package models

import (
	"context"
	"time"

	"github.com/satori/go.uuid"

	"basic.com/valib/logc.git"
	"basic.com/valib/logger.git"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

var (
	db             *gorm.DB
	logSetsDb      *gorm.DB
	opChan         chan *OperationLog
	scheduleChan   chan *ScheduleLog
	ruleServerChan chan *logc.RuleServerPushLog
	vaSystemChan   chan *logc.VaSystemLog
)

func Init(dbPath, logSetsDbPath string, ctx context.Context) {
	var err error

	db, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{})

	if err != nil {
		logger.Debug("db open error ", err)
		return
	}
	_ = db.AutoMigrate(OperationLog{}, ScheduleLog{}, RuleServerLog{}, VaSystemLog{})

	opChan = make(chan *OperationLog, 100)
	scheduleChan = make(chan *ScheduleLog, 100)
	ruleServerChan = make(chan *logc.RuleServerPushLog, 100)
	vaSystemChan = make(chan *logc.VaSystemLog, 100)

	go saveToDb(ctx)

	logSetsDb, err = gorm.Open(sqlite.Open(logSetsDbPath), &gorm.Config{})
	if err != nil {
		logger.Debug("log sets db open error ", err)
		return
	}

	_ = logSetsDb.AutoMigrate(Modules{}, Operations{})
	//db.SetLogger(&DbLogger{})
}

func saveToDb(ctx context.Context) {
	tc := time.Tick(time.Second * 2)
	var listOp []*OperationLog
	var listSchedule []*ScheduleLog
	var listRuleServer RuleServerLog
	var objVaSystemLog VaSystemLog

	maxSize := 50

	for {
		select {
		case <-ctx.Done():
			logger.Warn("saveToDb quit")
			return
		case <-tc:
			if len(listOp) > 0 {
				startTime := time.Now()
				db.CreateInBatches(listOp, len(listOp))
				logger.Info("saveToDb save operation log time cost:", time.Since(startTime).Milliseconds(), len(listOp))
				listOp = append([]*OperationLog{})
			}

			if len(listSchedule) > 0 {
				startTime := time.Now()
				db.CreateInBatches(listSchedule, len(listSchedule))
				logger.Info("saveToDb save schedule log time cost:", time.Since(startTime).Milliseconds(), len(listSchedule))
				listSchedule = append([]*ScheduleLog{})
			}
		case log := <-opChan:
			listOp = append(listOp, log)
			if len(listOp) >= maxSize {
				startTime := time.Now()
				db.CreateInBatches(listOp, len(listOp))
				logger.Info("saveToDb save operation log time cost:", time.Since(startTime).Milliseconds(), len(listOp))
				listOp = append([]*OperationLog{})
			}
		case log := <-scheduleChan:
			listSchedule = append(listSchedule, log)
			if len(listSchedule) >= maxSize {
				startTime := time.Now()
				db.CreateInBatches(listSchedule, len(listSchedule))
				logger.Info("saveToDb save schedule log time cost:", time.Since(startTime).Milliseconds(), len(listSchedule))
				listSchedule = append([]*ScheduleLog{})
			}

		case log := <-ruleServerChan:
			logger.Info("recive ruleserver :", log.ID, log.TaskName, log.Type, log.Info)
			listRuleServer.ID = log.ID
			if logc.UpdateTaskState == log.Type {
				listRuleServer.Name = log.TaskName
				listRuleServer.State = log.Info
				listRuleServer.CreateDate = time.Now().Format("2006-01-02 15:04:05")
				listRuleServer.LastSendDate = time.Now().Format("2006-01-02 15:04:05")
				err := listRuleServer.Insert()
				logger.Info("saveToDb save ruleserver UpdateTaskState:", err)
			} else if logc.IncreaseSuccess == log.Type {
				err := listRuleServer.TotalSuccessIncrement()
				logger.Info("saveToDb save ruleserver IncreaseSuccess:", err)
			} else if logc.IncreaseFailure == log.Type {
				err := listRuleServer.TotalFailureIncrement()
				logger.Info("saveToDb save ruleserver IncreaseFailure:", err)
			} else if logc.UpdateCacheCount == log.Type {
				listRuleServer.TotalCached = log.Info
				err := listRuleServer.TotalCachedSet()
				logger.Info("saveToDb save ruleserver UpdateCacheCount:", err)
			} else if logc.UpdateLastState == log.Type {
				listRuleServer.LastSendState = log.Info
				err := listRuleServer.LastStateSet()
				logger.Info("saveToDb save ruleserver UpdateLastState:", err)
			} else if logc.ReduceFailure == log.Type {
				err := listRuleServer.ReduceFailure()
				logger.Info("saveToDb save ruleserver ReduceFailure:", err)
			}
		case msg := <-vaSystemChan:
			logger.Info("recive vasystem log :", msg.ID, msg.ProcName, msg.Level, msg.Info)

			objVaSystemLog.ID = uuid.NewV4().String()
			objVaSystemLog.HostName = msg.HostName
			objVaSystemLog.ProcName = msg.ProcName
			objVaSystemLog.ProcID = msg.ProcID
			objVaSystemLog.Level = msg.Level
			objVaSystemLog.Info = msg.Info
			objVaSystemLog.Timestamp = time.Now().Unix()
			objVaSystemLog.CreateDate = time.Now().Format("2006-01-02 15:04:05")

			err := objVaSystemLog.Insert()
			if err != nil {
				logger.Info("saveToDb save vasystem error:", err)
			}
		}
	}
}

func GetDB() *gorm.DB {
	return db
}

func GetLogSetsDb() *gorm.DB {
	return logSetsDb
}

func CloseDB() {

}