package data

import (
	"errors"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/utils"
	"time"
)

func AddSciHqClassify(classifyName, lang string, parentId int) (ok bool, err error) {
	var count int
	switch lang {
	case utils.EnLangVersion:
		count, err = data_manage.GetBaseFromSciHqClassifyEnCount(classifyName, parentId)
	default:
		count, err = data_manage.GetBaseFromSciHqClassifyCount(classifyName, parentId)
	}
	if err != nil {
		return
	}
	if count > 0 {
		return false, errors.New("分类已存在")
	}

	sort, err := data_manage.GetChildSciHqClassifyMaxSortById(parentId)
	if err != nil {
		return false, err
	}
	if parentId > 0 {
		count, err = data_manage.GetSciHqClassifyCountById(parentId)
		if err != nil {
			return false, err
		}
		if count == 0 {
			return false, errors.New("父分类不存在")
		}
		sciHqClassify := &data_manage.BaseFromSciHqClassify{
			ClassifyName:   classifyName,
			ClassifyNameEn: classifyName,
			ParentId:       parentId,
			Level:          2,
			Sort:           sort + 1,
			ModifyTime:     time.Now(),
			CreateTime:     time.Now(),
		}
		_, err = sciHqClassify.Add()
		if err != nil {
			return
		}
	} else {
		sciHqClassify := &data_manage.BaseFromSciHqClassify{
			ClassifyName:   classifyName,
			ClassifyNameEn: classifyName,
			ParentId:       0,
			Level:          1,
			Sort:           sort + 1,
			ModifyTime:     time.Now(),
			CreateTime:     time.Now(),
		}
		insertId, er := sciHqClassify.Add()
		if er != nil {
			return false, er
		}
		sciHqClassifyList := []*data_manage.BaseFromSciHqClassify{
			{
				ClassifyName:   "价格",
				ClassifyNameEn: "价格",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           1,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "供应",
				ClassifyNameEn: "供应",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           2,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "需求",
				ClassifyNameEn: "需求",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           3,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "库存",
				ClassifyNameEn: "库存",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           4,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
		}
		err = data_manage.BatchAddSciHqClassify(sciHqClassifyList)
		if err != nil {
			return
		}
	}
	return true, nil
}

func DelSciHqClassify(classifyId int) (err error) {
	classify, err := data_manage.GetSciHqClassifyById(classifyId)
	if err != nil {
		return
	}
	var classifyIds []int
	if classify.ParentId == 0 {
		classifyIds, err = data_manage.GetChildSciHqClassifyIdsById(classify.ClassifyId)
		if err != nil {
			return
		}
	} else {
		classifyIds = append(classifyIds, classify.ClassifyId)
	}
	// 获取分类下的所有指标
	count, err := data_manage.GetBaseFromSciIndexCountByClassifyIds(classifyIds)
	if err != nil {
		err = errors.New("获取分类下的指标信息失败,Err:" + err.Error())
		return
	}
	if count > 0 {
		err = errors.New("该分类下有指标，不可删除")
		return
	}
	// 删除对应的分类
	err = data_manage.DeleteSciHqClassifyByClassifyId(classifyIds)
	if err != nil {
		return
	}
	return
}

// ResetSciHqIndex 指标数据清除分类接口
func ResetSciHqIndex(indexId int) (err error) {
	sciHqIndex, err := data_manage.GetBaseFromSciHqIndexByIndexId(indexId)
	if err != nil {
		return
	}

	// 更新指标在未分类下的排序，永远排在未分类的最后一个
	//移动排序
	classifyId := 0
	updateCol := make([]string, 0)
	var currentSort, prevSort int
	currentSort = sciHqIndex.Sort
	//未分类的最大的sort值
	prevSort, err = data_manage.GetBaseFromSciHqIndexMaxSortByClassifyId(classifyId)
	if err != nil {
		err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + err.Error())
		return
	}

	//如果前面一个节点的sort值比当前大，则当前节点往下移动
	if prevSort >= currentSort {
		//往下移动
		err = data_manage.MoveDownSciIndexBySort(classifyId, prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动出错:" + err.Error())
			return
		}
		sciHqIndex.Sort = prevSort
	}

	//更新
	sciHqIndex.ModifyTime = time.Now()
	sciHqIndex.ClassifyId = classifyId
	updateCol = append(updateCol, "Sort", "ModifyTime", "ClassifyId")
	err = sciHqIndex.Update(updateCol)
	if err != nil {
		err = errors.New("移动失败,Err:" + err.Error())
		return
	}
	return
}

// DelSciHqData 删除卓创红期指标
func DelSciHqData(indexId int) (err error, errMsg string) {
	baseFromSciHqIndex, err := data_manage.GetBaseFromSciHqIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if err.Error() == utils.ErrNoRow() {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

	// 获取已经加入到EDB指标库的Sci指标
	edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_SCI_HQ, baseFromSciHqIndex.IndexCode)
	if err != nil && err.Error() != utils.ErrNoRow() {
		errMsg = "删除失败"
		err = errors.New("获取分类下的指标信息失败,Err:" + err.Error())
		return
	}
	if edbInfo != nil {
		errMsg = "当前指标已被引用，不可删除"
		err = nil
		return
	}

	// 删除对应的分类和指标
	err = data_manage.DeleteBaseFromSciIndexById(indexId)
	if err != nil {
		return
	}

	return
}

// EditSciHqIndex 编辑卓创红期指标
func EditSciHqIndex(indexId, classifyId int) (baseFromSciHqIndex *data_manage.BaseFromSciHqIndex, err error) {
	baseFromSciHqIndex, err = data_manage.GetBaseFromSciHqIndexByIndexId(indexId)
	if err != nil {
		return
	}

	baseFromSciHqIndex.ClassifyId = classifyId
	baseFromSciHqIndex.ModifyTime = time.Now()
	err = baseFromSciHqIndex.Update([]string{"ClassifyId", "ModifyTime"})
	return
}