package v1

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/data"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/controller"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model/agent"
	devc "git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model/device"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model/message"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/errors"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/request"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/service"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/validator"
	"github.com/gin-gonic/gin"
	"strings"
	"time"
)

// 每30s的健康检查接口
func CheckHeartBeat(c *gin.Context) {
	device := &devc.DeviceInfo{}
	err := validator.CheckPostParams(c, device)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	_, err = device.SaveHealth()
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, "保存成功！")
}

// 设备基础信息上报
func PushDeviceInfo(c *gin.Context) {
	device := &devc.DeviceInfo{}
	err := validator.CheckPostParams(c, device)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	_, err = device.SaveBase()
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, "保存成功！")
}

type PageBodyDevice struct {
	PageInfo *request.PageInfo `json:"pageInfo" binding:"required"`
	Name     string            `json:"name"`
	IsNew    string            `json:"isNew"`
}

// 分页查询设备信息-关联资产属性
func PageDevices(c *gin.Context) {
	var pageBody PageBodyDevice
	err := c.ShouldBindJSON(&pageBody)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	device := &devc.AssetDeviceInfo{}
	fields := map[string]interface{}{}
	if pageBody.Name != "" {
		fields["pr.name"] = pageBody.Name
	}
	if pageBody.IsNew != "" {
		fields["is_new"] = pageBody.IsNew
	}
	page := &model.Page[devc.AssetDeviceInfo]{}
	page.Covert(pageBody.PageInfo)
	err = device.Page(page, fields)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, page)

}

// 统计设备升级数统计
func CountDeviceUpgrade(c *gin.Context) {
	fields := map[string]interface{}{}
	device := &devc.DeviceInfo{}
	result, err := device.CountUpgradeNum(fields)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	controller.Success(c, result)
}

// 获取设备基本信息
func GetDeviceInfo(c *gin.Context) {
	device := &devc.AssetDeviceInfo{}
	serialNo := c.Param("serialNo")
	fields := map[string]interface{}{}
	fields["serial_no"] = serialNo
	asset, err := device.Get(fields)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	controller.Success(c, asset)
}

// 获取设备的组件列表信息
func ListDeviceConfigs(c *gin.Context) {
	serialNo := c.Param("serialNo")
	device := &devc.AssetDeviceInfo{}
	fields := map[string]interface{}{}
	fields["serial_no"] = serialNo
	_, err := device.Get(fields)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "未找到设备！")
		return
	}
	sub := strings.ReplaceAll(message.TO_AGENT_UNICAST_SUBJECT, "{rid}", serialNo)
	dat := message.MsgModel{
		Body:    nil,
		Func:    message.FUNC_COMPONENTINFO,
		Rid:     serialNo,
		Version: "v1",
	}
	payload, _ := json.Marshal(dat)
	msg, err := data.Nc.Request(sub, payload, 6*time.Second)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	res, err := message.UnmarshalMsgRespModel(msg.Data)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "无法解析的消息格式！")
		return
	}
	if res.Code != 200 {
		controller.FailCode(c, errors.ServerError, err, "小助手消息错误！")
		return
	}
	deStr, err := base64.StdEncoding.DecodeString(fmt.Sprint(res.Data))
	result := make([]map[string]interface{}, 0)
	json.Unmarshal(deStr, &result)
	controller.Success(c, result)
}

// 创建设备升级记录
func CreateDeviceUpgradeRecord(c *gin.Context) {
	record := &devc.DeviceUpgradeRecord{}
	err := validator.CheckPostParams(c, record)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	_, err = record.Create()
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, "")
}

type PageBodyRecord struct {
	PageInfo *request.PageInfo `json:"pageInfo" binding:"required"`
}

// 获取设备升级记录
func PageDeviceUpgradeRecord(c *gin.Context) {
	var pageBody PageBodyRecord
	err := c.ShouldBindJSON(&pageBody)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	serialNo := c.Param("serialNo")
	fields := map[string]interface{}{}
	fields["serial_no"] = serialNo

	record := &devc.DeviceUpgradeRecord{}
	page := &model.Page[devc.UpgradeRecord]{}
	page.Covert(pageBody.PageInfo)
	err = record.Page(page, fields)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, page)
}

// 创建设备升级规则
func CreateDeviceUpgradeRule(c *gin.Context) {
	rule := &devc.DeviceUpgradeRule{}
	err := validator.CheckPostParams(c, rule)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	//企业+一体机类型唯一
	fields := map[string]interface{}{}
	fields["vendor_id"] = rule.VendorId
	rules, err := rule.ListAll(fields)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	if len(rules) > 0 && rule.DeviceType == "0" {
		controller.FailCode(c, errors.InvalidParameter, err, "与已有公司规则冲突！")
		return
	}
	for _, r := range rules {
		if r.DeviceType == rule.DeviceType || r.DeviceType == "0" {
			controller.FailCode(c, errors.InvalidParameter, err, "与已有公司规则冲突！")
			return
		}
	}
	num, err := rule.Create()
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "创建失败！")
		return
	}
	if num > 0 {
		go func(ru devc.DeviceUpgradeRule) {
			rules := make([]devc.DeviceUpgradeRule, 0)
			rules = append(rules, ru)
			if err == nil && len(rules) > 0 {
				_ = service.SendUpgradePlans(rules, "create")
			}
		}(*rule)
	}
	controller.Success(c, "保存成功！")
}

type PageRule struct {
	PageInfo *request.PageInfo `json:"pageInfo" binding:"required"`
	VendorId string            `json:"vendorId"`
}

// 获取设备升级规则
func PageDeviceUpgradeRule(c *gin.Context) {
	var pageBody PageRule
	err := c.ShouldBindJSON(&pageBody)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	fields := map[string]interface{}{}
	if pageBody.VendorId != "" {
		fields["vendor_id"] = pageBody.VendorId
	}
	rule := &devc.DeviceUpgradeRule{}
	page := &model.Page[devc.DeviceUpgradeRule]{}
	page.Covert(pageBody.PageInfo)
	err = rule.Page(page, fields)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	controller.Success(c, page)
}

type DeleteUpgradeRuleBody struct {
	Ids []int64 `json:"ids" binding:"required"`
}

// 删除设备升级规则
func DeleteDeviceUpgradeRule(c *gin.Context) {
	rule := &devc.DeviceUpgradeRule{}
	var deleteBody DeleteUpgradeRuleBody
	err := c.ShouldBindJSON(&deleteBody)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	rules, err := rule.GetBatch(deleteBody.Ids)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	var num int64
	if len(rules) > 0 {
		num, err = rule.DeleteBatch(deleteBody.Ids)
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "删除失败！")
			return
		}
	}
	if num > 0 {
		go func(rules []devc.DeviceUpgradeRule) {
			_ = service.SendUpgradePlans(rules, "delete")
		}(rules)
	}
	controller.Success(c, "删除成功！")
}

// 触发升级命令
func DoDeviceUpgrade(c *gin.Context) {
	serialNo := c.Param("serialNo")
	device := &devc.AssetDeviceInfo{}
	fields := map[string]interface{}{}
	fields["serial_no"] = serialNo
	d, err := device.Get(fields)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "未找到设备！")
		return
	}

	aget := &agent.AgentInfo{}
	agents, err := aget.ListLastVersion()
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "未查询到最新版本！")
		return
	}
	for _, a := range agents {
		if strings.ToLower(a.OsType) == strings.ToLower(d.OsType) && strings.ToLower(a.ArchType) == strings.ToLower(d.ArchType) {
			aget = &a
			break
		}
	}
	plan, err := service.GetUpgradeCommandNow(aget)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "未找到小助手包！")
		return
	}
	body, _ := json.Marshal(plan)
	dat := message.MsgModel{
		Body:    body,
		Func:    message.FUNC_UPGRADEIMMEDIATELY,
		Rid:     serialNo,
		Version: "v1",
	}
	payload, _ := json.Marshal(dat)
	sub := strings.ReplaceAll(message.TO_AGENT_UNICAST_SUBJECT, "{rid}", serialNo)
	msg, err := data.Nc.Request(sub, payload, 6*time.Second)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误，下发通知失败！")
		return
	}
	res, err := message.UnmarshalMsgRespModel(msg.Data)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "消息格式错误，下发通知失败！")
		return
	}
	if res.Code != 200 {
		controller.FailCode(c, errors.ServerError, err, "下发通知失败！")
		return
	}
	controller.Success(c, "已通知，自动升级！")
}