package pinglog

import (
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/glog"
	"github.com/gogf/gf/v2/os/gtime"
	"golang.org/x/net/context"
	"nodeMonitor/internal/consts"
	"nodeMonitor/internal/dao"
	"nodeMonitor/internal/model"
	"nodeMonitor/internal/model/do"
	"nodeMonitor/internal/service"
)

type (
	sPing struct{}
)

func init() {
	service.RegisterPing(New())
}

func New() *sPing {
	return &sPing{}
}

// Create 创建延迟日志
func (c *sPing) Create(ctx context.Context, ping model.PingSt, setverid int) error {
	return dao.Pinglog.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		_, err := dao.Pinglog.Ctx(ctx).Data(do.Pinglog{
			Maxdelay: ping.MaxDelay,
			Mindelay: ping.MinDelay,
			Avgdelay: ping.AvgDelay,
			Losspk:   ping.LossPk,
			Serverid: setverid,
		}).Insert()
		return err
	})
}

func (c *sPing) GetHyStatus(ctx context.Context, ping model.PingSt, serverid int) (bool, error) {

	pingConfig, err := service.PingConfig().Get(ctx)
	if err != nil {
		glog.Debug(ctx, err.Error())
		return false, err
	}

	// 查询节点上一次有离线记录的时间
	var lastDownTime *gtime.Time
	err = dao.Pinglog.Ctx(ctx).
		Where("avgdelay = 0").
		Where("losspk > ?", pingConfig.NodeLoos).
		Where("maxdelay = 0").
		Where("serverid = ?", serverid).
		OrderDesc("create_at").
		Limit(1).
		Scan(&lastDownTime)
	if err != nil {
		glog.Debug(ctx, err.Error())
		return false, err
	}

	// 如果没有找到上一次的离线记录，返回 false
	if lastDownTime == nil {
		return false, nil
	}

	return true, nil
}

// GetStatus 查询节点状态
// SELECT *  FROM pinglog WHERE create_at >= DATE_SUB(NOW(),INTERVAL 10 MINUTE) and avgdelay = 0  and losspk >= 0 and maxdelay = 0 and `serverid` = '1'gf
func (c *sPing) GetStatus(ctx context.Context, serverid int) (consts.NodeStatus, error) {
	//查询10分钟内的数据
	startTime, err := g.Cfg().Get(ctx, "node.startTime")
	if err != nil {
		glog.Debug(ctx, err.Error())
		return consts.Normal, err
	}
	//查询的数据超过3次就是不ok了
	//loos, err := g.Cfg().Get(ctx, "node.loos")
	//if err != nil {
	//	glog.Debug(ctx, err.Error())
	//	return false, err
	//}

	// 获取 ping 配置
	pingConfig, err := service.PingConfig().Get(ctx)
	if err != nil {
		glog.Debug(ctx, err.Error())
		return consts.Normal, err
	}

	// 查询最近10分钟内的 ping 日志，判断节点是否不通
	failCount, err := dao.Pinglog.Ctx(ctx).
		Where("create_at > DATE_SUB(NOW(), INTERVAL ? MINUTE)", startTime).
		Where("avgdelay = 0").
		Where("losspk > ?", pingConfig.NodeLoos).
		Where("maxdelay = 0").
		Where("serverid = ?", serverid).
		Count()
	if err != nil {
		glog.Debug(ctx, err.Error())
		return consts.Normal, err
	}

	// 如果节点当前是离线状态
	if failCount >= pingConfig.NodeDie {
		// Node is down
		return consts.Down, nil
	}

	// 查询节点上一次有离线记录的时间
	var lastDownTime *gtime.Time
	err = dao.Pinglog.Ctx(ctx).
		Where("avgdelay = 0").
		Where("losspk > ?", pingConfig.NodeLoos).
		Where("maxdelay = 0").
		Where("serverid = ?", serverid).
		OrderDesc("create_at").
		Limit(1).
		Scan(&lastDownTime)
	if err != nil {
		glog.Debug(ctx, err.Error())
		return consts.Normal, err
	}

	// 如果没有找到上一次的离线记录，返回 Normal
	if lastDownTime == nil {
		return consts.Normal, nil
	}

	// 查询最近10分钟内的 ping 日志，判断节点是否恢复
	successCount, err := dao.Pinglog.Ctx(ctx).
		Where("create_at > ?", lastDownTime).
		Where("avgdelay > 0").
		Where("serverid = ?", serverid).
		Count()
	if err != nil {
		glog.Debug(ctx, err.Error())
		return consts.Normal, err
	}

	// 如果节点之前是离线状态且现在恢复了，返回 Recovered
	if successCount >= pingConfig.NodeRecover {
		return consts.Recovered, nil
	}

	// 返回正常状态
	return consts.Normal, nil

}

func (c *sPing) ClearLog(ctx context.Context) {
	clearLogTime, err := g.Cfg().Get(ctx, "node.clearLogTime")
	if err != nil {
		glog.Debug(ctx, err.Error())
		return
	}
	timeStartStr := gtime.Now().AddDate(0, 0, -clearLogTime.Int()).String()
	glog.Info(ctx, timeStartStr)
	_, err = dao.Pinglog.Ctx(ctx).Where("create_at <= ?", timeStartStr).Delete()
	if err != nil {
		glog.Error(ctx, err)
		return
	}
}