package main

import (
	"electricity_bill_calc/config"
	"electricity_bill_calc/global"
	"electricity_bill_calc/model"
	"electricity_bill_calc/router"
	"electricity_bill_calc/utils"
	"encoding/csv"
	"fmt"
	"io"
	"log"
	"os"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
)

func init() {
	err := config.SetupSetting()
	if err != nil {
		log.Fatalf("Configuration load failed: %v", err)
	}
	log.Println("Configuration loaded!")

	err = global.SetupDatabaseConnection()
	if err != nil {
		log.Fatalf("Main Database connect failed: %v", err)
	}
	log.Println("Main Database connected!")

	err = global.DBConn.Sync(
		&model.Region{},
		&model.User{},
		&model.UserDetail{},
		&model.UserCharge{},
		&model.Park{},
		&model.Meter04KV{},
		&model.MaintenanceFee{},
		&model.Report{},
		&model.ReportSummary{},
		&model.WillDilutedFee{},
		&model.EndUserDetail{})
	if err != nil {
		log.Fatalf("Database structure synchronize failed: %v", err)
	}
	log.Println("Database structure synchronized.")

	err = global.SetupRedisConnection()
	if err != nil {
		log.Fatalf("Main Cache Database connect failed: %v", err)
	}
	log.Println("Main Cache Database connected!")

	err = initializeRegions()
	if err != nil {
		log.Fatalf("Regions initialize failed: %v", err)
	}
	log.Println("Regions synchronized.")
}

func initializeRegions() error {
	log.Println("Synchronize regions...")
	regionCsvFile, err := os.Open("regions.csv")
	if err != nil {
		return fmt.Errorf("region initialize file is not found: %w", err)
	}
	defer regionCsvFile.Close()

	var existRegions = make([]string, 0)
	err = global.DBConn.Table("region").Cols("code").Find(&existRegions)
	if err != nil {
		return fmt.Errorf("unable to retreive regions from database: %w", err)
	}

	regionCsv := csv.NewReader(regionCsvFile)
	transaction := global.DBConn.NewSession()
	defer transaction.Close()
	if err = transaction.Begin(); err != nil {
		return fmt.Errorf("unable to intiate database transaction: %w", err)
	}
	for {
		record, err := regionCsv.Read()
		if err == io.EOF {
			break
		}
		if utils.Contains(record[0], existRegions) {
			continue
		}
		level, err := strconv.Atoi(record[2])
		if err != nil {
			continue
		}
		if _, err = transaction.Insert(&model.Region{Code: record[0], Name: record[1], Level: level, Parent: record[3]}); err != nil {
			return fmt.Errorf("region synchronize in failed: %v, %w", record, err)
		}
	}
	if err = transaction.Commit(); err != nil {
		return fmt.Errorf("synchronize regions to database failed: %w", err)
	}
	return nil
}

func DBConnectionKeepLive() {
	for range time.Tick(30 * time.Second) {
		err := global.DBConn.Ping()
		if err != nil {
			continue
		}
	}
}

func main() {
	go DBConnectionKeepLive()
	gin.SetMode(config.ServerSettings.RunMode)
	r := router.Router()
	r.Run(fmt.Sprintf(":%d", config.ServerSettings.HttpPort))
}