package controllers

import (
	"fmt"
	"net/http"
	"sort"
	"strconv"
	"strings"
	"xugu_license/internal/api"
	"xugu_license/internal/global"
	middlewares "xugu_license/internal/middleware"
	"xugu_license/internal/models"
	"xugu_license/internal/module/capture"
	"xugu_license/internal/services"
	"xugu_license/internal/utils"

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

func getLoginInfo(c *gin.Context) (*middlewares.UserAuthInfo, error) {
	//获取当前登录用户信息
	userAny, exists := c.Get("userInfo")
	if !exists {
		global.Logger.Errorln("GetLicenseInfo: 用户信息不存在")
		return nil, errors.New("GetLicenseInfo: 用户信息不存在")
		// c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
		// c.Abort()

	}

	userInfo := userAny.(*middlewares.UserAuthInfo)
	return userInfo, nil
}

func GetSingleLicenseInfoController(c *gin.Context) {

	// userInfo, err := getLoginInfo(c)
	// if err != nil {
	// 	c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
	// 	c.Abort()
	// }

	//获取请求参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))
	LicUniqueID := c.DefaultQuery("LicUniqueID", "10")

	//获取指定的license信息
	applications, total, err := models.GetOALicenseInfo(page, pageSize, "", LicUniqueID, "", 0)
	if err != nil {
		global.Logger.Errorln("指定UniqueID查询错误：", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("指定UniqueID查询错误: ", err.Error())})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"data":     *applications,
		"page":     1,
		"pageSize": 1,
		"total":    total,
	})

}

func GetAllLicenseInfoController(c *gin.Context) {
	//获取请求参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "10"))
	//获取用户信息和权限
	userInfo, err := getLoginInfo(c)
	if err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
		c.Abort()
	}
	// if t := userInfo.Permission[middlewares.ReadAllLicense]; t == middlewares.ReadAllLicense {

	// }
	var datas [][]api.AllLicenseInfoResponse
	var Total int
	// 初始化存储 `OARequestID` 相同的 `ApiLicenseInfoTemp` 列表的 map
	oaRequestIDMap := make(map[int64][]api.AllLicenseInfoResponse)
	if userInfo.Permission[middlewares.ReadAllLicense] == middlewares.ReadAllLicense {
		datas1, total, err := models.GetOALicenseInfo(pageSize, page, "read_all_license", "", "", 0)
		if err != nil {
			global.Logger.Errorln("error", err.Error())
			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
			return
		}
		Total = total

		//var ApiLicenseInfoTemp []api.AllLicenseInfoResponse
		for _, data := range *datas1 {

			ApiLicenseInfo := api.AllLicenseInfoResponse{
				UniqueID:               utils.ToString(data.LicInfo.UniqueID),
				OAId:                   utils.ToInt64(data.LicInfo.OAId),
				OARequestID:            utils.ToInt64(data.LicInfo.OARequestID),
				OARequestName:          utils.ToString(data.LicInfo.OARequestName),
				OARequestNameNew:       utils.ToString(data.LicInfo.OARequestNameNew),
				OARequestNameHTMLNew:   utils.ToString(data.LicInfo.OARequestNameHTMLNew),
				OAGLXMId:               utils.ToInt64(data.LicInfo.OAGLXMID),
				OAGLXMName:             utils.ToString(data.LicInfo.OAGLXMName),
				OASQSJ:                 utils.ToString(data.LicInfo.OASQSJ),
				OASalespersonName:      utils.ToString(data.LicInfo.OASalespersonName),
				OAXSJSYX:               utils.ToString(data.LicInfo.OAXSJSYX),
				OAOperationsPersonName: utils.ToString(data.LicInfo.OAOperationsPersonName),
				OAJFJSYX:               utils.ToString(data.LicInfo.OAJFJSYX),
				OASYDW:                 utils.ToString(data.LicInfo.OASYDW),
				OAXMXXMS:               utils.ToString(data.LicInfo.OAXMXXMS),
				OAJDS:                  utils.ToInt64(data.LicInfo.OAJDS),
				OANodeCount:            utils.ToInt64(data.LicInfo.OANodeCount),
				OAProductCode:          utils.ToString(data.LicInfo.OAProductCode),
				OAProductName:          utils.ToString(data.LicInfo.OAProductName),
				OAProductVersion:       utils.ToString(data.LicInfo.OAProductVersion),
				OACPU:                  utils.ToString(data.LicInfo.OACPU),
				OAOperatingSystem:      utils.ToString(data.LicInfo.OAOperatingSystem),
				OAMainMAC:              utils.ToString(data.LicInfo.OAMainMAC),
				OASecondMAC:            utils.ToString(data.LicInfo.OASecondMAC),
				OACreationDate:         utils.ToString(data.LicInfo.OACreationDate),
				OACreationTime:         utils.ToString(data.LicInfo.OACreationTime),
				OALastOperateDate:      utils.ToString(data.LicInfo.OALastOperateDate),
				OALastOperateTime:      utils.ToString(data.LicInfo.OALastOperateTime),
				CaptureTime:            utils.ToTimeString(data.LicInfo.CaptureTime),
				DelTime:                utils.ToTimeString(data.LicInfo.DelTime),
				LastOperateTime:        utils.ToTimeString(data.LicInfo.LastOperateTime),
				LicenseFlage:           utils.ToString(data.GenrateInfo.LicenseFlage),
				Lic1:                   utils.ToString(data.GenrateInfo.Lic1),
				Lic2:                   utils.ToString(data.GenrateInfo.Lic2),
				CreatorGenerate:        utils.ToTimeString(data.GenrateInfo.CreatorGenerate),
			}
			// 将 `ApiLicenseInfo` 添加到 `OARequestID` 对应的数组中
			oaRequestID := utils.ToInt64(data.LicInfo.OARequestID)
			oaRequestIDMap[oaRequestID] = append(oaRequestIDMap[oaRequestID], ApiLicenseInfo)

		}

	} else if userInfo.Permission[middlewares.ReadLicense] == middlewares.ReadLicense {
		datas1, total, err := models.GetOALicenseInfo(pageSize, page, "", "", userInfo.UniqueID, 0)
		if err != nil {
			global.Logger.Errorln("error", err.Error())
			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
			return
		}
		Total = total

		//var ApiLicenseInfoTemp []api.AllLicenseInfoResponse
		for _, data := range *datas1 {

			ApiLicenseInfo := api.AllLicenseInfoResponse{
				UniqueID:               utils.ToString(data.LicInfo.UniqueID),
				OARequestID:            utils.ToInt64(data.LicInfo.OARequestID),
				OARequestName:          utils.ToString(data.LicInfo.OARequestName),
				OARequestNameNew:       utils.ToString(data.LicInfo.OARequestNameNew),
				OARequestNameHTMLNew:   utils.ToString(data.LicInfo.OARequestNameHTMLNew),
				OAGLXMId:               utils.ToInt64(data.LicInfo.OAGLXMID),
				OAGLXMName:             utils.ToString(data.LicInfo.OAGLXMName),
				OASQSJ:                 utils.ToString(data.LicInfo.OASQSJ),
				OASalespersonName:      utils.ToString(data.LicInfo.OASalespersonName),
				OAXSJSYX:               utils.ToString(data.LicInfo.OAXSJSYX),
				OAOperationsPersonName: utils.ToString(data.LicInfo.OAOperationsPersonName),
				OAJFJSYX:               utils.ToString(data.LicInfo.OAJFJSYX),
				OASYDW:                 utils.ToString(data.LicInfo.OASYDW),
				OAXMXXMS:               utils.ToString(data.LicInfo.OAXMXXMS),
				OAJDS:                  utils.ToInt64(data.LicInfo.OAJDS),
				OANodeCount:            utils.ToInt64(data.LicInfo.OANodeCount),
				OAProductCode:          utils.ToString(data.LicInfo.OAProductCode),
				OAProductName:          utils.ToString(data.LicInfo.OAProductName),
				OAProductVersion:       utils.ToString(data.LicInfo.OAProductVersion),
				OACPU:                  utils.ToString(data.LicInfo.OACPU),
				OAOperatingSystem:      utils.ToString(data.LicInfo.OAOperatingSystem),
				OAMainMAC:              utils.ToString(data.LicInfo.OAMainMAC),
				OASecondMAC:            utils.ToString(data.LicInfo.OASecondMAC),
				OACreationDate:         utils.ToString(data.LicInfo.OACreationDate),
				OACreationTime:         utils.ToString(data.LicInfo.OACreationTime),
				OALastOperateDate:      utils.ToString(data.LicInfo.OALastOperateDate),
				OALastOperateTime:      utils.ToString(data.LicInfo.OALastOperateTime),
				CaptureTime:            utils.ToTimeString(data.LicInfo.CaptureTime),
				DelTime:                utils.ToTimeString(data.LicInfo.DelTime),
				LastOperateTime:        utils.ToTimeString(data.LicInfo.LastOperateTime),
				LicenseFlage:           utils.ToString(data.GenrateInfo.LicenseFlage),
				Lic1:                   utils.ToString(data.GenrateInfo.Lic1),
				Lic2:                   utils.ToString(data.GenrateInfo.Lic2),
				CreatorGenerate:        utils.ToTimeString(data.GenrateInfo.CreatorGenerate),
			}
			// 将 `ApiLicenseInfo` 添加到 `OARequestID` 对应的数组中
			oaRequestID := utils.ToInt64(data.LicInfo.OARequestID)
			oaRequestIDMap[oaRequestID] = append(oaRequestIDMap[oaRequestID], ApiLicenseInfo)
		}
	}

	// 将 `oaRequestIDMap` 中的所有 `ApiLicenseInfoTemp` 列表添加到 `datas` 中
	for _, apiLicenseInfoTemp := range oaRequestIDMap {
		datas = append(datas, apiLicenseInfoTemp)
	}
	// 对 datas 的第一维进行排序
	// sort.Slice(datas, func(i, j int) bool {
	// 	// 假设你需要根据每个数组第一个元素的 OACreationDate 和 OACreationTime 来排序
	// 	if datas[i][0].OACreationDate == datas[j][0].OACreationDate {

	// 		return datas[i][0].OACreationTime > datas[j][0].OACreationTime
	// 	}
	// 	return datas[i][0].OACreationDate > datas[j][0].OACreationDate
	// })
	// 对 datas 的第一维进行排序
	sort.Slice(datas, func(i, j int) bool {
		// 先按 OACreationDate 和 OACreationTime 排序
		if datas[i][0].OACreationDate == datas[j][0].OACreationDate {
			if datas[i][0].OACreationTime == datas[j][0].OACreationTime {
				// 如果 OACreationDate 和 OACreationTime 相同，则按 OARequestID 从大到小排序
				return datas[i][0].OARequestID > datas[j][0].OARequestID
			}
			return datas[i][0].OACreationTime > datas[j][0].OACreationTime
		}
		return datas[i][0].OACreationDate > datas[j][0].OACreationDate
	})

	c.JSON(http.StatusOK, gin.H{
		"data":     datas,
		"page":     page,
		"pageSize": pageSize,
		"total":    Total,
	})

}

func GenerateOALicenseStrController(c *gin.Context) {
	var request api.GenerateLicenseStrRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("解析request失败 ：  ", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("解析请求失败: ", err.Error()),
		})
		return
	}
	err, isCheck := services.GenerateOALicenseStrServices(request)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"error": fmt.Sprintf("生成错误: ", err.Error()),
		})
		return
	}
	if isCheck {
		c.JSON(http.StatusOK, gin.H{
			"error": fmt.Sprintf("该条信息校验不一致，请刷新页面: "),
		})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "License生成成功！",
	})

	// applications, _, err := models.GetOALicenseInfo(0, 1, "", request.UniqueID, "")
	// if err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
	// 	return
	// }
	// pj := license.ProjectInfo{
	// 	ProjectName:  utils.ToString((*applications)[0].LicInfo.OAProductName),
	// 	UserName:     utils.ToString((*applications)[0].LicInfo.OAProductVersion),
	// 	UserAddr:     "未填写",
	// 	SerialNumber: "未填写",
	// }
	// ei := license.EnvironmentInfo{
	// 	CpuSN:       "未填写",
	// 	BaseboardSN: "未填写",
	// 	MacAddr:     utils.ToString((*applications)[0].LicInfo.OAMainMAC),
	// 	DiskID:      "未填写",
	// 	IPAddr:      "未填写",
	// }
	// LicType := utils.SwitchLicenseType(utils.ToString((*applications)[0].LicInfo.OAProductName))
	// lI := license.LicenseInfo{
	// 	GenDate:        "2024-07-15",
	// 	ExpireDate:     "9999-12-31",
	// 	LicenseType:    LicType,
	// 	LicenseVersion: 1,
	// 	HardType:       3,
	// }

	//这里调用的是license模块中的生成license的方法
	// res := true
	// if res {
	// 	//生成副主节点license
	// 	if (*applications)[0].LicInfo.OASecondMAC.String != "" {
	// 		// var licStr2 []byte
	// 		// ei.MacAddr = applications[0].SecondaryMasterMacAddress
	// 		// licStr2 = license.GenerateLicense(pj, ei, lI)
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"))
	// 	} else {
	// 		//fmt.Println("licStr licStr2", licStr, licStr2)
	// 		//插入到数据库
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), nil)
	// 	}
	// } else {
	// 	licStr := license.GenerateLicense(pj, ei, lI)

	// 	//生成副主节点license
	// 	if (*applications)[0].LicInfo.OASecondMAC.String != "" {
	// 		var licStr2 []byte
	// 		ei.MacAddr = (*applications)[0].LicInfo.OASecondMAC.String
	// 		licStr2 = license.GenerateLicense(pj, ei, lI)
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), licStr, licStr2)
	// 	} else {
	// 		//插入到数据库
	// 		err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), licStr, nil)
	// 	}

	// }
	// if err != nil {
	// 	fmt.Println(err)
	// 	if err := c.ShouldBindJSON(&request); err != nil {
	// 		c.JSON(400, gin.H{
	// 			"error": err.Error(),
	// 		})
	// 		return
	// 	}
	// }
	// if err != nil {
	// 	fmt.Println(err)
	// 	if err := c.ShouldBindJSON(&request); err != nil {
	// 		global.Logger.Errorln("LicenseInfo数据查询失败： ", err.Error())
	// 		c.JSON(400, gin.H{
	// 			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
	// 		})
	// 		return
	// 	}
	// }

	//xlsx.ExcelToMail(lic, licStr, licStr2)
}

// func CheckDistributeOALicenseToOaDbController(c *gin.Context) {
// 	var CheckDisLicense struct {
// 		LicUniqueID string `json:"lic_unique_id"`
// 	}

// 	var request CheckDisLicense
// 	if err := c.ShouldBindJSON(&request); err != nil {
// 		global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
// 		c.JSON(400, gin.H{
// 			"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
// 		})
// 		return
// 	}
// 	//检测该数据是否与oa库数据库一致
// 	OALicenseInfo, err := models.CheckLicenseInfoInOADB((*applications)[0].LicInfo.ID)
// 	if err != nil {
// 		global.Logger.Errorln("LicenseInfo数据对比oa库 查询失败：  ", err.Error())
// 		//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
// 		return errors.Errorf("LicenseInfo数据对比oa库 查询失败 %v", err.Error())
// 	}

// 	checkTemp := CompareOALicenseInfo(&(*applications)[0], OALicenseInfo)
// 	//如果不一致，则修改源数据
// }

/*
对单条lic或是申请单的处理
检测lic是否以及分发过给用户
*/
func DistributeOALicenseController(c *gin.Context) {

	// //判断是否发邮件
	// //数据库查询license信息
	// var request api.DistributeLicenseRequest
	// if err := c.ShouldBindJSON(&request); err != nil {
	// 	global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
	// 	c.JSON(400, gin.H{
	// 		"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
	// 	})
	// 	return
	// }

	// EmailArray := strings.Split(request.Emails, ",")
	// err, existUsers := services.DistributeOALicenseServices(request.OperatorUniqueID, request.OaRequestId, request.UserUniqueIDs, request.UserAccounts, request.UserNames, EmailArray)
	// if err != nil {
	// 	global.Logger.Errorln("license分发失败  %s", err.Error())
	// 	c.JSON(400, gin.H{
	// 		"error": fmt.Sprintf("license分发失败  %s", err.Error()),
	// 	})
	// 	return
	// }
	// if existUsers != nil {
	// 	global.Logger.Errorf("license分发失败,以下用户已经分发过  %s")
	// 	c.JSON(400, gin.H{
	// 		"error": fmt.Sprintf("以下用户已经分发过  %s", existUsers),
	// 	})
	// 	return
	// }

	// c.JSON(http.StatusOK, gin.H{
	// 	"success": true,
	// 	"data":    "分发成功！",
	// })
}

func DistributeLicenseToUsersController(c *gin.Context) {
	var request api.DistributeLicenseRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
		})
		return
	}

	err, existUsers := services.DistributeLicenseToUserServices(request.OperatorUniqueID, request.OaRequestId, request.UserUniqueIDs, request.UserAccounts, request.UserNames)
	if err != nil {
		global.Logger.Errorln("license分发失败  %s", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("license分发失败  %s", err.Error()),
		})
		return
	}
	if existUsers != nil {
		global.Logger.Errorf("license分发失败,以下用户已经分发过  %s")
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("以下用户已经分发过  %s", existUsers),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    "分发成功！",
	})
}

func DistributeLicenseToEmailController(c *gin.Context) {
	//判断是否发邮件
	//数据库查询license信息
	var request api.DistributeLicenseRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("license分发请求解析失败  %s", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("license分发请求解析失败  %s", err.Error()),
		})
		return
	}

	EmailArray := strings.Split(request.Emails, ",")
	err, existUsers := services.DistributeLicenseToEmailServices(request.OperatorUniqueID, request.OaRequestId, request.UserUniqueIDs, request.UserAccounts, request.UserNames, EmailArray)
	if err != nil {
		global.Logger.Errorln("license分发失败  %s", err.Error())
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("license分发失败  %s", err.Error()),
		})
		return
	}
	if existUsers != nil {
		global.Logger.Errorf("license分发失败,以下用户已经分发过  %s")
		c.JSON(400, gin.H{
			"error": fmt.Sprintf("以下用户已经分发过  %s", existUsers),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    "分发成功！",
	})
}

// 获取分发历史
func GetlicenseRecordInfo(c *gin.Context) {
	// type licenseRecordInfoRequest struct {
	// 	UniqueID string `json:"uniqueID"`
	// 	Id       int    `json:"id"`
	// }

	var request api.GetDistributeHistoryRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		global.Logger.Errorln("解析请求失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("解析请求失败: ", err.Error()),
		})
		return
	}

	LicUers, err := models.GetlicenseRecordByUser(request.OaRequestId, request.UniqueID)
	if err != nil {
		global.Logger.Errorln("数据查询失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
		})
		return
	}
	LicEmails, err := models.GetlicenseRecordByEmail(request.OaRequestId, request.UniqueID)
	if err != nil {
		global.Logger.Errorln("数据查询失败 ", err.Error())

		c.JSON(400, gin.H{
			"error": fmt.Sprintf("数据查询失败: ", err.Error()),
		})
		return
	}
	licR := models.LicenseRecord{
		LicenseRecordToUser:   LicUers,
		LicenseRecordToEmails: LicEmails,
	}
	fmt.Println("分发历史applications", licR)
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    licR,
	})
}

// 更新license信息
func UpdateLicense(c *gin.Context) {

	var license api.UpdateLicenseInfoRequest
	// 绑定JSON数据到License结构体
	if err := c.ShouldBindJSON(&license); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   err.Error(),
		})
		return
	}
	//	fmt.Printf(" license.ApplicationDate: %#v ", license)
	err := models.UpdatelicenseInfoRow(models.OALicenseInfo{
		LicInfo: models.TargetOALicenseInfo{
			UniqueID:               utils.StringToNullString(license.UniqueID),
			OARequestName:          utils.StringToNullString(license.Creator),
			OACreationDate:         utils.StringToNullString(license.ApplicationDate),
			OAGLXMName:             utils.StringToNullString(license.AssociatedProject),
			OANodeCount:            utils.IntToNullInt64(license.NodeCount),
			OASalespersonName:      utils.StringToNullString(license.SalesPerson),
			OAOperationsPersonName: utils.StringToNullString(license.SupportPerson),
			OAXSJSYX:               utils.StringToNullString(license.SalesEmail),
			OAJFJSYX:               utils.StringToNullString(license.SupportEmail),
			OAJDS:                  utils.IntToNullInt64(license.TotalNodes),
			OAProductName:          utils.StringToNullString(license.ProductName),
			OAProductVersion:       utils.StringToNullString(license.Version),
			OASYDW:                 utils.StringToNullString(license.Company),
		},
	})

	if err != nil {
		global.Logger.Errorln("数据插入失败 ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": fmt.Sprintf("数据插入失败: ", err.Error())})
		return
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
	})
}

// 删除一行lincese信息
func DelLicenseInfoRow(c *gin.Context) {
	// 解析 JSON 请求体
	var request UniqueIDRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		c.JSON(400, gin.H{
			"error": err.Error(),
		})
		return
	}
	err := models.DelLicenseInfoRow(request.UniqueID)
	if err != nil {
		global.Logger.Errorln("删除一行License信息失败  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("删除失败: ", err.Error())})
		return
	}

	//刷新缓存
	// layout := "2006-01-02 15:04:05"
	// startTime, _ := time.Parse(layout, "2023-07-30 14:00:00")
	// endTime, _ := time.Parse(layout, "2023-08-26 16:00:00")
	// if err := global.LicCache.RefreshCache(global.XuguDB, startTime, endTime, 0, 20); err != nil {
	// 	global.Logger.Errorln("LicenseInfo数据刷新缓存失败：  ", err.Error())
	// 	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据刷新缓存失败: ", err.Error())})
	// 	return
	// }

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    "删除成功",
	})

}

// 主动抓取一次license信息到支撑库
func CaptureLicenseOnceToDb(c *gin.Context) {
	if err := capture.CaptureOnce(global.OaDB, global.XuguDB); err != nil {
		global.Logger.Errorln("主动抓取license信息到支撑库失败：  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("主动抓取license信息数据失败: %s", err.Error())})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"success": true,
	})
}

func GetDistributeButtenCheckController(c *gin.Context) {
	//获取oa申请单号
	name := c.Query("oa_request_id")
	oaRequestID, err := strconv.ParseInt(name, 10, 64)
	//查询oa单号的每一行license信息
	err, isCheck := services.GetDistributeButtenCheckService(oaRequestID)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"error": fmt.Sprintf("生成错误: ", err.Error()),
		})
		return
	}
	if isCheck {
		c.JSON(http.StatusOK, gin.H{
			"error": fmt.Sprintf("该条信息校验不一致，请刷新页面: "),
		})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "License校验成功！",
	})
}

func SearchLicInfoToDb(c *gin.Context) {

	// var request string
	// if err := c.ShouldBindJSON(&request); err != nil {
	// 	c.JSON(400, gin.H{
	// 		"error": err.Error(),
	// 	})
	// 	return
	// }
	request := c.Param("data")

	if datas, err := models.SearchLicInfoToDb(request); err != nil {
		global.Logger.Errorln("搜索license信息失败：  ", err.Error())
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("搜索license信息失败失败: %s", err.Error())})
		return
	} else {
		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"data":    datas,
		})
	}

}

func ConditionalSearchController(c *gin.Context) {
	// 解析 JSON 请求体
	var request api.ConditionalSearchRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		c.JSON(400, gin.H{
			"error": err.Error(),
		})
		return
	}
	if request.AnySearch == "" && request.EndDate == "" && request.StartingDate == "" && request.LicenseFlag == "" {
		c.JSON(400, gin.H{
			"error": "请求参数不能为空",
		})
		return
	}

	//获取用户信息和权限
	userInfo, err := getLoginInfo(c)
	if err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户信息不存在"})
		c.Abort()
	}

	if userInfo.Permission[middlewares.ReadAllLicense] == middlewares.ReadAllLicense {
		licInfos, _, err := services.GetConditionalSearchService(request, middlewares.ReadAllLicense, userInfo.Account)
		if err != nil {
			c.JSON(400, gin.H{
				"error": errors.Errorf("查询失败: %s", err.Error()),
			})
			return
		}

		if ret, err := returnLicenseInfo(licInfos); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintln("数据转换失败: ", err.Error())})
		} else {
			c.JSON(http.StatusOK, gin.H{
				"success": true,
				"data":    ret,
			})
		}

	} else if userInfo.Permission[middlewares.ReadLicense] == middlewares.ReadLicense {
		licInfos, _, err := services.GetConditionalSearchService(request, middlewares.ReadLicense, userInfo.Account)
		if err != nil {
			c.JSON(400, gin.H{
				"error": errors.Errorf("查询失败: %s", err.Error()),
			})
			return
		}

		if ret, err := returnLicenseInfo(licInfos); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintln("数据转换失败: ", err.Error())})
		} else {
			c.JSON(http.StatusOK, gin.H{
				"success": true,
				"data":    ret,
			})
		}
	}

}

func returnLicenseInfo(datas1 *[]models.OALicenseInfo) ([][]api.AllLicenseInfoResponse, error) {

	// 初始化存储 `OARequestID` 相同的 `ApiLicenseInfoTemp` 列表的 map
	oaRequestIDMap := make(map[int64][]api.AllLicenseInfoResponse)

	for _, data := range *datas1 {
		ApiLicenseInfo := api.AllLicenseInfoResponse{
			UniqueID:               utils.ToString(data.LicInfo.UniqueID),
			OAId:                   utils.ToInt64(data.LicInfo.OAId),
			OARequestID:            utils.ToInt64(data.LicInfo.OARequestID),
			OARequestName:          utils.ToString(data.LicInfo.OARequestName),
			OARequestNameNew:       utils.ToString(data.LicInfo.OARequestNameNew),
			OARequestNameHTMLNew:   utils.ToString(data.LicInfo.OARequestNameHTMLNew),
			OAGLXMId:               utils.ToInt64(data.LicInfo.OAGLXMID),
			OAGLXMName:             utils.ToString(data.LicInfo.OAGLXMName),
			OASQSJ:                 utils.ToString(data.LicInfo.OASQSJ),
			OASalespersonName:      utils.ToString(data.LicInfo.OASalespersonName),
			OAXSJSYX:               utils.ToString(data.LicInfo.OAXSJSYX),
			OAOperationsPersonName: utils.ToString(data.LicInfo.OAOperationsPersonName),
			OAJFJSYX:               utils.ToString(data.LicInfo.OAJFJSYX),
			OASYDW:                 utils.ToString(data.LicInfo.OASYDW),
			OAXMXXMS:               utils.ToString(data.LicInfo.OAXMXXMS),
			OAJDS:                  utils.ToInt64(data.LicInfo.OAJDS),
			OANodeCount:            utils.ToInt64(data.LicInfo.OANodeCount),
			OAProductCode:          utils.ToString(data.LicInfo.OAProductCode),
			OAProductName:          utils.ToString(data.LicInfo.OAProductName),
			OAProductVersion:       utils.ToString(data.LicInfo.OAProductVersion),
			OACPU:                  utils.ToString(data.LicInfo.OACPU),
			OAOperatingSystem:      utils.ToString(data.LicInfo.OAOperatingSystem),
			OAMainMAC:              utils.ToString(data.LicInfo.OAMainMAC),
			OASecondMAC:            utils.ToString(data.LicInfo.OASecondMAC),
			OACreationDate:         utils.ToString(data.LicInfo.OACreationDate),
			OACreationTime:         utils.ToString(data.LicInfo.OACreationTime),
			OALastOperateDate:      utils.ToString(data.LicInfo.OALastOperateDate),
			OALastOperateTime:      utils.ToString(data.LicInfo.OALastOperateTime),
			CaptureTime:            utils.ToTimeString(data.LicInfo.CaptureTime),
			DelTime:                utils.ToTimeString(data.LicInfo.DelTime),
			LastOperateTime:        utils.ToTimeString(data.LicInfo.LastOperateTime),
			LicenseFlage:           utils.ToString(data.GenrateInfo.LicenseFlage),
			Lic1:                   utils.ToString(data.GenrateInfo.Lic1),
			Lic2:                   utils.ToString(data.GenrateInfo.Lic2),
			CreatorGenerate:        utils.ToTimeString(data.GenrateInfo.CreatorGenerate),
		}
		// 将 `ApiLicenseInfo` 添加到 `OARequestID` 对应的数组中
		oaRequestID := utils.ToInt64(data.LicInfo.OARequestID)
		oaRequestIDMap[oaRequestID] = append(oaRequestIDMap[oaRequestID], ApiLicenseInfo)
	}

	var datas [][]api.AllLicenseInfoResponse
	// 将 `oaRequestIDMap` 中的所有 `ApiLicenseInfoTemp` 列表添加到 `datas` 中
	for _, apiLicenseInfoTemp := range oaRequestIDMap {
		datas = append(datas, apiLicenseInfoTemp)
	}
	// 对 datas 的第一维进行排序
	// sort.Slice(datas, func(i, j int) bool {
	// 	// 假设你需要根据每个数组第一个元素的 OACreationDate 和 OACreationTime 来排序
	// 	if datas[i][0].OACreationDate == datas[j][0].OACreationDate {

	// 		return datas[i][0].OACreationTime > datas[j][0].OACreationTime
	// 	}
	// 	return datas[i][0].OACreationDate > datas[j][0].OACreationDate
	// })
	// 对 datas 的第一维进行排序
	sort.Slice(datas, func(i, j int) bool {
		// 先按 OACreationDate 和 OACreationTime 排序
		if datas[i][0].OACreationDate == datas[j][0].OACreationDate {
			if datas[i][0].OACreationTime == datas[j][0].OACreationTime {
				// 如果 OACreationDate 和 OACreationTime 相同，则按 OARequestID 从大到小排序
				return datas[i][0].OARequestID > datas[j][0].OARequestID
			}
			return datas[i][0].OACreationTime > datas[j][0].OACreationTime
		}
		return datas[i][0].OACreationDate > datas[j][0].OACreationDate
	})

	return datas, nil
}