package services

import (
	"archive/zip"
	"bytes"
	"fmt"
	"strings"
	"xugu_license/internal/api"
	"xugu_license/internal/global"
	"xugu_license/internal/models"
	"xugu_license/internal/module/email"
	"xugu_license/internal/module/license"
	"xugu_license/internal/utils"

	"github.com/pkg/errors"
)

func DistributeOALicenseServices(OperatorUniqueID, OaRequestId string, UserUniqueIDs, UserAccounts, UserNames, EmailArray []string) (error, []string) {
	// //检测OARequest是否以及分发过给用户
	// existUsers, err := checkDistributeToUser(OaRequestId, UserUniqueIDs, UserNames)
	// if err != nil {
	// 	global.Logger.Errorln("license分发请求检测是否已发放给用户失败  %s", err.Error())
	// 	return err, nil
	// }
	// //返回以及分发过的用户列表
	// if len(existUsers) != 0 {

	// 	return nil, existUsers
	// }
	// fmt.Println("DistributeOALicenseServices : ")
	// //获取一个申请单的多个license信息
	// LicInfos, _, err := models.GetOALicenseInfo(1, 1, "", "", "", OaRequestId)
	// if err != nil {
	// 	return err, nil
	// }

	// //将分发的lic信息插入lic分发用户表中
	// for _, licInfo := range *LicInfos {

	// 	for userIdx, userUID := range UserUniqueIDs {

	// 		//如果lic1为空则报错
	// 		if licInfo.GenrateInfo.Lic1.String == "" {
	// 			global.Logger.Errorln("DistributeOALicenseServices : license生成信息为空 ")
	// 			return errors.New("license生成信息为空"), nil
	// 		}

	// 		err = models.InsertlicenseRecordByUserRow(OaRequestId, licInfo.LicInfo.UniqueID.String, userUID, UserAccounts[userIdx], OperatorUniqueID)
	// 		if err != nil {
	// 			global.Logger.Errorln("DistributeOALicenseServices: 数据库插入失败： ", err.Error())
	// 			return err, nil
	// 		}
	// 	}
	// }
	// //发送邮件
	// //邮箱不空则发送
	// //将一个申请单的多个license信息用邮箱发送

	// if len(EmailArray) == 0 {
	// 	return nil, nil
	// }
	// //将licenses里的lic串们打包在zip里
	// // 1. 创建 ZIP 文件并存储在内存中
	// // var buffer bytes.Buffer
	// // zipWriter := zip.NewWriter(&buffer)
	// // for _, lic := range *LicInfos {
	// // 	// 将数据添加到 ZIP 中
	// // 	file1, err := zipWriter.Create("file1.txt")
	// // 	if err != nil {
	// // 		global.Logger.Errorln(err)
	// // 	}
	// // 	_, err = file1.Write(lic)
	// // 	if err != nil {
	// // 		global.Logger.Errorln(err)
	// // 	}

	// // }

	// // file2, err := zipWriter.Create("file2.txt")
	// // if err != nil {
	// // 	global.Logger.Errorln(err)
	// // }
	// // _, err = file2.Write(data2)
	// // if err != nil {
	// // 	global.Logger.Errorln(err)
	// // }

	// fmt.Println("EmailArray : ", EmailArray)
	// emails := strings.Join(EmailArray, ",")
	// if !strings.Contains(emails, "@") {
	// 	return nil, nil
	// }
	// for _, lic := range *LicInfos {

	// 	if lic.GenrateInfo.Lic1.String == "" {
	// 		global.Logger.Errorln("DistributeOALicenseServices : license生成信息为空 ")
	// 		return errors.New("license生成信息为空"), nil
	// 	}

	// 	//组装邮件
	// 	em, err := email.BuildEmail(&lic, EmailArray, lic.GenrateInfo.Lic1.String, lic.GenrateInfo.Lic2.String)
	// 	if err != nil {
	// 		global.Logger.Errorln("邮件生成失败", err.Error())
	// 		return err, nil
	// 	}
	// 	//发送邮件
	// 	err = email.SendEmail(em)
	// 	if err != nil {
	// 		global.Logger.Errorln("邮件发送失败", err.Error())

	// 		return err, nil
	// 	}
	// 	//将分发的lic信息插入lic分发邮箱表中
	// 	err = models.InsertlicenseRecordByEmailRow(OaRequestId, lic.LicInfo.UniqueID.String, emails, OperatorUniqueID)
	// 	if err != nil {
	// 		global.Logger.Errorln("数据库插入失败： ", err.Error())
	// 		return err, nil
	// 	}

	// }

	return nil, nil
}

func DistributeLicenseToUserServices(OperatorUniqueID string, OaRequestId int64, UserUniqueIDs, UserAccounts, UserNames []string) (error, []string) {
	//检测支撑库数据与oa是否一致
	err, checkInfo := CheckOaLicInfoRequest(OaRequestId)
	if err != nil {
		return err, nil
	}
	if checkInfo {
		return errors.Errorf("本地数据与oa数据不一致,请刷新页面"), nil
	}

	//检测OARequest是否以及分发过给用户
	existUsers, err := checkDistributeToUser(OaRequestId, UserUniqueIDs, UserNames)
	if err != nil {
		global.Logger.Errorln("license分发请求检测是否已发放给用户失败  %s", err.Error())
		return err, nil
	}
	//返回以及分发过的用户列表
	if len(existUsers) != 0 {

		return nil, existUsers
	}
	fmt.Println("DistributeOALicenseServices : ")
	//获取一个申请单的多个license信息
	LicInfos, _, err := models.GetOALicenseInfo(1, 1, "", "", "", OaRequestId)
	if err != nil {
		return err, nil
	}

	//将分发的lic信息插入lic分发用户表中
	for _, licInfo := range *LicInfos {

		for userIdx, userUID := range UserUniqueIDs {

			//如果lic1为空则报错
			if licInfo.GenrateInfo.Lic1.String == "" {
				global.Logger.Errorln("DistributeOALicenseServices : license生成信息为空 ")
				return errors.New("license生成信息为空"), nil
			}

			err = models.InsertlicenseRecordByUserRow(OaRequestId, licInfo.LicInfo.UniqueID.String, userUID, UserAccounts[userIdx], OperatorUniqueID)
			if err != nil {
				global.Logger.Errorln("DistributeOALicenseServices: 数据库插入失败： ", err.Error())
				return err, nil
			}
		}
	}
	return nil, nil
}

func DistributeLicenseToEmailServices(OperatorUniqueID string, OaRequestId int64, UserUniqueIDs, UserAccounts, UserNames, EmailArray []string) (error, []string) {
	//发送邮件
	//邮箱不空则发送
	//将一个申请单的多个license信息用邮箱发送

	//检测支撑库数据与oa是否一致
	err, checkInfo := CheckOaLicInfoRequest(OaRequestId)
	if err != nil {
		return err, nil
	}
	if checkInfo {
		return errors.Errorf("本地数据与oa数据不一致,请刷新页面"), nil
	}
	if len(EmailArray) == 0 {
		return nil, nil
	}

	//获取一个申请单的多个license信息
	LicInfos, _, err := models.GetOALicenseInfo(1, 1, "", "", "", OaRequestId)
	if err != nil {
		return err, nil
	}

	//将licenses里的lic串们打包在zip里
	//1. 创建 ZIP 文件并存储在内存中
	var buffer bytes.Buffer
	zipWriter := zip.NewWriter(&buffer)
	for i, lic := range *LicInfos {
		ii := i + 1
		num := 1
		filetestName := fmt.Sprintf("%d_%s_license_%djd_%d", ii, lic.LicInfo.OAGLXMName.String, lic.LicInfo.OANodeCount.Int64, num)
		num++
		// 将数据添加到 ZIP 中
		file1, err := zipWriter.Create(fmt.Sprintf(filetestName+"_%s.dat", lic.LicInfo.OAMainMAC.String))
		if err != nil {
			global.Logger.Errorln(err)
			return err, nil
		}
		if lic.GenrateInfo.Lic1.Valid {
			_, err = file1.Write([]byte(lic.GenrateInfo.Lic1.String))
			if err != nil {
				global.Logger.Errorln(err)
				return err, nil
			}
		}

		if lic.GenrateInfo.Lic2.Valid {
			if err != nil {
				global.Logger.Errorln(err)
				return err, nil
			}
			file2, err := zipWriter.Create(fmt.Sprintf(filetestName+"_%s", lic.LicInfo.OASecondMAC.String))
			if err != nil {
				global.Logger.Errorln(err)
				return err, nil
			}
			_, err = file2.Write([]byte(lic.GenrateInfo.Lic2.String))
			if err != nil {
				global.Logger.Errorln(err)
				return err, nil
			}

		}

	}

	// 关闭 zip.Writer
	if err := zipWriter.Close(); err != nil {
		global.Logger.Errorln(err)
	}

	// 将 ZIP 内容转换为 []byte
	zipBytes := buffer.Bytes()

	fmt.Println("EmailArray : ", EmailArray)
	emails := strings.Join(EmailArray, ",")
	if !strings.Contains(emails, "@") {
		return nil, nil
	}

	// if lic.GenrateInfo.Lic1.String == "" {
	// 	global.Logger.Errorln("DistributeOALicenseServices : license生成信息为空 ")
	// 	return errors.New("license生成信息为空"), nil
	// }

	lic := &(*LicInfos)[0]
	//组装邮件
	em, err := email.BuildEmail(lic, EmailArray, zipBytes, "")
	if err != nil {
		global.Logger.Errorln("邮件生成失败", err.Error())
		return err, nil
	}
	//发送邮件
	err = email.SendEmail(em)
	if err != nil {
		global.Logger.Errorln("邮件发送失败", err.Error())

		return err, nil
	}

	for _, lic := range *LicInfos {
		//将分发的lic信息插入lic分发邮箱表中
		err = models.InsertlicenseRecordByEmailRow(OaRequestId, lic.LicInfo.UniqueID.String, emails, OperatorUniqueID)
		if err != nil {
			global.Logger.Errorln("数据库插入失败： ", err.Error())
			return err, nil
		}
	}

	// for _, lic := range *LicInfos {

	// 	if lic.GenrateInfo.Lic1.String == "" {
	// 		global.Logger.Errorln("DistributeOALicenseServices : license生成信息为空 ")
	// 		return errors.New("license生成信息为空"), nil
	// 	}

	// 	//组装邮件
	// 	em, err := email.BuildEmail(&lic, EmailArray, lic.GenrateInfo.Lic1.String, lic.GenrateInfo.Lic2.String)
	// 	if err != nil {
	// 		global.Logger.Errorln("邮件生成失败", err.Error())
	// 		return err, nil
	// 	}
	// 	//发送邮件
	// 	err = email.SendEmail(em)
	// 	if err != nil {
	// 		global.Logger.Errorln("邮件发送失败", err.Error())

	// 		return err, nil
	// 	}
	// 	//将分发的lic信息插入lic分发邮箱表中
	// 	err = models.InsertlicenseRecordByEmailRow(OaRequestId, lic.LicInfo.UniqueID.String, emails, OperatorUniqueID)
	// 	if err != nil {
	// 		global.Logger.Errorln("数据库插入失败： ", err.Error())
	// 		return err, nil
	// 	}
	// }
	return nil, nil
}

// 生成license
func GenerateOALicenseStrServices(request api.GenerateLicenseStrRequest) (error, bool) {
	if request.OARequestId != 0 {
		//一个OARequestId会有多条数据UniqueID
		OALics, _, err := models.GetOALicenseInfo(0, 0, "", "", "", request.OARequestId)
		if err != nil || OALics == nil {
			global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
			return errors.Errorf("LicenseInfo数据查询失败 ： %v", err.Error()), false
		}

		//校验license信息是否与oa一致
		var isCheck bool
		for _, license := range *OALics {
			//检测该数据是否与oa库数据库一致 //todo
			isCheckTmp, err := models.CheckLicenseInfoInOADB(&license.LicInfo)
			if err != nil {
				global.Logger.Errorln("LicenseInfo数据对比oa库 校验失败：  ", err.Error())
				return errors.Errorf("LicenseInfo数据对比oa库 校验失败 %v", err.Error()), false
			}
			if isCheckTmp {
				global.Logger.Errorf("\nLicenseInfo数据对比oa库 不一致:  %v\n", license.LicInfo.UniqueID)
				isCheck = isCheckTmp
				err = models.UpdatelicenseInfoRow(license)
				if err != nil {
					return err, false
				}
			}
		}
		//不一致则返回
		if isCheck {
			return nil, true
		}

		//生成license，已生成的不管
		for _, v := range *OALics {
			if v.GenrateInfo.LicenseFlage.String == "未生成" || v.GenrateInfo.LicenseFlage.String == "已失效" {
				err := generateLicenseStrSub(utils.ToString(v.LicInfo.UniqueID))
				if err != nil {
					global.Logger.Errorf("请联系管理员, LicenseInfo%v生成失败:  %v\n", v.LicInfo.UniqueID, err.Error())
					return errors.Errorf("请联系管理员, LicenseInfo%v生成失败:  %v\n", v.LicInfo.UniqueID, err.Error()), false
				}
			}
		}
		return nil, false
	}
	return errors.Errorf("License申请单为空"), false
}

func generateLicenseStrSub(UniqueID string) error {
	var applications *[]models.OALicenseInfo
	var err error
	if UniqueID != "" {
		applications, _, err = models.GetOALicenseInfo(0, 1, "", UniqueID, "", 0)
		if err != nil {
			global.Logger.Errorln("LicenseInfo数据查询失败：  ", err.Error())
			//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
			return errors.Errorf("LicenseInfo数据查询失败: %v", err.Error())
		}
	}

	//fmt.Printf("applications%#v\n", applications)

	//生成副主节点license
	if applications == nil {
		global.Logger.Errorln("LicenseInfo数据生成失败 ，数据查询为空  ")
		//c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("LicenseInfo数据生成失败 ，数据查询为空: ", err.Error())})
		return errors.Errorf("LicenseInfo数据生成失败 ，数据查询为空 ")
	}
	for _, lic := range *applications {
		if !lic.LicInfo.OAMainMAC.Valid {
			return errors.Errorf("LicenseInfo数据生成失败 , %s 有集群 主mac地址缺失 ", lic.LicInfo.OAProductName.String)
		}
	}

	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.OAProductVersion))
	lI := license.LicenseInfo{
		GenDate:        "2024-07-15",
		ExpireDate:     "9999-12-31",
		LicenseType:    LicType,
		LicenseVersion: 1,
		HardType:       3,
	}

	//这里调用的是license模块中的生成license的方法
	//res := false
	fmt.Println("res是 : ", global.Cfg.App.IsGenerate)
	if global.Cfg.App.IsGenerate {

		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)
			if err != nil {
				global.Logger.Errorln("LicenseInfo2生成插入失败：  ", err.Error())
				//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
				return errors.Errorf("LicenseInfo2生成插入失败：%s", err.Error())
			}
		} else {
			//插入到数据库
			err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), licStr, nil)
			if err != nil {
				global.Logger.Errorln("LicenseInfo生成插入失败：  ", err.Error())
				//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
				return errors.Errorf("LicenseInfo生成插入失败： %s", err.Error())
			}
		}

	} else {

		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"))
			if err != nil {
				global.Logger.Errorln("LicenseInfo生成插入失败：  ", err.Error())
				//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
				return errors.Errorf("LicenseInfo生成插入失败：: ", err.Error())
			}
		} else {
			//fmt.Println("licStr licStr2", licStr, licStr2)
			//插入到数据库
			err = models.UpdateOALicenseStr(utils.ToString((*applications)[0].LicInfo.UniqueID), []byte("b4j6z4rE2IfG1av0wIPT7YnvyGZFHxwIBikMGjgCLQILR0xsT1NHiuzoi+Dqq+bmiNDEiuPyitDVgdvlRmYbFAk+MAAGASlPTkdMbE9"), nil)
			if err != nil {
				global.Logger.Errorln("LicenseInfo2生成插入失败：  ", err.Error())
				//	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("数据查询失败: ", err.Error())})
				return errors.Errorf("LicenseInfo2生成插入失败：: ", err.Error())
			}
		}
	}

	//---------------------

	return nil
}