package services

import (
	"eta/eta_index_lib/models"
	"eta/eta_index_lib/services/alarm_msg"
	"eta/eta_index_lib/utils"
	"fmt"
	"strconv"
	"strings"
	"time"
)

// 重置单个计算指标中的引用关系
func ResetEdbRelation(edbInfoId int) {
	var err error
	defer func() {
		if err != nil {
			msg := fmt.Sprintf("重置单个计算指标中的引用关系失败，错误信息：%s", err.Error())
			go alarm_msg.SendAlarmMsg(msg, 3)
		}
	}()
	//查询与该计算指标相关的间接引用或者间接引用关系，如果记录不存在，则不处理
	_, err = models.GetEdbInfoRelationByChildEdbInfoId(edbInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = nil
			return
		}
		err = fmt.Errorf("查询与该计算指标相关的间接引用或者间接引用关系失败，错误信息：%s", err.Error())
		return
	}

	//查询当前计算指标最新的引用指标列表
	newMappingList, err := models.GetEdbInfoCalculateDetailList(edbInfoId)
	if err != nil {
		err = fmt.Errorf("查询当前计算指标最新的指标列表失败，错误信息：%s", err.Error())
		return
	}
	//整理关联的来源指标ID
	newEdbIdList := make([]int, 0)
	newMappingListMap := make(map[int]*models.EdbInfoCalculateDetail)
	for _, v := range newMappingList {
		newEdbIdList = append(newEdbIdList, v.FromEdbInfoId)
		newMappingListMap[v.FromEdbInfoId] = v
	}
	// 排序
	//二者匹配一下，如果相同，则不处理，如果不同，先查询所有旧的间接引用记录，整理并分组，则删除旧的间接引用记录，新增新的间接引用记录，
	relationList, err := models.GetEdbInfoRelationListByChildEdbInfoId(edbInfoId)
	if err != nil {
		err = fmt.Errorf("查询当前计算指标的间接引用关系失败，错误信息：%s", err.Error())
		return
	}
	deleteRelationIds := make([]int, 0)
	// 根据引用对象和直接引用指标 进行分组
	groupMap := make(map[string]map[int]*models.EdbInfoRelation)
	// 遍历每组内容，
	for _, v := range relationList {
		//如果指标ID不在新的
		if !utils.InArrayByInt(newEdbIdList, v.EdbInfoId) {
			deleteRelationIds = append(deleteRelationIds, v.EdbInfoRelationId)
		}
		name := fmt.Sprintf("%d_%d_%d_%d", v.ReferObjectId, v.ReferObjectType, v.ReferObjectSubType, v.RootEdbInfoId)
		childMap, ok := groupMap[name]
		if !ok {
			childMap = make(map[int]*models.EdbInfoRelation, 0)
		}
		childMap[v.EdbInfoId] = v
		groupMap[name] = childMap
	}
	// 遍历每组内容，如果新ID不在组内，则添加
	addList := make([]*models.EdbInfoRelation, 0)
	indexCodeList := make([]string, 0)
	refreshEdbIds := make([]int, 0)
	nowTime := time.Now()
	for name, childMap := range groupMap {
		for _, edbId := range newEdbIdList {
			if _, ok := childMap[edbId]; !ok {
				// 新增记录
				childEdb, ok1 := newMappingListMap[edbId]
				if !ok1 {
					continue
				}
				// 获取引用时间
				relationObjectInfo := strings.Split(name, "_")
				objectId, _ := strconv.Atoi(relationObjectInfo[0])
				objectType, _ := strconv.Atoi(relationObjectInfo[1])
				objectSubType, _ := strconv.Atoi(relationObjectInfo[2])
				rootEdbId, _ := strconv.Atoi(relationObjectInfo[3])
				tmp1 := &models.EdbInfoRelation{
					ReferObjectId:      objectId,
					ReferObjectType:    objectType,
					ReferObjectSubType: objectSubType,
					EdbInfoId:          childEdb.FromEdbInfoId,
					EdbName:            childEdb.FromEdbName,
					Source:             childEdb.FromSource,
					EdbCode:            childEdb.FromEdbCode,
					CreateTime:         nowTime,
					ModifyTime:         nowTime,
					RelationTime:       nowTime,
					RelationType:       1,
					RootEdbInfoId:      rootEdbId,
					ChildEdbInfoId:     edbInfoId,
				}
				tmp1.RelationCode = fmt.Sprintf("%d_%d_%d_%d", tmp1.RootEdbInfoId, tmp1.ReferObjectId, tmp1.ReferObjectType, tmp1.ReferObjectSubType)
				addList = append(addList, tmp1)
				refreshEdbIds = append(refreshEdbIds, childEdb.FromEdbInfoId)
				if childEdb.FromSource == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
					indexCodeList = append(indexCodeList, childEdb.FromEdbCode)
				}
			}
		}
	}

	if len(addList) > 0 || len(deleteRelationIds) > 0 {
		err = models.AddOrUpdateEdbInfoRelationByChildEdbInfoId(addList, refreshEdbIds, indexCodeList, deleteRelationIds)
		if err != nil {
			err = fmt.Errorf("新增引用关系失败,err:%v", err)
			return
		}
	}
	return
}

// 设置成禁用状态
func DisableEdbInfoNoUpdate(edbInfo *models.EdbInfo) (err error) {
	// 如果一个计算指标里，包涵的基础指标是停用状态，那么计算指标也要是停用状态停用状态
	newBaseEdbInfoList := make([]int, 0)
	hasFind := make(map[int]struct{})
	newBaseEdbInfoIds, err := FindBaseEdbInfo(edbInfo.EdbInfoId, newBaseEdbInfoList, hasFind)
	if err != nil {
		err = fmt.Errorf("查找基础指标信息失败,err:%v", err)
		return
	}
	// 查询是否存在停用指标，如果存在，则计算指标也要是停用状态
	total, err := models.GetEdbInfoNoUpdateTotalByIdList(newBaseEdbInfoIds)
	if err != nil {
		err = fmt.Errorf("查询基础指标信息失败,err:%v", err)
		return
	}
	if total > 0 {
		edbInfo.NoUpdate = 1
		edbInfo.ModifyTime = time.Now()
		err = edbInfo.Update([]string{"NoUpdate", "ModifyTime"})
		if err != nil {
			err = fmt.Errorf("更新计算指标刷新状态失败,err:%v", err)
			return
		}
	}
	return
}

// 找到基础指标的过程
func FindBaseEdbInfo(edbInfoId int, baseEdbInfoList []int, hasFind map[int]struct{}) (newBaseEdbInfoList []int, err error) {
	newBaseEdbInfoList = baseEdbInfoList
	if _, ok := hasFind[edbInfoId]; ok {
		return
	}
	// 先找到所有的引用关系
	//查询当前计算指标最新的引用指标列表
	newMappingList, err := models.GetEdbInfoCalculateDetailList(edbInfoId)
	if err != nil {
		err = fmt.Errorf("查询当前计算指标最新的指标列表失败，错误信息：%s", err.Error())
		return
	}
	hasFind[edbInfoId] = struct{}{}
	for _, mapping := range newMappingList {
		if mapping.EdbType == 1 { // 如果是基础指标，则加入，否则继续找
			newBaseEdbInfoList = append(newBaseEdbInfoList, mapping.FromEdbInfoId)
		} else {
			newBaseEdbInfoList, err = FindBaseEdbInfo(mapping.FromEdbInfoId, newBaseEdbInfoList, hasFind)
		}
	}
	return
}