package services

import (
	"fmt"
	"strings"
	"xugu_license/internal/api"
	"xugu_license/internal/global"
	"xugu_license/internal/models"
	"xugu_license/internal/module/email"
	"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 GenerateOALicenseStrServices(request api.GenerateLicenseStrRequest) (error, bool) {
	if request.OARequestId != "" {
		//一个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 == "未生成" {
				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, "", "")
		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数据生成失败 ，数据查询为空 ")
	}

	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
}

func GetDistributeButtenCheckService(OARequestId string) (error, bool) {
	if OARequestId != "" {
		//一个OARequestId会有多条数据UniqueID
		OALics, _, err := models.GetOALicenseInfo(0, 0, "", "", "", 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
				}
				err = models.UpdatelicenseGenerateInfoRow(license)
				if err != nil {
					return err, false
				}
			}
		}
		//不一致则返回
		if isCheck {
			return nil, true
		}
		return nil, false
	}
	return errors.Errorf("该申请单没有oa单号"), false
}