package data

import (
	"errors"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/system"
	"eta/eta_api/utils"
	"fmt"
	"github.com/shopspring/decimal"
	"github.com/tealeg/xlsx"
	"strconv"
	"strings"
	"time"
)

func GetManualSysUser(keyWord string) (list []*data_manage.ManualSysUser, err error) {
	//departmentId := 1
	list = make([]*data_manage.ManualSysUser, 0)
	departmentItems, err := system.GetSysDepartmentAll()
	if err != nil {
		return list, err
	}
	for _, dv := range departmentItems {
		department := new(data_manage.ManualSysUser)
		department.ItemId = dv.DepartmentId * 10000
		department.ItemName = dv.DepartmentName

		fmt.Println(department.ItemId, department.ItemName)
		//GetSysuserList

		var condition string
		var pars []interface{}

		if keyWord != "" {
			condition += ` AND (real_name LIKE ? OR admin_name LIKE ? OR mobile LIKE ? )  `
			pars = utils.GetLikeKeywordPars(pars, keyWord, 3)
		}
		sysUsers, err := system.GetSysUserItems(condition, pars)
		if err != nil {
			return list, err
		}

		groups, err := system.GetSysGroupByDepartmentId(dv.DepartmentId)
		if err != nil {
			return list, err
		}
		dg := make([]*data_manage.ManualSysUser, 0)
		for _, v := range groups {
			group := new(data_manage.ManualSysUser)
			group.ItemId = v.DepartmentId * 100000
			group.ItemName = v.GroupName

			for _, sv := range sysUsers {
				user := new(data_manage.ManualSysUser)
				user.ItemId = sv.AdminId
				user.ItemName = sv.RealName
				if sv.GroupId == v.GroupId {
					group.Children = append(group.Children, user)
				}
			}
			if len(group.Children) > 0 {
				dg = append(dg, group)
			}
		}

		if len(groups) <= 0 {
			group := new(data_manage.ManualSysUser)
			group.ItemId = dv.DepartmentId * 100000
			group.ItemName = "无分组"

			for _, sv := range sysUsers {
				user := new(data_manage.ManualSysUser)
				user.ItemId = sv.AdminId
				user.ItemName = sv.RealName
				if sv.DepartmentId == dv.DepartmentId && sv.GroupId == 0 {
					group.Children = append(group.Children, user)
				}
			}
			if len(group.Children) > 0 {
				dg = append(dg, group)
			}
		}

		if len(dg) > 0 {
			department.Children = dg
			list = append(list, department)
		}
	}
	return
}

// GetManualEdbClassifyListByAdminId
// @Description: 根据账户类型获取手工指标分类ID集合
// @author: Roc
// @datetime 2024-07-16 13:18:39
// @param adminId int64
// @return classifyIdList []int
// @return err error
func GetManualEdbClassifyListByAdminId(adminId int64) (classifyIdList []int, err error) {
	var list []*models.EdbdataClassify
	if adminId <= 0 {
		list, err = models.GetAllChildManualEdbClassify()
	} else {
		userClassifyList, _ := models.GetManualUserClassify(int(adminId))
		var userClassifyIdList []int
		for _, v := range userClassifyList {
			userClassifyIdList = append(userClassifyIdList, v.ClassifyId)
		}
		list, err = models.GetChildManualEdbClassifyByIdList(userClassifyIdList)
	}
	if err != nil {
		return
	}
	for _, classify := range list {
		classifyIdList = append(classifyIdList, classify.ClassifyId)
	}

	return
}

type ManualIndexSource2EdbReq struct {
	EdbCode       string
	EdbName       string
	Frequency     string
	Unit          string
	ClassifyId    int
	AdminId       int
	AdminRealName string
}

// ManualIndexSource2Edb 新增彭博数据源到指标库
func ManualIndexSource2Edb(req ManualIndexSource2EdbReq, lang string) (edb *data_manage.EdbInfo, err error, errMsg string, skip bool) {
	if req.EdbCode == "" {
		err = fmt.Errorf("指标ID为空")
		return
	}
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("ManualIndexSource2Edb新增失败, Err: %s", err.Error())
			fmt.Println(tips)
			utils.FileLog.Info(tips)
		}
	}()
	source := utils.DATA_SOURCE_MANUAL

	// 是否已有指标数据
	dataList, e := data_manage.GetEdbDataAllByEdbCode(req.EdbCode, source, utils.DATA_SUB_SOURCE_EDB, utils.EDB_DATA_LIMIT)
	if e != nil {
		err = fmt.Errorf("获取指标数据失败, Err: %s", e.Error())
		return
	}

	// 新增指标数据
	if len(dataList) == 0 {
		res, e := AddEdbData(source, req.EdbCode, req.Frequency)
		if e != nil {
			err = fmt.Errorf("index_lib: 新增指标数据失败, Err: %s", e.Error())
			return
		}
		if res == nil {
			err = fmt.Errorf("index_lib: 新增指标数据失败, res nil")
			return
		}
		if res.Ret != 200 {
			err = fmt.Errorf("index_lib: 新增指标数据失败, Ret: %d", res.Ret)
			return
		}
	}

	// 是否新增过指标
	exist, e := data_manage.GetEdbInfoByEdbCode(source, req.EdbCode)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = fmt.Errorf("获取指标是否存在失败, err: %s", e.Error())
		return
	}
	if exist != nil {
		skip = true
		return
	}

	// 开始结束时间
	var startDate, endDate string
	minMax, e := data_manage.GetEdbInfoMaxAndMinInfo(source, utils.DATA_SUB_SOURCE_EDB, req.EdbCode)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = fmt.Errorf("MinMax: 获取指标极值失败, err: %s", e.Error())
		return
	}
	if minMax != nil {
		startDate = minMax.MinDate
		endDate = minMax.MaxDate
	}

	// 新增指标库
	edbInfo, e, msg, _ := EdbInfoAdd(source, utils.DATA_SUB_SOURCE_EDB, req.ClassifyId, req.EdbCode, req.EdbName, req.Frequency, req.Unit, startDate, endDate, req.AdminId, req.AdminRealName, lang)
	if e != nil {
		errMsg = msg
		err = fmt.Errorf("EdbInfo: 新增指标失败, err: %s", e.Error())
		return
	}
	edb = edbInfo

	// 新增es
	go AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	return
}

func ImportManualData(path string, sysUser *system.Admin) (err error, errMsg string) {
	errMsg = `导入失败`
	xlFile, err := xlsx.OpenFile(path)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	if len(xlFile.Sheets) <= 0 {
		errMsg = "导入模板异常"
		err = errors.New(errMsg)
		return
	}

	//导入成功数量
	successCount := 0
	//导入失败数据
	failDataList := make([]*models.EdbdataImportFail, 0)
	var indexDataList []ImportManualIndexData

	for _, sheet := range xlFile.Sheets {
		var tmpIndexDataList []ImportManualIndexData
		var tmpFailDataList []*models.EdbdataImportFail
		rowList := sheet.Rows
		if len(rowList) <= 0 {
			errMsg = sheet.Name + "页异常"
			err = errors.New(errMsg)
			return
		}
		headerCell := rowList[0].Cells
		if len(headerCell) < 7 {
			errMsg = sheet.Name + "页模板异常"
			err = errors.New(errMsg)
			return
		}

		templateName := headerCell[6].String()
		switch templateName {
		case "导入模板2/Import Template 2":
			// 模板2需要走对应的取数逻辑
			tmpIndexDataList, tmpFailDataList, err, errMsg = getDataByTemplate2(sheet)
		default:
			// 模板1需要走对应的取数逻辑
			tmpIndexDataList, tmpFailDataList, err, errMsg = getDataByTemplate1(sheet)
		}
		indexDataList = append(indexDataList, tmpIndexDataList...)
		failDataList = append(failDataList, tmpFailDataList...)
	}

	//超管账号可以查看分类下的所有频度数据
	userId := sysUser.AdminId
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
		userId = 0
	}
	//获取账户所拥有权限的分类id集合
	classifyNameStrList, edbDataClassifyMap, err := GetEdbClassifyNameListByAdminId(int64(userId))
	if err != nil {
		errMsg = "获取分类数据失败"
		return
	}

	////指标map
	//targetMap := make(map[string]*models.Edbinfo)
	//defer func() {
	//	for _, target := range targetMap {
	//		//结束后，清除掉对应的缓存
	//		key := "import:edbinfo:data:" + target.TradeCode
	//		utils.Rc.Delete(key)
	//
	//		//将该指标的code加入到 “手工数据导入后刷新” 缓存
	//		if utils.Re == nil {
	//			err := utils.Rc.LPush(utils.CACHE_IMPORT_MANUAL_DATA, target.TradeCode)
	//			if err != nil {
	//				fmt.Println("CACHE_IMPORT_MANUAL_DATA LPush Err:" + err.Error())
	//			}
	//		}
	//	}
	//}()
	//
	//// 所有的指标数据map
	//edbCodeDataMap := make(map[string]map[string]string)

	// 确定模板

	// 遍历sheet页读取
	//for _, sheet := range xlFile.Sheets {
	//	fmt.Println("sheet name: ", sheet.Name)
	//	//遍历行读取
	//	maxRow := sheet.MaxRow
	//	fmt.Println("maxRow:", maxRow)
	//	fmt.Println("maxRow")
	//	for i := 0; i < maxRow; i++ {
	//		if i == 1 {
	//			row := sheet.Row(i)
	//			cells := row.Cells
	//			if len(cells) < 6 {
	//				br.ErrMsg = "导入文件异常，请下载最新导入模板文件"
	//				br.Msg = "导入文件异常，请下载最新导入模板文件"
	//				return
	//			}
	//			templateFail := false
	//			if cells[0].Value != "品种分类" && cells[0].Value != "Species Category" {
	//				templateFail = true
	//			}
	//			if cells[1].Value != "录入日期" && cells[1].Value != "Input Date" {
	//				templateFail = true
	//			}
	//			if cells[2].Value != "指标名称" && cells[2].Value != "Indicator Name Indicator Name" {
	//				templateFail = true
	//			}
	//			if cells[3].Value != "值" && cells[3].Value != "Value" {
	//				templateFail = true
	//			}
	//			if cells[4].Value != "频度" && cells[4].Value != "Frequency" {
	//				templateFail = true
	//			}
	//			if cells[5].Value != "单位" && cells[5].Value != "Unit" {
	//				templateFail = true
	//			}
	//			if templateFail {
	//				br.ErrMsg = "导入文件异常，请下载最新导入模板文件"
	//				br.Msg = "导入文件异常，请下载最新导入模板文件"
	//				return
	//			}
	//		}
	//		if i > 1 {
	//			row := sheet.Row(i)
	//			cells := row.Cells
	//			if len(cells) >= 6 {
	//				classifyName := cells[0].Value //分类
	//				if classifyName == "" {        //过滤空白行
	//					continue
	//				}
	//				cell1 := cells[1].Value
	//				//createDate := utils.ConvertToFormatDay(cell1) //录入日期
	//				createDate := cell1
	//				cell2 := cells[2].Value //指标名称
	//				secName := utils.TrimStr(cell2)
	//				frequency := cells[4].Value //频度
	//				unit := cells[5].Value      //单位
	//
	//				closeVal := cells[3].Value //值
	//				if strings.Contains(closeVal, "#N/A") {
	//					continue
	//				}
	//
	//				//校验表格中的日期格式
	//				if strings.Contains(createDate, "-") {
	//					//如果是带有 - 的普通日期格式文本
	//					_, timeErr := time.Parse("2006-1-2", createDate)
	//					if timeErr != nil {
	//						failItem := new(models.EdbdataImportFail)
	//						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//						failItem.ClassifyName = classifyName
	//						failItem.CreateDate = createDate
	//						failItem.SecName = secName
	//						failItem.Close = closeVal
	//						failItem.Remark = "日期格式异常"
	//						failItem.Frequency = frequency
	//						failItem.Unit = unit
	//						failDataList = append(failDataList, failItem)
	//						//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
	//						continue
	//					}
	//				} else if strings.Contains(createDate, "/") {
	//					//如果是带有 / 的普通日期格式文本
	//					createDateTime, timeErr := time.Parse("2006/1/2", createDate)
	//					if timeErr != nil {
	//						failItem := new(models.EdbdataImportFail)
	//						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//						failItem.ClassifyName = classifyName
	//						failItem.CreateDate = createDate
	//						failItem.SecName = secName
	//						failItem.Close = closeVal
	//						failItem.Remark = "日期格式异常"
	//						failItem.Frequency = frequency
	//						failItem.Unit = unit
	//						failDataList = append(failDataList, failItem)
	//						//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
	//						continue
	//					}
	//					createDate = createDateTime.Format("2006-01-02")
	//				} else {
	//					//可能是excel的日期格式
	//					_, tmpErr := strconv.Atoi(createDate)
	//					if tmpErr != nil {
	//						failItem := new(models.EdbdataImportFail)
	//						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//						failItem.ClassifyName = classifyName
	//						failItem.CreateDate = createDate
	//						failItem.SecName = secName
	//						failItem.Close = closeVal
	//						failItem.Remark = "日期格式异常"
	//						failItem.Frequency = frequency
	//						failItem.Unit = unit
	//						failDataList = append(failDataList, failItem)
	//						//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
	//						continue
	//					}
	//					createDate = utils.ConvertToFormatDay(createDate) //录入日期
	//				}
	//
	//				closeValFloat, err := cells[3].Float() //值
	//
	//				if err != nil {
	//					failItem := new(models.EdbdataImportFail)
	//					failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//					failItem.ClassifyName = classifyName
	//					failItem.CreateDate = createDate
	//					failItem.SecName = secName
	//					failItem.Close = cells[3].Value
	//					failItem.Remark = "值类型异常"
	//					failItem.Frequency = frequency
	//					failItem.Unit = unit
	//					failDataList = append(failDataList, failItem)
	//					continue
	//				}
	//				newDecimal := decimal.NewFromFloat(closeValFloat)
	//				newDecimal.Round(4)
	//				closeVal = newDecimal.String()
	//				if strings.Contains(closeVal, "#N/A") {
	//					continue
	//				}
	//				//closeVal := closeValFloat.
	//
	//				//判断指标，类型，等数据是否正常
	//				classifyName = strings.Trim(classifyName, " ")
	//				frequency = utils.TrimStr(frequency)
	//				unit = utils.TrimStr(unit)
	//
	//				// 成功数量超过20个指标，那就不导入了
	//				if len(targetMap) >= 150 {
	//					failItem := new(models.EdbdataImportFail)
	//					failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//					failItem.ClassifyName = classifyName
	//					failItem.CreateDate = createDate
	//					failItem.SecName = secName
	//					failItem.Close = closeVal
	//					failItem.Remark = "导入指标数量过多"
	//					failItem.Frequency = frequency
	//					failItem.Unit = unit
	//					failDataList = append(failDataList, failItem)
	//					//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
	//					continue
	//				}
	//
	//				if !strings.Contains(strings.Join(classifyNameStrList, ","), classifyName) {
	//					failItem := new(models.EdbdataImportFail)
	//					failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//					failItem.ClassifyName = classifyName
	//					failItem.CreateDate = createDate
	//					failItem.SecName = secName
	//					failItem.Close = closeVal
	//					failItem.Remark = "没有该品种分类权限"
	//					failItem.Frequency = frequency
	//					failItem.Unit = unit
	//					failDataList = append(failDataList, failItem)
	//					continue
	//				}
	//				//fmt.Println(classifyName, createDate, secName, closeVal)
	//
	//				//获取指标分类信息
	//				classify, ok := edbDataClassifyMap[classifyName]
	//				if !ok {
	//					failItem := new(models.EdbdataImportFail)
	//					failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//					failItem.ClassifyName = classifyName
	//					failItem.CreateDate = createDate
	//					failItem.SecName = secName
	//					failItem.Close = closeVal
	//					failItem.Remark = "指标分类不存在"
	//					failItem.Frequency = frequency
	//					failItem.Unit = unit
	//					failDataList = append(failDataList, failItem)
	//					//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
	//					continue
	//				}
	//
	//				//判断指标是否存在
	//				target, ok := targetMap[secName]
	//				if !ok {
	//					tmpTarget, err := models.GetTargetBySecName(secName)
	//					if err != nil {
	//						//如果是找不到该指标，那么新增指标
	//						if err.Error() == utils.ErrNoRow() {
	//							if frequency == "" {
	//								failItem := new(models.EdbdataImportFail)
	//								failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//								failItem.ClassifyName = classifyName
	//								failItem.CreateDate = createDate
	//								failItem.SecName = secName
	//								failItem.Close = closeVal
	//								failItem.Remark = "新增指标失败，频度字段为空"
	//								failItem.Frequency = frequency
	//								failItem.Unit = unit
	//								failDataList = append(failDataList, failItem)
	//								continue
	//							}
	//							if unit == "" {
	//								failItem := new(models.EdbdataImportFail)
	//								failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//								failItem.ClassifyName = classifyName
	//								failItem.CreateDate = createDate
	//								failItem.SecName = secName
	//								failItem.Close = closeVal
	//								failItem.Remark = "新增指标失败，单位字段为空"
	//								failItem.Frequency = frequency
	//								failItem.Unit = unit
	//								failDataList = append(failDataList, failItem)
	//								continue
	//							}
	//							tmpErr := data.AddEdbInfo(secName, unit, frequency, "", sysUser.Mobile, classify.ClassifyId, sysUser.AdminId)
	//							if tmpErr != nil {
	//								fmt.Println("line 158")
	//								failItem := new(models.EdbdataImportFail)
	//								failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//								failItem.ClassifyName = classifyName
	//								failItem.CreateDate = createDate
	//								failItem.SecName = secName
	//								failItem.Close = closeVal
	//								failItem.Remark = "新增指标失败"
	//								failItem.Frequency = frequency
	//								failItem.Unit = unit
	//								failDataList = append(failDataList, failItem)
	//								continue
	//							}
	//							tmpTarget, tmpErr := models.GetTargetBySecName(secName)
	//							target = tmpTarget
	//							targetMap[secName] = target
	//						} else {
	//							fmt.Println("导入数据 获取指标:Err:" + err.Error())
	//						}
	//					} else {
	//						target = tmpTarget
	//						targetMap[secName] = target
	//					}
	//
	//					//设置10分钟缓存，不允许其他地方删除
	//					key := "import:edbinfo:data:" + target.TradeCode
	//					utils.Rc.SetNX(key, 1, time.Second*600)
	//				}
	//
	//				if target == nil {
	//					fmt.Println("指标不存在")
	//					failItem := new(models.EdbdataImportFail)
	//					failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
	//					failItem.ClassifyName = classifyName
	//					failItem.CreateDate = createDate
	//					failItem.SecName = secName
	//					failItem.Close = closeVal
	//					failItem.Remark = "指标不存在"
	//					failItem.Frequency = frequency
	//					failItem.Unit = unit
	//					failDataList = append(failDataList, failItem)
	//					continue
	//				}
	//
	//				//更新指标信息
	//				updateCols := make([]string, 0)
	//				//更新指标分类
	//				if target.ClassifyId <= 0 && classify.ClassifyId > 0 {
	//					target.ClassifyId = classify.ClassifyId
	//					updateCols = append(updateCols, "ClassifyId")
	//				}
	//				if target.Frequency != frequency {
	//					target.Frequency = frequency
	//					target.NoticeTime = ""
	//					updateCols = append(updateCols, "Frequency", "NoticeTime")
	//				}
	//				if target.Unit != unit {
	//					target.Unit = unit
	//					updateCols = append(updateCols, "Unit")
	//				}
	//				if len(updateCols) > 0 {
	//					_ = target.Update(updateCols)
	//				}
	//
	//				// 判断指标数据列表是否已经存在
	//				tmpDataMap, ok := edbCodeDataMap[target.TradeCode]
	//				if !ok {
	//					tmpDataMap = make(map[string]string)
	//					dataList, tmpErr := models.GetTargetsDataList(target.TradeCode)
	//					if tmpErr != nil {
	//						go alarm_msg.SendAlarmMsg("导入数据"+target.TradeCode+" 获取指标的数据失败，Err："+err.Error(), 3)
	//					}
	//					for _, tmpData := range dataList {
	//						tmpDataMap[tmpData.Dt] = tmpData.Close
	//					}
	//					edbCodeDataMap[target.TradeCode] = tmpDataMap
	//				}
	//
	//				//判断数据是否已经存在
	//				tmpVal, ok := tmpDataMap[createDate]
	//				//数据已存在，进行更新操作
	//				if ok {
	//					if tmpVal != closeVal {
	//						err = models.ModifyTargetsDataByImport(target.TradeCode, createDate, closeVal)
	//						if err != nil {
	//							go alarm_msg.SendAlarmMsg("导入数据 修改数据失败，Err："+err.Error(), 3)
	//							//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 修改数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
	//						}
	//					}
	//				} else { //数据不存在，进行新增操作
	//					if target.TradeCode != "" && createDate != "" && closeVal != "" {
	//						models.AddTargetsDataByImport(target.TradeCode, createDate, closeVal)
	//						if err != nil {
	//							go alarm_msg.SendAlarmMsg("导入数据 新增数据失败，Err："+err.Error(), 3)
	//							//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 新增数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
	//						}
	//						tmpDataMap[createDate] = closeVal
	//						edbCodeDataMap[target.TradeCode] = tmpDataMap
	//					}
	//				}
	//				successCount++
	//			} else {
	//				//br.ErrMsg = "请填写导入内容"
	//				//br.Msg = "请填写导入内容"
	//				//return
	//			}
	//		}
	//	}
	//}

	return
}

// ImportManualIndexData
// @Description: excel模板后的内容
type ImportManualIndexData struct {
	IndexName string            `description:"指标名称"`
	Unit      string            `description:"单位"`
	ClassName string            `description:"所属品种"`
	Frequency string            `description:"频度"`
	DataMap   map[string]string `description:"时间数据"`
}

// TODO 模板数据获取异常的结果记录

// getDataByTemplate1
// @Description: 根据模板1获取数据
// @author: Roc
// @datetime 2024-07-24 16:17:45
// @param sheet *xlsx.Sheet
// @return indexDataList []ImportManualIndexData
// @return err error
// @return errMsg string
func getDataByTemplate1(sheet *xlsx.Sheet, sysUserId int) (indexDataList []ImportManualIndexData, failDataList []*models.EdbdataImportFail, err error, errMsg string) {
	fmt.Println("sheet name: ", sheet.Name)
	indexDataList = make([]ImportManualIndexData, 0)
	indexDataListMap := make(map[string]ImportManualIndexData, 0)
	failDataList = make([]*models.EdbdataImportFail, 0)

	//遍历行读取
	maxRow := sheet.MaxRow
	fmt.Println("maxRow:", maxRow)

	// 表头信息
	if maxRow <= 2 {
		errMsg = "模板异常1"
		err = errors.New(errMsg)
		return
	}

	// 表头校验
	{
		headerRow := sheet.Row(1)
		cells := headerRow.Cells
		if len(cells) < 6 {
			errMsg = "导入文件异常，请下载最新导入模板文件"
			err = errors.New(errMsg)
			return
		}

		templateFail := false
		if cells[0].Value != "品种/Variety" {
			templateFail = true
		}
		if cells[1].Value != "指标名称/Indicator Name" {
			templateFail = true
		}
		if cells[2].Value != "指标日期/Indicator Date" {
			templateFail = true
		}
		if cells[3].Value != "值/Value" {
			templateFail = true
		}
		if cells[4].Value != "频度/Frequency" {
			templateFail = true
		}
		if cells[5].Value != "单位/Unit" {
			templateFail = true
		}
		if templateFail {
			errMsg = "导入文件异常，请下载最新导入模板文件"
			err = errors.New(errMsg)
			return
		}
	}

	for i := 2; i < maxRow; i++ {
		row := sheet.Row(i)
		cells := row.Cells
		if len(cells) < 6 {
			errMsg = "导入文件异常，请下载最新导入模板文件"
			err = errors.New(errMsg)
			return
		}

		classifyName := strings.TrimSpace(cells[0].Value) //分类
		if classifyName == "" {                           //过滤空白行
			continue
		}
		// 指标名称
		cell1 := cells[1].Value
		indexName := strings.TrimSpace(cell1)
		if indexName == "" { //过滤空白行
			continue
		}
		//createDate := utils.ConvertToFormatDay(cell1) //录入日期
		createDate := cells[2].Value                      //指标日期
		frequency := strings.TrimSpace(cells[4].String()) //频度
		unit := strings.TrimSpace(cells[5].String())      //单位

		closeVal := cells[3].Value //值
		if strings.Contains(closeVal, "#N/A") {
			continue
		}

		currDate, tmpErr := getExcelDate(createDate)
		if tmpErr != nil {
			failDataList = append(failDataList, &models.EdbdataImportFail{
				//Id:           0,
				ClassifyName: classifyName,
				CreateDate:   createDate,
				SecName:      indexName,
				Close:        closeVal,
				Remark:       "日期格式异常",
				SysUserId:    strconv.Itoa(sysUserId),
				Frequency:    frequency,
				Unit:         unit,
			})
			continue
		}

		closeValFloat, tmpErr := cells[3].Float() //值
		if tmpErr != nil {
			failDataList = append(failDataList, &models.EdbdataImportFail{
				//Id:           0,
				ClassifyName: classifyName,
				CreateDate:   currDate,
				SecName:      indexName,
				Close:        cells[3].Value,
				Remark:       "值类型异常",
				SysUserId:    strconv.Itoa(sysUserId),
				Frequency:    frequency,
				Unit:         unit,
			})
			continue
		}
		newDecimal := decimal.NewFromFloat(closeValFloat)
		newDecimal.Round(4)
		closeVal = newDecimal.String()
		if strings.Contains(closeVal, "#N/A") {
			continue
		}

		_, ok := indexDataListMap[indexName]
		if !ok {
			indexDataListMap[indexName] = ImportManualIndexData{
				IndexName: indexName,
				Unit:      unit,
				ClassName: classifyName,
				Frequency: frequency,
				DataMap:   make(map[string]string),
			}
		}

		indexDataListMap[indexName].DataMap[currDate] = closeVal
	}

	for _, v := range indexDataListMap {
		indexDataList = append(indexDataList, v)
	}

	return
}

// getDataByTemplate2
// @Description: 根据模板2获取数据
// @author: Roc
// @datetime 2024-07-24 16:17:56
// @param sheet *xlsx.Sheet
// @return indexDataList []ImportManualIndexData
// @return err error
// @return errMsg string
func getDataByTemplate2(sheet *xlsx.Sheet, sysUserId int) (indexDataList []ImportManualIndexData, failDataList []*models.EdbdataImportFail, err error, errMsg string) {
	fmt.Println("sheet name: ", sheet.Name)
	indexDataList = make([]ImportManualIndexData, 0)
	failDataList = make([]*models.EdbdataImportFail, 0)

	//遍历行读取
	maxRow := sheet.MaxRow
	fmt.Println("maxRow:", maxRow)

	varietyList := make([]string, 0)
	indexNameList := make([]string, 0)
	unitList := make([]string, 0)
	frequencyList := make([]string, 0)

	// make(map[指标下标]map[日期]值)
	indexDateValueMap := make(map[int]map[string]string)

	// 表头信息
	if maxRow <= 4 {
		errMsg = "模板异常1"
		err = errors.New(errMsg)
		return
	}

	for i := 1; i < maxRow; i++ {
		row := sheet.Row(i)
		cells := row.Cells
		//if len(cells) < 1 {
		//	errMsg = "模板异常2"
		//	err = errors.New(errMsg)
		//	return
		//}

		// 表头处理
		if i <= 4 {
			switch i {
			case 1:
				for k, v := range cells {
					if k == 0 {
						continue
					}
					varietyList = append(varietyList, strings.TrimSpace(v.String()))
				}
			case 2:
				for k, v := range cells {
					if k == 0 {
						continue
					}
					indexNameList = append(indexNameList, strings.TrimSpace(v.String()))
				}
			case 3:
				for k, v := range cells {
					if k == 0 {
						continue
					}
					unitList = append(unitList, strings.TrimSpace(v.String()))
				}
			case 4:
				for k, v := range cells {
					if k == 0 {
						continue
					}
					frequencyList = append(frequencyList, strings.TrimSpace(v.String()))
				}
			}

			continue
		}

		// 当前日期
		var currDate string

		// 日期是否异常，异常的话，就跳过，进入下一行数据处理
		var dateErr bool

		// 数据处理
		for k, v := range cells {
			if k == 0 {
				tmpCurrDate, tmpErr := getExcelDate(v.Value)
				if tmpErr != nil {
					// TODO 错误数据记录
					//failItem := new(models.EdbdataImportFail)
					//failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
					//failItem.ClassifyName = classifyName
					//failItem.CreateDate = createDate
					//failItem.SecName = secName
					//failItem.Close = closeVal
					//failItem.Remark = "日期格式异常"
					//failItem.Frequency = frequency
					//failItem.Unit = unit
					//failDataList = append(failDataList, failItem)
					//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
					dateErr = true
				}

				currDate = tmpCurrDate
				continue
			}
			key := k - 1

			// 日期异常，所以不处理该行了
			if dateErr {
				varietyList[key]
				failDataList = append(failDataList, &models.EdbdataImportFail{
					//Id:           0,
					ClassifyName: classifyName,
					CreateDate:   currDate,
					SecName:      indexName,
					Close:        cells[3].Value,
					Remark:       "值类型异常",
					SysUserId:    strconv.Itoa(sysUserId),
					Frequency:    frequency,
					Unit:         unit,
				})

				continue
			}

			_, ok := indexDateValueMap[key]
			if !ok {
				indexDateValueMap[key] = make(map[string]string)
			}

			closeVal := v.Value //值
			// 没有数据，说明是空串
			if strings.Contains(closeVal, "#N/A") {
				indexDateValueMap[key][currDate] = ""
				continue
			}

			closeValFloat, tmpErr := v.Float() //值
			if tmpErr != nil {
				// TODO 错误数据记录
				//failItem := new(models.EdbdataImportFail)
				//failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
				//failItem.ClassifyName = classifyName
				//failItem.CreateDate = createDate
				//failItem.SecName = secName
				//failItem.Close = cells[3].Value
				//failItem.Remark = "值类型异常"
				//failItem.Frequency = frequency
				//failItem.Unit = unit
				//failDataList = append(failDataList, failItem)
				indexDateValueMap[key][currDate] = ""
				continue
			}

			newDecimal := decimal.NewFromFloat(closeValFloat)
			newDecimal.Round(4)
			closeVal = newDecimal.String()
			if strings.Contains(closeVal, "#N/A") {
				indexDateValueMap[key][currDate] = ""
				continue
			}
			indexDateValueMap[key][currDate] = closeVal
		}

	}

	maxUnitIndex := len(unitList) - 1
	maxClassNameIndex := len(varietyList) - 1
	maxFrequencyIndex := len(frequencyList) - 1
	for i, indexName := range indexNameList {
		var unit, classifyName, frequency string
		if i <= maxUnitIndex {
			unit = unitList[i]
		}
		if i <= maxClassNameIndex {
			classifyName = varietyList[i]
		}
		if i <= maxFrequencyIndex {
			frequency = frequencyList[i]
		}
		indexData := ImportManualIndexData{
			IndexName: indexName,
			Unit:      unit,
			ClassName: classifyName,
			Frequency: frequency,
			DataMap:   indexDateValueMap[i],
		}
		indexDataList = append(indexDataList, indexData)
	}

	return
}

// getExcelDate
// @Description: 获取excel的日期
// @author: Roc
// @datetime 2024-07-23 17:26:12
// @param createDate string
// @return newCreateDate string
// @return err error
func getExcelDate(createDate string) (newCreateDate string, err error) {
	if strings.Contains(createDate, "-") {
		//如果是带有 - 的普通日期格式文本
		_, err = time.Parse("2006-1-2", createDate)
		if err == nil {
			newCreateDate = createDate
		}
	} else if strings.Contains(createDate, "/") {
		//如果是带有 / 的普通日期格式文本
		createDateTime, timeErr := time.Parse("2006/1/2", createDate)
		if timeErr != nil {
			err = timeErr
		} else {
			newCreateDate = createDateTime.Format("2006-01-02")
		}
	} else {
		//可能是excel的日期格式
		_, tmpErr := strconv.Atoi(createDate)
		if tmpErr != nil {
			err = tmpErr
		} else {
			newCreateDate = utils.ConvertToFormatDay(createDate) //录入日期
		}
	}

	return
}