package dutyassess

import (
	"strconv"
	"strings"
	"time"

	"github.com/flipped-aurora/gin-vue-admin/server/commonus"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/assessmentmodel"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/gin-gonic/gin"
)

//获取定性考核指标列表(下拉列表)
func (d *DutyAssessApi) SelectDutyList(c *gin.Context) {
	var evalTargetList []assessmentmodel.EvaluationTarget
	err := global.GVA_DB_Performanceappraisal.Where("`et_type` = 1 AND `et_state` = 1").Find(&evalTargetList).Error
	if err != nil {
		response.Result(101, err, "没有数据！", c)
		return
	}
	var listAry []DutySelectList
	for _, v := range evalTargetList {
		var cont DutySelectList
		cont.Id = v.Id

		cont.Title = v.Title
		cont.Type = v.Type
		cont.State = v.State
		cont.AddTime = v.AddTime
		cont.Share = v.Share
		cont.RelevantDepartments = v.RelevantDepartments
		cont.Dimension = v.Dimension
		cont.Key = v.Key
		cont.Report = v.Report
		cont.Uniteing = v.Uniteing
		cont.Cycles = v.Cycles
		cont.CycleAttres = v.CycleAttres
		cont.VisibleRange = v.VisibleRange
		cont.VisibleRangeGroup = v.VisibleRangeGroup
		cont.DepartmentList = strings.Split(v.RelevantDepartments, ",")
		listAry = append(listAry, cont)
	}
	response.Result(0, listAry, "查询完成！", c)
}

//定性考核列表（部门方案用的）
func (d *DutyAssessApi) DutyDepartmentList(c *gin.Context) {
	var requestData getDepartAssObtains
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	var targetId []int64
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target")
	if requestData.DepartID != "" {
		gormDb = gormDb.Where("`qe_accept_evaluation` = ?", requestData.DepartID)
	}
	gormDb = gormDb.Where("`qe_state` = 1 AND `qe_type` = 1")
	listTargetErr := gormDb.Group("qe_target").Find(&targetId).Error
	if listTargetErr != nil {
		response.Result(101, listTargetErr, "没有数据！", c)
		return
	}
	var targetList []OutDutyList
	for _, v := range targetId {
		var targetCont OutDutyList
		targetCont.Id = strconv.FormatInt(v, 10)
		tarCont, _ := commonus.GetTargetInfo(v)

		targetCont.Target = strconv.FormatInt(v, 10)                    //指标ID
		targetCont.TargetName = tarCont.Title                           //指标名称
		targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
		dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
		if dutyClassErr == true {
			targetCont.DimensionName = dutyClassCont.Title //维度名称
		}
		targetCont.Content = ""                      //指标说明
		targetCont.Unit = tarCont.Uniteing           //单位"`
		targetCont.ReferenceScore = 0                //标准分值"`
		targetCont.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
		targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
		targetCont.State = 1
		targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(v, 1)

		targetList = append(targetList, targetCont)
	}
	// var qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
	response.Result(0, targetList, "查询完成！", c)
}

//获取方案中的所有所有相关部们
func GetDutyFangAnDepart(dutyId int64, class int) (departId []int64, departAry []DepartmentAryType) {
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("`qe_state` = 1 AND `qe_target` = ? AND `qe_type` = ?", dutyId, class).Group("qe_accept_evaluation").Find(&departId).Error
	if err != nil {
		return
	}

	for _, v := range departId {
		deparConErr, deparConCont := commonus.GetBranchFactory(v)
		if deparConErr == true {
			var departcont DepartmentAryType
			departcont.Parentname = deparConCont.Name
			departcont.Parentid = strconv.FormatInt(v, 10)
			departAry = append(departAry, departcont)
		}
	}
	return
}

//根据指标ID获取列表信息
func (d *DutyAssessApi) IdToTargetSunList(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	tarCont, isTrue := commonus.GetTargetInfo(requestData.Id)
	if isTrue != true {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	var targetCont TargetFormId
	targetCont.Id = strconv.FormatInt(requestData.Id, 10)
	targetCont.Target = strconv.FormatInt(requestData.Id, 10)       //指标ID
	targetCont.TargetName = tarCont.Title                           //指标名称
	targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
	dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
	if dutyClassErr == true {
		targetCont.DimensionName = dutyClassCont.Title //维度名称
	}
	targetCont.Content = ""                      //指标说明
	targetCont.Unit = tarCont.Uniteing           //单位"`
	targetCont.ReferenceScore = 0                //标准分值"`
	targetCont.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
	targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
	targetCont.State = 1
	targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(requestData.Id, 1)
	targetCont.SunTargetList = GetSunTargetList(requestData.Id, tarCont.Dimension, targetCont.DepartmentId)
	targetCont.Reportmap = strings.Split(tarCont.Report, ",")

	// for _, vv := range jieguo {
	// 	targetCont.SunTargetList = append(targetCont.SunTargetList, vv)
	// }
	// targetCont.SunTargetList = jieguo
	// jsonstr, _ := json.Marshal(targetCont)
	// fmt.Printf("+++++++++>%v----->\n", string(jsonstr))
	response.Result(0, targetCont, "查询完成！", c)
}

//获取子指标和指标详情
func GetSunTargetList(targetId, demID int64, parAryId []int64) (cont []SunTargetListType) {
	var qualTargetCont []assessmentmodel.QualitativeTarget
	err := global.GVA_DB_Performanceappraisal.Where("`q_state` = 1 AND `q_parent_id` = ?", targetId).Find(&qualTargetCont).Error
	if err != nil {
		return
	}
	// fmt.Printf("%v\n", qualTargetCont)
	for _, v := range qualTargetCont {
		var sunCont SunTargetListType
		sunCont.Id = strconv.FormatInt(v.Id, 10)
		sunCont.Title = v.Title
		sunCont.DetailedTarget = GetDetailTrager(targetId, v.Id, demID, parAryId)
		// fmt.Printf("-->%v-->%v\n", v.Id, v.Title)
		cont = append(cont, sunCont)
	}
	// fmt.Printf("=========>%v\n", cont)
	return
}

//获取指标详情
func GetDetailTrager(targetId, detId, demID int64, parAryId []int64) (cont []DetailedTargetType) {
	var qualTargetCont []assessmentmodel.DetailedTarget
	err := global.GVA_DB_Performanceappraisal.Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", targetId, detId).Find(&qualTargetCont).Error
	if err != nil {
		return
	}
	for _, v := range qualTargetCont {
		var sunCont DetailedTargetType
		sunCont.Id = strconv.FormatInt(v.Id, 10)
		sunCont.Title = v.Title
		sunCont.UserList, sunCont.UserListAry = GetOperator(demID, targetId, detId, v.Id, parAryId)
		cont = append(cont, sunCont)
	}
	return
}

//获取执行人
func GetOperator(dimID, tarId, sunTarId, detaId int64, parAryId []int64) (UserList []string, UserListAry []QualEvalArrt) {
	var qualEval []assessmentmodel.QualitativeEvaluation
	err := global.GVA_DB_Performanceappraisal.Where("`qe_state` = 1 AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ? AND `qe_accept_evaluation` IN ?", dimID, tarId, sunTarId, detaId, parAryId).Find(&qualEval).Error
	if err != nil {
		return
	}

	for _, v := range qualEval {
		if v.Operator != "" {
			usAry := strings.Split(v.Operator, ",")
			if len(usAry) > 0 {
				for _, vv := range usAry {

					if commonus.IsItTrueString(vv, UserList) == false {
						UserList = append(UserList, vv)
						usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": vv})
						if usErr == true {
							var userCont QualEvalArrt
							userCont.Id = vv
							userCont.Name = usCont.Name
							UserListAry = append(UserListAry, userCont)
						}
					}
				}
			}
		}
	}
	return
}

//获取定性指标->指标细则修改回显
func (d *DutyAssessApi) GetDetailedTargetCallBack(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	var cont assessmentmodel.QualitativeEvaluation
	errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
	if errErr != nil {
		response.Result(103, err, "没有获取到数据！", c)
		return
	}
	//输出格式
	var content OutTargetCont
	content.Id = strconv.FormatInt(requestData.Id, 10)
	//获取子栏目信息
	sunTargetCont, _ := commonus.GetQualitativeTargetInfo(cont.TargetSun)
	content.SunTargerId = strconv.FormatInt(sunTargetCont.Id, 10)
	content.SunTargetName = sunTargetCont.Title
	//获取指标细则信息
	detaileInfo, _ := commonus.GetDetailedTargetInfo(cont.DetailedTarget)
	content.DetailedTargetId = strconv.FormatInt(detaileInfo.Id, 10)
	content.DetailedTargetName = detaileInfo.Title
	content.DetailedTargetContent = detaileInfo.Content
	shenPiRen := strings.Split(cont.Operator, ",")
	content.Operator = shenPiRen
	for _, v := range shenPiRen {
		usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": v})
		if usErr == true {
			var userCont QualEvalArrt
			userCont.Id = v
			userCont.Name = usCont.Name
			content.OperatorAry = append(content.OperatorAry, userCont)
		}
	}
	//获取所有子栏目
	var qualTar []assessmentmodel.QualitativeTarget
	quaTarErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ?", cont.Target).Find(&qualTar).Error
	if quaTarErr == nil {
		for _, s_v := range qualTar {
			var sunTarCont QualEvalArrt
			sunTarCont.Id = strconv.FormatInt(s_v.Id, 10)
			sunTarCont.Name = s_v.Title
			content.SunTargerList = append(content.SunTargerList, sunTarCont)
		}
	}
	response.Result(0, content, "获取成功！", c)
}

//获取定性指标->指标细则修改回显
func (d *DutyAssessApi) EiteDetailedTargetCallBack(c *gin.Context) {
	var requestData GetEiteTargetCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	var cont assessmentmodel.QualitativeEvaluation
	errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
	if errErr != nil {
		response.Result(103, err, "未能获取到数据！", c)
		return
	}
	isTrue := false
	if requestData.Class != 1 {
		isTrue = NewEiteData(requestData, cont)
	} else {
		isTrue = NewAddData(requestData, cont)
	}
	if isTrue == false {
		response.Result(104, err, "数据处理失败", c)
		return
	}
	response.Result(0, err, "数据处理成功", c)
}

//新增
func NewAddData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
	isTrue = false
	var detailedTargetInfo assessmentmodel.DetailedTarget
	detailedTargetInfo.Title = getData.DetailedTargetName
	detailedTargetInfo.Content = getData.DetailedTargetContent
	detailedTargetInfo.ParentId = oldData.Target
	detailedTargetInfo.ParentIdSun = oldData.TargetSun
	detailedTargetInfo.State = 1
	detailedTargetInfo.AddTime = time.Now().Unix()
	addErr := global.GVA_DB_Performanceappraisal.Create(&detailedTargetInfo).Error
	if addErr != nil {
		return
	}
	var saveData assessmentmodel.QualitativeEvaluation
	saveData.Title = oldData.Title
	saveData.DepartmentId = oldData.DepartmentId
	saveData.Dimension = oldData.Dimension
	saveData.Target = oldData.Target
	saveData.TargetSun = oldData.TargetSun
	saveData.DetailedTarget = detailedTargetInfo.Id
	saveData.Type = oldData.Type
	saveData.Weight = oldData.Weight
	saveData.Unit = oldData.Unit
	saveData.ReferenceScore = oldData.ReferenceScore
	saveData.State = oldData.State
	saveData.Addtime = time.Now().Unix()
	saveData.Eitetime = time.Now().Unix()
	saveData.Group = oldData.Group
	saveData.QualEvalId = oldData.QualEvalId
	saveData.Cycles = oldData.Cycles
	saveData.CycleAttres = oldData.CycleAttres
	saveData.AcceptEvaluation = oldData.AcceptEvaluation
	saveData.Operator = oldData.Operator
	saveData.Content = oldData.Content
	addErrQE := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
	if addErrQE != nil {
		return
	}
	isTrue = true
	return
}

//修改
func NewEiteData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
	isTrue = false
	eiteDetailedInfo := commonus.MapOut()
	eiteDetailedInfo["dt_time"] = time.Now().Unix()
	if getData.DetailedTargetName != "" {
		eiteDetailedInfo["dt_title"] = getData.DetailedTargetName
	}
	if getData.DetailedTargetContent != "" {
		eiteDetailedInfo["dt_content"] = getData.DetailedTargetContent
	}
	eiteDetaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", oldData.DetailedTarget).Updates(&eiteDetailedInfo).Error
	if eiteDetaInfoErr != nil {
		return
	}
	if len(getData.Operator) > 0 {
		eiteQualEvlInfo := commonus.MapOut()
		eiteQualEvlInfo["qe_eitetime"] = time.Now().Unix()
		eiteQualEvlInfo["qe_operator"] = strings.Join(getData.Operator, ",")
		eiteQualEvlInfo["qe_department_id"] = strings.Join(commonus.GetDepartmentByUserBast(getData.Operator), ",")
		eiteDetaQuaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` = ?", oldData.Id).Updates(&eiteQualEvlInfo).Error
		if eiteDetaQuaInfoErr != nil {
			return
		}
	}
	isTrue = true
	return
}

//修改子栏目名称
func (d *DutyAssessApi) EiteSunTargetName(c *gin.Context) {
	var requestData QualEvalArrt
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Name == "" {
		response.Result(103, err, "参数错误！请重新提交！", c)
		return
	}
	var oldId int64
	errCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_id").Where("`q_id` = ?", requestData.Id).First(&oldId).Error
	if errCont != nil {
		response.Result(104, err, "没有该数据！", c)
		return
	}
	eiteCont := commonus.MapOut()
	eiteCont["q_time"] = time.Now().Unix()
	eiteCont["q_title"] = requestData.Name
	errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", requestData.Id).Updates(&eiteCont).Error
	if errEiteCont != nil {
		response.Result(105, err, "修改失败！", c)
		return
	}
	response.Result(0, err, "数据处理成功", c)
}