package data_manage

import (
	"encoding/json"
	"eta_gn/eta_api/controllers"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/data_manage/request"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/services/data"
	"eta_gn/eta_api/utils"
	"sort"
)

// ChartPublicClassifyController 数据管理-公共分类模块
type ChartPublicClassifyController struct {
	controllers.BaseAuthController
}

// SimpleList
// @Title 单层公共分类列表
// @Description 单层公共分类列表
// @Success 200 {object} data_manage.ChartClassifyListResp
// @router /chart_public/classify/simple [get]
func (c *ChartPublicClassifyController) SimpleList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	// 公共分类来源筛选
	// 目前只有图库会涉及到公共分类
	source := utils.CHART_TYPE_CURVE

	// 默认查一级公共分类和一级公共分类下的指标信息，
	// 如果是 子级公共分类，查询该子级公共分类的下一级公共分类和指标信息
	// 增加标识判断是文件夹还是指标列表
	parentId, _ := c.GetInt("ParentId")

	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	rootList, err := chartPublicClassifyObj.GetChartClassifyItemsByParentId(parentId, int8(source))
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	nodeAll := make([]*data_manage.ChartClassifyItems, 0)

	var sortList data_manage.ChartClassifyItemList
	if parentId > 0 {
		allChartInfo, err := data_manage.GetChartInfoByPublicClassifyId(parentId, source)
		if err != nil {
			br.Msg = "获取指标数据失败"
			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
			return
		}

		editShareChartInfoIdMap, err := data.GetAllEditSharedChartInfoIdMapByReceivedUserId(c.SysUser.AdminId)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有编辑权限的分享图表失败，Err:" + err.Error()
			return
		}

		// 查询当前公共分类信息
		for _, v := range allChartInfo {
			v.HaveOperaAuth = true
			button := data.GetChartOpButton(c.SysUser, v.SysUserId, v.ChartInfoId, v.HaveOperaAuth, editShareChartInfoIdMap)
			button.AddButton = false //不管有没有权限，指标都是没有添加按钮的
			v.Button = button
			v.Children = make([]*data_manage.ChartClassifyItems, 0)
			v.ParentId = parentId
			nodeAll = append(nodeAll, v)
		}

	}

	for _, v := range rootList {
		// 数据权限
		v.HaveOperaAuth = true
		// 按钮权限
		button := data.GetChartClassifyOpButton(c.SysUser, v.SysUserId, v.HaveOperaAuth)
		v.Button = button
		v.Children = make([]*data_manage.ChartClassifyItems, 0)
		nodeAll = append(nodeAll, v)
	}

	if len(nodeAll) > 0 {
		//根据sort值排序
		sortList = nodeAll
		sort.Sort(sortList)
	}

	language := `CN`
	// 指标显示的语言
	{
		configDetail, _ := system.GetConfigDetailByCode(c.SysUser.AdminId, system.ChartLanguageVar)
		if configDetail != nil {
			language = configDetail.ConfigValue
		} else {
			configDetail, _ = system.GetDefaultConfigDetailByCode(system.ChartLanguageVar)
			if configDetail != nil {
				language = configDetail.ConfigValue
			}
		}
	}

	// 是否允许添加一级公共分类
	canOpClassify := true
	button := data.GetChartClassifyOpButton(c.SysUser, 0, true)
	if !button.AddButton {
		canOpClassify = false
	}

	resp := new(data_manage.ChartClassifyListResp)
	resp.AllNodes = sortList
	resp.Language = language
	resp.CanOpClassify = canOpClassify
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ClassifyTree
// @Title 多层公共分类列表树
// @Description 多层公共分类列表树
// @Success 200 {object} data_manage.ChartClassifyListResp
// @router /chart_public/classify/tree [get]
func (c *ChartPublicClassifyController) ClassifyTree() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	// 公共分类来源筛选
	classifyType := utils.CHART_TYPE_CURVE

	chartPublicClassifyObj := data_manage.ChartPublicClassify{}
	allList, err := chartPublicClassifyObj.GetAllChartClassifyByType(int8(classifyType))
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	var sortList data_manage.ChartClassifyItemList
	if len(allList) > 0 {
		for k, v := range allList {
			// 数据权限
			v.HaveOperaAuth = true
			// 按钮权限
			button := data.GetChartClassifyOpButton(c.SysUser, v.SysUserId, v.HaveOperaAuth)
			allList[k].Button = button
		}
		allList = data.GetChartClassifyTreeRecursive(allList, 0)
		//根据sort值排序
		sortList = allList
		sort.Sort(sortList)
	}
	language := `CN`

	// 是否允许添加一级公共分类
	canOpClassify := true
	button := data.GetChartClassifyOpButton(c.SysUser, 0, true)
	if !button.AddButton {
		canOpClassify = false
	}

	resp := new(data_manage.ChartClassifyListResp)
	resp.AllNodes = sortList
	resp.Language = language
	resp.CanOpClassify = canOpClassify
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// AddChartClassify
// @Title 新增公共分类
// @Description 新增公共分类接口
// @Param	request	body data_manage.AddChartClassifyReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /chart_public/classify/add [post]
func (c *ChartPublicClassifyController) AddClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	var req data_manage.AddChartClassifyReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ChartClassifyName == "" {
		br.Msg = "请输入公共分类名称"
		br.IsSendEmail = false
		return
	}
	if req.ParentId < 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}
	// 公共分类来源筛选
	source := utils.CHART_TYPE_CURVE

	//添加指标
	_, err, errMsg := data.AddChartPublicClassify(req.ChartClassifyName, req.ParentId, source, c.SysUser.AdminId, c.SysUser.RealName)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = errMsg + ";Err:" + err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	//count, err := data_manage.GetChartClassifyCount(req.ClassifyName, req.ParentId)
	//if err != nil {
	//	br.Msg = "判断名称是否已存在失败"
	//	br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
	//	return
	//}
	//if count > 0 {
	//	br.Msg = "公共分类名称已存在，请重新输入"
	//	br.IsSendEmail = false
	//	return
	//}
	////获取该层级下最大的排序数
	//maxSort, err := data_manage.GetChartClassifyMaxSort(req.ParentId, req.ClassifyType)
	//
	//classify := new(data_manage.ChartClassify)
	//classify.ClassifyType = req.ClassifyType
	//classify.ParentId = req.ParentId
	//classify.ClassifyName = req.ClassifyName
	//classify.HasData = 0
	//classify.CreateTime = time.Now()
	//classify.ModifyTime = time.Now()
	//classify.SysUserId = c.SysUser.AdminId
	//classify.SysUserRealName = c.SysUser.RealName
	//classify.Level = req.Level + 1
	//timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	//classify.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
	//classify.Sort = maxSort
	//
	//_, err = data_manage.AddChartClassify(classify)
	//if err != nil {
	//	br.Msg = "保存公共分类失败"
	//	br.ErrMsg = "保存公共分类失败,Err:" + err.Error()
	//	return
	//}
	br.Ret = 200
	br.Msg = "新增成功"
	br.Success = true
	br.IsAddLog = true
}

// EditChartClassify
// @Title 修改公共分类
// @Description 修改公共分类接口
// @Param	request	body data_manage.EditChartClassifyReq true "type json string"
// @Success 200 Ret=200 修改成功
// @router /chart_public/classify/edit [post]
func (c *ChartPublicClassifyController) EditChartClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	var req data_manage.EditChartClassifyReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ChartClassifyName == "" {
		br.Msg = "请输入公共分类名称"
		br.IsSendEmail = false
		return
	}

	if req.ChartClassifyId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}

	err, errMsg := data.EditChartPublicClassify(req.ChartClassifyId, req.ChartClassifyName, c.SysUser)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = errMsg + ";Err:" + err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	br.Ret = 200
	br.Msg = "修改成功"
	br.Success = true
	br.IsAddLog = true
}

// DeleteClassifyCheck
// @Title 删除检测接口
// @Description 删除检测接口
// @Param	request	body request.PublicChartClassifyDeleteCheckReq true "type json string"
// @Success 200 Ret=200 检测成功
// @router /chart_public/classify/delete/check [post]
func (c *ChartPublicClassifyController) DeleteClassifyCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	var req request.PublicChartClassifyDeleteCheckReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ChartClassifyId <= 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}
	deleteStatus, tipsMsg, _, tableList, err, errMsg := data.DeleteChartPublicClassifyCheck(req.ChartClassifyId, c.SysUser)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	if c.Lang == "en" {
		if utils.ViperConfig.InConfig(tipsMsg) {
			tipsMsg = utils.ViperConfig.GetString(tipsMsg)
		}
	}

	//var deleteStatus int
	//var tipsMsg string
	////删除公共分类
	//if req.ClassifyId > 0 && req.ChartInfoId == 0 {
	//	//判断公共分类下，是否含有指标
	//	count, err := data_manage.GetChartInfoCountByClassifyId(req.ClassifyId)
	//	if err != nil {
	//		br.Msg = "删除失败"
	//		br.ErrMsg = "公共分类下是否含有指标失败，Err:" + err.Error()
	//		return
	//	}
	//
	//	if count > 0 {
	//		deleteStatus = 1
	//		tipsMsg = "若目录关联指标不可删除"
	//	}
	//}
	//
	//if deleteStatus != 1 && req.ChartInfoId == 0 {
	//	classifyCount, err := data_manage.GetClassifyCountByClassifyId(req.ClassifyId)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "删除失败"
	//		br.ErrMsg = "公共分类下是否含有指标失败，Err:" + err.Error()
	//		return
	//	}
	//	if classifyCount > 0 {
	//		deleteStatus = 2
	//		tipsMsg = "确认删除当前目录及包含的子目录吗"
	//	}
	//}
	//
	////删除指标
	//if req.ChartInfoId > 0 {
	//	//判断指标是否用于作图，如果用于作图，则不可删除
	//	chartCount, err := data_manage.GetChartChartMappingCount(req.ChartInfoId)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "删除失败"
	//		br.ErrMsg = "判断指标是否被用于作图失败，Err:" + err.Error()
	//		return
	//	}
	//	if chartCount > 0 {
	//		deleteStatus = 3
	//		tipsMsg = "当前指标已用作画图，不可删除"
	//	}
	//	//判断指标是否用于计算
	//	{
	//		calculateCount, err := data_manage.GetChartInfoCalculateMappingCount(req.ChartInfoId)
	//		if err != nil && !utils.IsErrNoRow(err) {
	//			br.Msg = "删除失败"
	//			br.ErrMsg = "判断指标是否被用于计算失败，GetChartInfoCalculateCount Err:" + err.Error()
	//			return
	//		}
	//		if calculateCount > 0 {
	//			deleteStatus = 4
	//			tipsMsg = "当前指标已用作，指标运算，不可删除"
	//		}
	//	}
	//}

	resp := new(data_manage.ClassifyDeleteCheckResp)
	resp.DeleteStatus = deleteStatus
	resp.TipsMsg = tipsMsg
	resp.TableList = tableList
	br.Ret = 200
	br.Msg = "检测成功"
	br.Success = true
	br.Data = resp
}

// DeleteClassify
// @Title 删除公共分类/指标
// @Description 删除公共分类/指标接口
// @Param	request	body request.PublicChartClassifyDeleteCheckReq true "type json string"
// @Success 200 Ret=200 删除成功
// @router /chart_public/classify/delete [post]
func (c *ChartPublicClassifyController) DeleteClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.PublicChartClassifyDeleteCheckReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ChartClassifyId <= 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}

	nextItem, _, err, errMsg := data.DeleteChartPublicClassify(req.ChartClassifyId, sysUser, string(c.Ctx.Input.RequestBody), c.Ctx.Input.URI())
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}

	resp := data_manage.AddChartInfoResp{}
	if nextItem != nil {
		resp = data_manage.AddChartInfoResp{
			ChartInfoId: nextItem.ChartInfoId,
			UniqueCode:  nextItem.UniqueCode,
		}
	}

	br.Ret = 200
	br.Msg = "删除成功"
	br.Success = true
	br.IsAddLog = true
	br.Data = resp
}

// ChartClassifyMove
// @Title 分类移动接口
// @Description 分类移动接口
// @Success 200 {object} data_manage.MoveChartClassifyReq
// @router /chart_public/chart_classify/move [post]
func (c *ChartPublicClassifyController) ChartClassifyMove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.MoveChartClassifyReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ClassifyId <= 0 && req.ChartInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "请选择拖动目标，分类目录或者指标"
		return
	}

	//if chartClassifyInfo.Source != utils.CHART_SOURCE_DEFAULT {
	//	br.Msg = "分类异常"
	//	br.ErrMsg = "分类异常,不是ETA图库的分类"
	//	return
	//}

	err, errMsg := data.MoveChartPublicClassify(req, sysUser)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	////判断分类是否存在
	//edbClassifyInfo, err := data_manage.GetEdbClassifyById(req.ClassifyId)
	//if err != nil {
	//	br.Msg = "移动失败"
	//	br.ErrMsg = "获取分类信息失败,Err:" + err.Error()
	//	return
	//}
	//updateCol := make([]string, 0)
	//
	////判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
	//if edbClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
	//	parentEdbClassifyInfo, err := data_manage.GetEdbClassifyById(req.ParentClassifyId)
	//	if err != nil {
	//		br.Msg = "移动失败"
	//		br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
	//		return
	//	}
	//	edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
	//	edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
	//	edbClassifyInfo.ModifyTime = time.Now()
	//	updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
	//}
	//
	////如果有传入 上一个兄弟节点分类id
	//if req.PrevClassifyId > 0 {
	//	prevClassify, err := data_manage.GetEdbClassifyById(req.PrevClassifyId)
	//	if err != nil {
	//		br.Msg = "移动失败"
	//		br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
	//		return
	//	}
	//
	//	//如果是移动在两个兄弟节点之间
	//	if req.NextClassifyId > 0 {
	//		//下一个兄弟节点
	//		nextClassify, err := data_manage.GetEdbClassifyById(req.NextClassifyId)
	//		if err != nil {
	//			br.Msg = "移动失败"
	//			br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
	//			return
	//		}
	//		//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
	//		if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == edbClassifyInfo.Sort {
	//			//变更兄弟节点的排序
	//			updateSortStr := `sort + 2`
	//			_ = data_manage.UpdateEdbClassifySortByParentId(prevClassify.ParentId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr)
	//		} else {
	//			//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
	//			if nextClassify.Sort-prevClassify.Sort == 1 {
	//				//变更兄弟节点的排序
	//				updateSortStr := `sort + 1`
	//				_ = data_manage.UpdateEdbClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
	//			}
	//		}
	//	}
	//
	//	edbClassifyInfo.Sort = prevClassify.Sort + 1
	//	edbClassifyInfo.ModifyTime = time.Now()
	//	updateCol = append(updateCol, "Sort", "ModifyTime")
	//} else {
	//	firstClassify, err := data_manage.GetFirstEdbClassifyByParentId(edbClassifyInfo.ParentId)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "移动失败"
	//		br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
	//		return
	//	}
	//
	//	//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
	//	if firstClassify != nil && firstClassify.ChartClassifyId > 0 && firstClassify.Sort == 0 {
	//		updateSortStr := ` sort + 1 `
	//		_ = data_manage.UpdateEdbClassifySortByParentId(firstClassify.ParentId, firstClassify.ClassifyId-1, 0, updateSortStr)
	//	}
	//
	//	edbClassifyInfo.Sort = 0 //那就是排在第一位
	//	edbClassifyInfo.ModifyTime = time.Now()
	//	updateCol = append(updateCol, "Sort", "ModifyTime")
	//}
	//
	////更新
	//if len(updateCol) > 0 {
	//	err = edbClassifyInfo.Update(updateCol)
	//	if err != nil {
	//		br.Msg = "移动失败"
	//		br.ErrMsg = "修改失败,Err:" + err.Error()
	//		return
	//	}
	//}
	br.Ret = 200
	br.Success = true
	br.Msg = "移动成功"
}