package knowledge

import (
	"errors"
	"eta_gn/eta_api/models/knowledge"
	"eta_gn/eta_api/services/alarm_msg"
	"eta_gn/eta_api/utils"
	"fmt"
	"sort"
	"time"
)

func MoveKnowledgeClassify(req knowledge.ClassifyMoveReq) (err error, errMsg string) {
	knowledgeObj := new(knowledge.KnowledgeClassify)
	classifyId := req.ClassifyId
	prevClassifyId := req.PrevClassifyId
	nextClassifyId := req.NextClassifyId

	var (
		classifyInfo *knowledge.KnowledgeClassify
		prevClassify *knowledge.KnowledgeClassify
		nextClassify *knowledge.KnowledgeClassify

		prevSort int
		nextSort int
	)

	classifyInfo, err = knowledgeObj.GetClassifyById(classifyId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "分类不存在, 请刷新页面"
			err = fmt.Errorf("获取分类信息失败,Err:" + err.Error())
			return
		}
		errMsg = "移动失败"
		err = fmt.Errorf("获取分类信息失败,Err:" + err.Error())
		return
	} else if classifyInfo.ClassifyId == 0 {
		errMsg = "分类不存在, 请刷新页面"
		err = fmt.Errorf("获取分类信息失败")
		return
	}

	parentClassifyId := classifyInfo.ParentId
	if prevClassifyId > 0 {
		prevClassify, err = knowledgeObj.GetClassifyById(prevClassifyId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "上一个分类不存在, 请刷新页面"
				err = fmt.Errorf("获取分类信息失败,Err:" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = fmt.Errorf("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		if prevClassify.ParentId != parentClassifyId {
			errMsg = "禁止拖动到其他节点"
			err = fmt.Errorf(errMsg)
			return
		}
		prevSort = prevClassify.Sort
	}

	if nextClassifyId > 0 {
		nextClassify, err = knowledgeObj.GetClassifyById(nextClassifyId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "下一个分类不存在, 请刷新页面"
				err = fmt.Errorf("获取分类信息失败,Err:" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = fmt.Errorf("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		if nextClassify.ParentId != parentClassifyId {
			errMsg = "禁止拖动到其他节点"
			err = fmt.Errorf(errMsg)
			return
		}
		nextSort = nextClassify.Sort
	}

	err, errMsg = moveKnowledgeClassify(classifyInfo, prevClassify, nextClassify, parentClassifyId, prevSort, nextSort, classifyInfo.ResourceType)
	return
}

func moveKnowledgeClassify(classifyInfo, prevClassify, nextClassify *knowledge.KnowledgeClassify, parentId, prevSort, nextSort, resourceType int) (err error, errMsg string) {
	knowledgeObj := new(knowledge.KnowledgeClassify)
	updateCol := make([]string, 0)

	if classifyInfo.ParentId != parentId {
		errMsg = "移动失败"
		err = fmt.Errorf("不支持目录层级变更")
		return
	}

	if prevSort > 0 {
		if nextSort > 0 {
			if prevSort == nextSort || prevSort == classifyInfo.Sort {
				updateSortStr := `sort + 2`

				if prevClassify != nil {
					_ = knowledgeObj.UpdateClassifySortByParentId(parentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, resourceType)
				} else {
					_ = knowledgeObj.UpdateClassifySortByParentId(parentId, 0, prevSort, updateSortStr, resourceType)
				}

			} else {
				if nextSort-prevSort == 1 {
					updateSortStr := `sort + 1`

					if prevClassify != nil {
						_ = knowledgeObj.UpdateClassifySortByParentId(parentId, prevClassify.ClassifyId, prevSort, updateSortStr, resourceType)
					} else {
						_ = knowledgeObj.UpdateClassifySortByParentId(parentId, 0, prevSort, updateSortStr, resourceType)
					}

				}
			}
		}

		classifyInfo.Sort = prevSort + 1
		classifyInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")
	} else if prevClassify == nil && nextClassify == nil && parentId > 0 {
		var maxSort int
		maxSort, err = knowledgeObj.GetMaxSortByParentId(parentId)
		if err != nil {
			errMsg = "移动失败"
			err = fmt.Errorf("查询组内排序信息失败,Err:" + err.Error())
			return
		}
		classifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
		classifyInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")
	} else {
		firstPermission, tmpErr := knowledgeObj.GetFirstClassifyByParentId(parentId)
		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
			errMsg = "移动失败"
			err = fmt.Errorf("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
			return
		}

		if firstPermission != nil && firstPermission.ClassifyId > 0 && firstPermission.Sort == 0 {
			updateSortStr := ` sort + 1 `
			_ = knowledgeObj.UpdateClassifySortByParentId(parentId, firstPermission.ClassifyId-1, 0, updateSortStr, resourceType)
		}

		classifyInfo.Sort = 0 //那就是排在第一位
		classifyInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")
	}

	if len(updateCol) > 0 {
		err = classifyInfo.Update(updateCol)
		if err != nil {
			errMsg = "移动失败"
			err = fmt.Errorf("修改失败,Err:" + err.Error())
			return
		}
	}
	return
}

func AddKnowledgeClassify(classifyName string, parentId, resourceType int) (err error, errMsg string, isSendEmail bool) {
	isSendEmail = true
	errMsg = `添加失败`
	knowledgeObj := new(knowledge.KnowledgeClassify)
	_, err = knowledgeObj.GetClassifyByName(classifyName, parentId, resourceType)
	if err != nil && !utils.IsErrNoRow(err) {
		errMsg = "获取分类信息失败"
		return
	}

	if err == nil {
		errMsg = "分类名称:" + classifyName + "已存在"
		isSendEmail = false
		err = errors.New(errMsg)
		return
	} else {
		err = nil
	}

	level := 1
	var parentClassifyItem *knowledge.KnowledgeClassify
	var childClassifyCount int

	if parentId > 0 {
		parentClassifyItem, err = knowledgeObj.GetClassifyById(parentId)
		if err != nil {
			errMsg = "获取父级分类信息失败"
			if utils.IsErrNoRow(err) {
				errMsg = "父级分类不存在"
			}
			return
		}
		if parentClassifyItem.ResourceType != resourceType {
			errMsg = "父级分类与当前分类类型不一致"
			err = fmt.Errorf(errMsg)
			return
		}
		level = parentClassifyItem.Level + 1

		if level > 3 {
			errMsg = "分类层级不可超过三级"
			isSendEmail = false
			return
		}
		childClassifyCount, err = knowledgeObj.GetCountClassifyChildByParentId(parentId)
		if err != nil {
			errMsg = "获取父级分类的子分类信息失败"
			return
		}
	}

	nowTime := time.Now().Local()
	classify := new(knowledge.KnowledgeClassify)

	maxSort, err := classify.GetMaxSort()
	if err != nil {
		errMsg = "操作失败"
		err = errors.New("查询品种排序失败, Err: " + err.Error())
		return
	}
	classify.ClassifyName = classifyName
	classify.ParentId = parentId
	classify.CreateTime = nowTime
	classify.ModifyTime = nowTime
	classify.Sort = maxSort + 1
	classify.Enabled = 1
	classify.Level = level
	classify.ResourceType = resourceType

	err = knowledgeObj.Add(classify)
	if err != nil {
		return
	}
	fmt.Println("classify.ClassifyId:")
	fmt.Println(classify.ClassifyId)
	if parentClassifyItem != nil {
		if childClassifyCount <= 0 {
			moveResourceByAddClassify(parentClassifyItem, classify, resourceType)
		}
	}
	return
}

func moveResourceByAddClassify(parentClassifyInfo, currClassifyInfo *knowledge.KnowledgeClassify, resourceType int) (err error) {
	defer func() {
		if err != nil {
			msg := fmt.Sprint("历史事件更改分类失败，父级分类ID：", parentClassifyInfo.ClassifyId, "；当前分类ID:", currClassifyInfo.ClassifyId, "；错误信息：", err.Error())
			utils.FileLog.Error(msg)
			go alarm_msg.SendAlarmMsg(msg, 3)
		}
	}()
	if currClassifyInfo.Level > 3 {
		err = errors.New("父级分类不支持三级分类以上")
		return
	}

	var condition string
	pars := make([]interface{}, 0)
	condition += ` AND resource_type = ? `
	pars = append(pars, resourceType)
	condition += ` AND classify_id = ? `
	pars = append(pars, parentClassifyInfo.ClassifyId)
	idList, err := knowledge.GetKnowledgeResourceIdList(condition, pars)
	if err != nil {
		err = fmt.Errorf("查询需要转移的资源数量失败，Err: %s", err.Error())
		return
	}
	if len(idList) == 0 { //没有需要转移的资源
		return
	}

	newClassifyId := currClassifyInfo.ClassifyId
	if currClassifyInfo.Level == 2 {
		classifyObj := new(knowledge.KnowledgeClassify)
		childClassify, e := classifyObj.GetFirstClassifyByParentId(currClassifyInfo.ClassifyId)
		if e == nil {
			newClassifyId = childClassify.ClassifyId
		}
	}
	resourceObj := new(knowledge.KnowledgeResource)
	err = resourceObj.UpdateClassifyIdByIds(idList, newClassifyId, resourceType)
	return
}

func EditKnowledgeClassify(classifyId, parentId int, classifyName string, resourceType int) (err error, errMsg string, isSendEmail bool) {
	isSendEmail = true
	errMsg = `修改失败`
	knowledgeObj := new(knowledge.KnowledgeClassify)
	item, err := knowledgeObj.GetClassifyById(classifyId)
	if err != nil {
		errMsg = "获取分类信息失败"
		if utils.IsErrNoRow(err) {
			errMsg = "分类不存在, 或已被删除"
			isSendEmail = false
		}
		return
	}
	if item.ResourceType != resourceType {
		errMsg = "分类类型错误"
		err = errors.New("分类类型错误")
		return
	}

	if (parentId == 0 && item.ParentId > 0) || (parentId > 0 && item.ParentId == 0) {
		err = errors.New("不允许修改分类层级")
		errMsg = "不允许修改分类层级"
		return
	}
	var parentClassifyItem *knowledge.KnowledgeClassify
	var childClassifyCount int

	if parentId > 0 {
		parentClassifyItem, err = knowledgeObj.GetClassifyById(parentId)
		if err != nil {
			errMsg = "获取父级分类信息失败"
			if utils.IsErrNoRow(err) {
				errMsg = "父级分类不存在"
			}
			return
		}
		if parentClassifyItem.ResourceType != resourceType {
			errMsg = "父级分类与当前分类类型不一致"
			err = fmt.Errorf(errMsg)
			return
		}
		if parentClassifyItem.Level+1 != item.Level {
			errMsg = "不允许修改分类层级"
			err = errors.New("不允许修改分类层级")
			return
		}
		level := parentClassifyItem.Level + 1

		if level > 3 {
			errMsg = "分类层级不可超过三级"
			isSendEmail = false
			return
		}
		childClassifyCount, err = knowledgeObj.GetCountClassifyChildByParentId(parentId)
		if err != nil {
			errMsg = "获取父级分类的子分类信息失败"
			return
		}
	}

	existName, e := knowledgeObj.GetClassifyByName(classifyName, parentId, item.ResourceType)
	if e != nil && !utils.IsErrNoRow(e) {
		errMsg = "分类名称已存在"
		err = errors.New("获取重名分类失败, Err: " + e.Error())
		return
	}
	if existName != nil && existName.ClassifyId > 0 && existName.ClassifyId != item.ClassifyId {
		errMsg = "分类名称:" + classifyName + "已存在"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}
	item.ClassifyName = classifyName

	item.ParentId = parentId
	item.ModifyTime = time.Now().Local()
	cols := make([]string, 0)
	cols = append(cols, "ParentId", "ClassifyName", "ModifyTime")
	err = item.Update(cols)
	if err != nil {
		return
	}
	if parentClassifyItem != nil {
		if childClassifyCount <= 0 {
			moveResourceByAddClassify(parentClassifyItem, item, resourceType)
		}
	}
	return
}

func GetClassifyTreeRecursive(list []*knowledge.KnowledgeClassifyItem, parentId int) []*knowledge.KnowledgeClassifyItem {
	res := make([]*knowledge.KnowledgeClassifyItem, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			v.Child = GetClassifyTreeRecursive(list, v.ClassifyId)
			res = append(res, v)
		}
	}
	return res
}

func GetParentClassifyListByParentIdList(parentClassifyIdList []int) (list []*knowledge.KnowledgeClassifyItem, err error) {
	knowledgeObj := new(knowledge.KnowledgeClassify)
	num := len(parentClassifyIdList)
	if num <= 0 {
		return
	}
	list, err = knowledgeObj.GetClassifyListByParentIdList(parentClassifyIdList)
	if err != nil {
		return
	}

	{
		currParentClassifyIdList := make([]int, 0)
		for _, v := range list {
			if v.ParentId > 0 {
				currParentClassifyIdList = append(currParentClassifyIdList, v.ParentId)
			}
		}

		if len(currParentClassifyIdList) > 0 {
			tmpList, tmpErr := GetParentClassifyListByParentIdList(currParentClassifyIdList)
			if tmpErr != nil {
				err = tmpErr
				return
			}
			list = append(tmpList, list...)
		}
	}

	return
}

func GetClassifyListTreeRecursive(list []*knowledge.KnowledgeClassifyItem, parentId int) []*knowledge.KnowledgeClassifyItem {
	res := make([]*knowledge.KnowledgeClassifyItem, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			v.Child = GetClassifyListTreeRecursive(list, v.ClassifyId)
			res = append(res, v)
		}
	}

	if len(res) <= 0 {
		res = nil
	}

	return res
}

type BySortAndCreateTime []*knowledge.KnowledgeClassifyItem

func (a BySortAndCreateTime) Len() int {
	return len(a)
}

func (a BySortAndCreateTime) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func (a BySortAndCreateTime) Less(i, j int) bool {
	if a[i].Sort == a[j].Sort {
		return a[i].CreateTime.Before(a[j].CreateTime)
	}
	return a[i].Sort < a[j].Sort
}

func SortClassifyListBySortAndCreateTime(classifyList []*knowledge.KnowledgeClassifyItem) {
	sort.Sort(BySortAndCreateTime(classifyList))
}