package node

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/dao"
	"nodeMonitor/internal/model"
	"nodeMonitor/internal/model/do"
	"nodeMonitor/internal/model/entity"
	"nodeMonitor/internal/service"
	"time"
)

type (
	sNode struct{}
)

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

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

// Create 创建节点
func (c *sNode) Create(ctx context.Context, input model.NodeCreateInput) error {
	return dao.Node.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		_, err := dao.Node.Ctx(ctx).Data(do.Node{
			Name:     input.Name,
			Host:     input.Host,
			Port:     input.Port,
			Url:      input.Url,
			PingType: input.PingType,
			NodeMs:   0,
		}).Insert()
		return err
	})
}
func (c *sNode) FindServer(ctx context.Context, host string) (*entity.Node, error) {
	var data *entity.Node
	err := dao.Node.Ctx(ctx).Where("host", host).Scan(&data)
	if err != nil {
		return nil, err
	}
	return data, nil
}

// UpdateNodeMs 更新节点延迟1
func (c *sNode) UpdateNodeMs(ctx context.Context, input model.NodeUpdateInput) error {
	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": input.ServerId,
	}).Update(g.Map{
		"node_ms": input.NodeMs,
	})
	return err
}

func (c *sNode) GetLasDowTime(ctx context.Context, serverid int) (*gtime.Time, error) {
	var data *entity.Node
	err := dao.Node.Ctx(ctx).Where("id", serverid).Scan(&data)
	if err != nil {
		return nil, err
	}
	return data.LastDownTime, nil
}

func (c *sNode) UpdateNodeLasDowTime(ctx context.Context, serverid int, lastDownTime *gtime.Time) error {
	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": serverid,
	}).Update(g.Map{
		"last_down_time": lastDownTime,
	})
	return err
}

func (c *sNode) UpdateAllNodeMs(ctx context.Context) error {
	_, err := dao.Node.Ctx(ctx).Update(g.Map{
		"nodeMs": 0,
	})
	return err
}

// Del 删除节点
func (c *sNode) Del(ctx context.Context, input model.NodeDelInput) error {
	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": input.Id,
	}).Delete()
	return err
}

// IsExist 节点是否存在
func (c *sNode) IsExist(ctx context.Context, host string) (bool, error) {
	count, err := dao.Node.Ctx(ctx).Where(g.Map{
		"host": host,
	}).Count()
	if err != nil {
		return false, err
	}
	return count == 0, nil
}

// UpdateNode 更新指定节点
func (c *sNode) UpdateNode(ctx context.Context, input model.NodeEditInput) error {
	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": input.Id,
	}).Update(g.Map{
		"host":        input.Host,
		"name":        input.Name,
		"port":        input.Port,
		"url":         input.Url,
		"url_Recover": input.UrlRecover,
		"ping_type":   input.PingType,
		"url_status":  input.UrlStatus,
		"is_notice":   input.IsNotice,
	})
	return err
}

// GetNode 获取全部数据
func (c *sNode) GetNode(ctx context.Context) ([]*entity.Node, error) {
	var nodeList []*entity.Node
	err := dao.Node.Ctx(ctx).OrderDesc("create_at").Scan(&nodeList)
	return nodeList, err
}

// GetNodePingStatus 获取节点监控结果
func (c *sNode) GetNodePingStatus(ctx context.Context) ([]*model.UserItem, error) {
	//查询10分钟内的数据
	//startTime, err := g.Cfg().Get(ctx, "node.startTime")
	//if err != nil {
	//	glog.Debug(ctx, err.Error())
	//	return nil, err
	//}

	timeStartStr := gtime.Now().Add(-7200 * time.Second).String()
	timeEnd := gtime.Now().String()
	var nodeList []*model.UserItem

	err := dao.Node.Ctx(ctx).OrderDesc("create_at").ScanList(&nodeList, "Node")
	if err != nil {
		return nil, err
	}
	//获取2个小时内的数据
	err = dao.Pinglog.Ctx(ctx).Where("serverid", gdb.ListItemValuesUnique(nodeList, "Node", "Id")).WhereBetween("create_at", timeStartStr, timeEnd).OrderDesc("create_at").ScanList(&nodeList, "PingLog", "Node", "serverid=id")
	glog.Debug(ctx, timeStartStr)
	if err != nil {
		return nil, err
	}

	return nodeList, nil
}

// FindNode 获取指定节点数据
func (c *sNode) FindNode(ctx context.Context, id int) (*entity.Node, error) {
	var nodeList *entity.Node
	err := dao.Node.Ctx(ctx).Where("id = ?", id).Scan(&nodeList)
	return nodeList, err
}

// 查询节点MS等于0的线路
func (c *sNode) FindNodeMs(ctx context.Context) ([]*entity.Node, error) {
	var nodeList []*entity.Node
	err := dao.Node.Ctx(ctx).Where("nodeMs = 0").OrderDesc("create_at").Scan(&nodeList)
	return nodeList, err
}

// UpdateNodeUrlStatus 更新节点url是否执行完成
func (c *sNode) UpdateNodeUrlStatus(ctx context.Context, input model.NodeCreateInput) error {
	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"host": input.Host,
	}).Update(g.Map{
		"url_status": input.UrlStatus,
	})
	return err
}

// 获取节点执行次数
func (c *sNode) GetNodeUrlCount(ctx context.Context, id int) (*entity.Node, error) {
	var ccc *entity.Node
	err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": id,
	}).Scan(&ccc)

	return ccc, err
}

// 更新执行次数
func (c *sNode) UPdateNodeUrlCount(ctx context.Context, id int, urlCount int, urlret string, urlstatus int) error {

	_, err := dao.Node.Ctx(ctx).Where(g.Map{
		"id": id,
	}).Update(g.Map{
		"urlCount":   urlCount,
		"url_status": urlstatus,
		"urlRet":     urlret,
	})
	return err
}