package assessment

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/archiveapi"
	"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/flipped-aurora/gin-vue-admin/server/model/testpage"
	"github.com/gin-gonic/gin"
)

/*
定量考核
*/
//添加定量考核
func (d *DutyHandle) AddRation(c *gin.Context) {
	var requestData AddRationCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if len(requestData.AcceptDepartmentId) <= 0 {
		response.Result(102, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(102, err, "请选择考核维度", c)
		return
	}

	if len(requestData.RationList) <= 0 {
		response.Result(102, err, "请添加测评详情！", c)
		return
	}
	var synergeticProcess dataLockStatistics
	for _, deparmentId := range requestData.AcceptDepartmentId {
		addDepartDimension(requestData.Group, deparmentId, requestData.Dimension, 2)
		syncProcess.Add(1)
		go synergeticProcess.addRationContList(deparmentId, requestData)
	}
	syncProcess.Wait()
	returData := commonus.MapOut()
	readDataMap, readBaoJinf := synergeticProcess.readMyDayData()

	returData["istrue"] = readDataMap
	returData["isfalse"] = readBaoJinf
	if len(readBaoJinf) > 0 && len(readDataMap) == 0 {
		response.Result(112, returData, "有未处理失败的数据！请检查", c)
	} else if len(readBaoJinf) > 0 && len(readDataMap) > 0 {
		response.Result(1, returData, "有部门数据处理失败！请针对性输入！", c)
	} else {
		response.Result(0, returData, "数据处理完成！", c)
	}
}

//关联集团部门考核维度
/*
@groupID			集团
@departId			部门
@dimensionId		维度
@key				1：定性考核；2：定量考核
*/
func addDepartDimension(groupID, departId, dimensionId string, key int64) {
	judgeMap := commonus.MapOut()
	judgeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimension{}).Select("dd_id").Where("`dd_group` = ? AND `dd_department` = ? AND `dd_dimension` = ?", groupID, departId, dimensionId).First(&judgeMap).Error
	if judgeErr != nil {
		var saveData assessmentmodel.DepartmentDimension
		saveData.Key = key
		departIdVal, _ := strconv.ParseInt(departId, 10, 64)
		saveData.DepartmentId = departIdVal
		dimensionIdVal, _ := strconv.ParseInt(dimensionId, 10, 64)
		saveData.Dimension = dimensionIdVal
		groupIDVal, _ := strconv.ParseInt(groupID, 10, 64)
		saveData.Group = groupIDVal
		saveData.Addtime = time.Now().Unix()
		insetErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
		if insetErr == nil {
		}
	}
}

func (d *dataLockStatistics) addRationContList(deparmentId string, addData AddRationCont) {
	d.mutext.Lock()
	defer d.mutext.Unlock()
	var saveDataAry []assessmentmodel.QualitativeEvaluation
	for _, v := range addData.RationList {
		var saveData assessmentmodel.QualitativeEvaluation
		juadgeMap := commonus.MapOut()
		juadgeInsetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? ", deparmentId, addData.Dimension, v.Target).First(&juadgeMap).Error
		if juadgeInsetErr != nil {
			groupInt, groupIntErr := strconv.ParseInt(addData.Group, 10, 64)
			if groupIntErr == nil {
				saveData.Group = groupInt
			}
			saveData.Type = addData.Type
			// departidInt, departinIntErr := strconv.ParseInt(v.DepartmentId, 10, 64)
			// if departinIntErr == nil {
			// 	saveData.DepartmentId = departidInt
			// }

			dimensionInt, departinIntErr := strconv.ParseInt(addData.Dimension, 10, 64)
			if departinIntErr == nil {
				saveData.Dimension = dimensionInt
			}

			targetInt, targetIntErr := strconv.ParseInt(v.Target, 10, 64)
			if targetIntErr == nil {
				saveData.Target = targetInt
			}

			saveData.Unit = v.Unit
			saveData.ReferenceScore = v.ReferenceScore
			saveData.Cycles = v.Cycles
			saveData.CycleAttres = v.CycleAttres

			saveData.State = 1
			saveData.Addtime = time.Now().Unix()
			saveData.Eitetime = time.Now().Unix()
			departmentIdInt, departmentIdIntErr := strconv.ParseInt(deparmentId, 10, 64)
			if departmentIdIntErr == nil {
				saveData.AcceptEvaluation = departmentIdInt
			}
			// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
			// if operatorIntErr == nil {
			// 	saveData.Operator = operatorInt
			// }
			saveData.Operator = strings.Join(v.Operator, ",")
			saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.Operator), ",")

			saveDataAry = append(saveDataAry, saveData)
			msg := commonus.MapOut()
			msg["msg"] = saveData
			d.dataMap = append(d.dataMap, msg)
		} else {
			detailedTargetInts, _ := strconv.ParseInt(v.Target, 10, 64)
			dtCont, dtIsTrue := commonus.GetTargetInfo(detailedTargetInts)

			groupInt, _ := strconv.ParseInt(addData.Group, 10, 64)
			departidInt, _ := strconv.ParseInt(deparmentId, 10, 64)
			_, groupCont := commonus.GetGroupCont(groupInt)
			_, deparConCont := commonus.GetBranchFactory(departidInt)
			msg := commonus.MapOut()
			if dtIsTrue == true {
				msg["msg"] = fmt.Sprintf("%v-%v定量考核《%v》考核项目已经存在！请重新处理此方案！->ID:%v", groupCont.Name, deparConCont.Name, dtCont.Title, detailedTargetInts)
			} else {
				msg["msg"] = fmt.Sprintf("%v-%v定量考核《%v》考核项目已经存在！请重新处理此方案！", groupCont.Name, deparConCont.Name, detailedTargetInts)
			}

			d.dataErrMap = append(d.dataErrMap, msg)
		}
	}
	if len(saveDataAry) > 0 {
		addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
		if addErr != nil {
			msg := commonus.MapOut()
			msg["data"] = saveDataAry
			msg["msg"] = fmt.Sprintf("《%v》考核维度录入失败！请重新处理此方案", addData.Dimension)
			d.dataErrMap = append(d.dataErrMap, msg)
		}
	}
	syncProcess.Done()
}

//批量获取相关人员部门id
func GetDepartmentByUserBast(userKey []string) (userDepartmentId []string) {
	if len(userKey) < 1 {
		return
	}
	var usDepartId []int64
	usDepartErr := global.GVA_DB_Master.Model(&testpage.WorkMan{}).Select("wm_bf_id").Where("`wm_key` IN ?", userKey).Group("wm_bf_id").Find(&usDepartId).Error
	if usDepartErr != nil {
		return
	}
	if len(usDepartId) < 1 {
		return
	}
	for _, v := range usDepartId {
		userDepartmentId = append(userDepartmentId, strconv.FormatInt(v, 10))
	}
	return
}

//定量考核方案列表
func (d *DutyHandle) RationList(c *gin.Context) {
	var requestData rationSelect
	c.ShouldBindJSON(&requestData)
	//归档集团
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_group").Where("qe_type = 2").Group("qe_group")
	if requestData.Group != "" {
		gormDb = gormDb.Having("qe_group = ?", requestData.Group)
	}
	var fileAry []int64
	listErr := gormDb.Find(&fileAry).Error
	if listErr != nil {
		response.Result(101, listErr, "没有数据！", c)
		return
	}
	if len(fileAry) < 1 {
		response.Result(102, listErr, "没有数据！", c)
		return
	}
	var aualEvalArrtAry []QualEvalRationListOut
	for _, v := range fileAry {
		var aualEvalArrtCont QualEvalRationListOut
		groupErr, groupCont := commonus.GetGroupCont(v)
		if groupErr == true {
			aualEvalArrtCont.Id = strconv.FormatInt(v, 10)
			aualEvalArrtCont.Name = groupCont.Name
			// 归档分厂-部室
			departAry, departAryErr := deparmentRationList(v, requestData.DepartmentId)
			if departAryErr == true {
				//分厂部室列表
				aualEvalArrtCont.Child = departAry
			}
			//组合集团
			aualEvalArrtAry = append(aualEvalArrtAry, aualEvalArrtCont)
		}
	}
	response.Result(0, aualEvalArrtAry, "查询完成！", c)
}

//归档部门
func deparmentRationList(groupID int64, departmentIDStr string) (contentList []QualEvalRationListOutDepart, isTrue bool) {
	isTrue = false
	gormDbDepart := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("qe_type = 2 AND `qe_group` = ?", groupID).Group("qe_accept_evaluation")
	if departmentIDStr != "" {
		gormDbDepart = gormDbDepart.Having("qe_accept_evaluation = ?", departmentIDStr)
	}
	var fileDepartAry []int64
	listDepartErr := gormDbDepart.Find(&fileDepartAry).Error
	if listDepartErr == nil {
		for _, v := range fileDepartAry {
			deparConErr, deparConCont := commonus.GetBranchFactory(v)
			var deparCont QualEvalRationListOutDepart
			if deparConErr == true {
				deparCont.Id = strconv.FormatInt(v, 10)
				deparCont.Name = deparConCont.Name
				//归档维度
				dimensionAry, dimensionAryErr := dimensionRationList(groupID, v)
				if dimensionAryErr == true {
					//维度列表
					deparCont.Child = dimensionAry
				}
			}
			//组合分厂部室
			contentList = append(contentList, deparCont)
		}

	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

//归档维度
func dimensionRationList(groupID, departmentID int64) (contentList []DimensionRationList, isTrue bool) {
	isTrue = false
	var fileDimensionAry []int64
	listDimensionErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_dimension").Where("qe_type = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ?", groupID, departmentID).Group("qe_dimension").Find(&fileDimensionAry).Error
	if listDimensionErr == nil {
		for _, v := range fileDimensionAry {
			dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(v)
			var dimenCont DimensionRationList
			if dutyClassErr == true {
				dimenCont.Id = strconv.FormatInt(v, 10)
				dimenCont.Name = dutyClassCont.Title
				//归档指标
				targerAry, targerAryErr := targetRationList(groupID, departmentID, v)
				if targerAryErr == true {
					//定性考核指标列表
					dimenCont.Child = targerAry
				}
				//组合维度
				contentList = append(contentList, dimenCont)
			}
		}
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

//查询归档定性指标
func targetRationList(groupID, departmentID, dimension int64) (contentList []taskDetails, isTrue bool) {
	isTrue = false
	var fileTargetAry []assessmentmodel.QualitativeEvaluation
	listTargetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("qe_type = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", groupID, departmentID, dimension).Find(&fileTargetAry).Error
	if listTargetErr != nil {
		return
	}
	for _, v := range fileTargetAry {
		var content taskDetails
		targetInfo, targetErr := commonus.GetTargetInfo(v.Target)
		if targetErr == true {
			content.Id = strconv.FormatInt(v.Target, 10)

			content.Name = targetInfo.Title
			content.QeId = strconv.FormatInt(v.Id, 10)
			content.Unit = v.Unit
			content.ReferenceScore = v.ReferenceScore
			content.Cycles = v.Cycles
			content.CycleAttres = v.CycleAttres
			content.State = v.State

			contentList = append(contentList, content)
		}
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

//删除定量考核
func (d *DutyHandle) DelRationList(c *gin.Context) {
	var requestData DelQualitative
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(103, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(104, err, "请选择考核维度", c)
		return
	}
	if requestData.Target == "" {
		response.Result(105, err, "请选择考核指标", c)
		return
	}
	if requestData.Type == 0 {
		requestData.Type = 2
	}

	delOldContErr := global.GVA_DB_Performanceappraisal.Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target).Delete(&assessmentmodel.QualitativeEvaluation{}).Error

	if delOldContErr == nil {
		response.Result(0, delOldContErr, "删除成功！", c)
	} else {
		response.Result(102, delOldContErr, "删除失败！", c)
	}
}

//获取定量考核
func (d *DutyHandle) GetRationList(c *gin.Context) {
	var requestData QualitativeEite
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(102, requestData, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(102, err, "请选择考核维度", c)
		return
	}
	var quaAry []assessmentmodel.QualitativeEvaluation
	var quaOutAry QualitativeEiteOut
	quaOutAry.Group = requestData.Group
	quaOutAry.DepartmentId = requestData.DepartmentId
	quaOutAry.Dimension = requestData.Dimension

	// quaOutAry.List = requestData.List
	quaErr := global.GVA_DB_Performanceappraisal.Where("`qe_type` = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension).Find(&quaAry).Error
	if quaErr != nil {
		response.Result(102, quaErr, "数据获取失败！", c)
		return
	}
	// var targetInfo assessmentmodel.EvaluationTarget
	// targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.Target).First(&targetInfo).Error
	for _, v := range quaAry {

		// detTarCont, detTarContErr := commonus.GetDetailedTargetInfo(v.DetailedTarget)
		targetInfo, targetErr := commonus.GetTargetInfo(v.Target)
		if targetErr == true {
			var outCont taskDetailsLinkage
			outCont.Id = strconv.FormatInt(v.Id, 10)
			outCont.Name = targetInfo.Title
			// outCont.Content = targetInfo.Content
			outCont.State = v.State
			// if targetInfoErr == nil {
			outCont.Unit = v.Unit
			// outCont.ReferenceScore = v.Content
			outCont.Cycles = v.Cycles
			outCont.CycleAttres = v.CycleAttres
			if targetInfo.Report != "" {
				userKeyAry := strings.Split(v.Operator, ",")
				if len(userKeyAry) > 0 {
					outCont.UserList = userKeyAry
					for _, u_v := range userKeyAry {
						usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": u_v})
						if usErr == true {
							var userCont QualEvalArrt
							userCont.Id = u_v
							userCont.Name = usCont.Name
							outCont.UserListAry = append(outCont.UserListAry, userCont)
						}
					}
				}
			}
			// }

			quaOutAry.List = append(quaOutAry.List, outCont)
		}

	}
	response.Result(0, quaOutAry, "数据获取成功！", c)
}

//修改定量考核
func (d *DutyHandle) EiteRationList(c *gin.Context) {
	var requestData QualitativeEiteOut
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(102, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(102, err, "请选择考核维度", c)
		return
	}
	if len(requestData.List) < 1 {
		response.Result(102, err, "考核细则不能为空", c)
		return
	}

	//开启事务处理
	affairDb := global.GVA_DB_Performanceappraisal.Begin()
	delOldContErr := affairDb.Where("`qe_type` = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension).Delete(&assessmentmodel.QualitativeEvaluation{}).Error
	var quaEvaCont []assessmentmodel.QualitativeEvaluation
	for _, v := range requestData.List {
		var saveData assessmentmodel.QualitativeEvaluation

		groupInt, groupIntErr := strconv.ParseInt(requestData.Group, 10, 64)
		if groupIntErr == nil {
			saveData.Group = groupInt
		}
		saveData.Type = 1

		dimensionInt, departinIntErr := strconv.ParseInt(requestData.Dimension, 10, 64)
		if departinIntErr == nil {
			saveData.Dimension = dimensionInt
		}

		targetInt, targetIntErr := strconv.ParseInt(v.Id, 10, 64)
		if targetIntErr == nil {
			saveData.Target = targetInt
		}

		saveData.Unit = v.Unit
		saveData.ReferenceScore = v.ReferenceScore
		saveData.Cycles = v.Cycles
		saveData.CycleAttres = v.CycleAttres

		saveData.State = 1
		saveData.Addtime = time.Now().Unix()
		saveData.Eitetime = time.Now().Unix()

		departmentIdInt, departmentIdIntErr := strconv.ParseInt(requestData.DepartmentId, 10, 64)
		if departmentIdIntErr == nil {
			saveData.AcceptEvaluation = departmentIdInt
		}
		saveData.Operator = strings.Join(v.UserList, ",")
		// fmt.Printf("%v-------->%v\n", GetDepartmentByUserBast(v.UserList), strings.Join(GetDepartmentByUserBast(v.UserList), ","))
		saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.UserList), ",")
		// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
		// if operatorIntErr == nil {
		// 	saveData.Operator = strings.Join(v.Operator,",")
		// }
		// saveData.AcceptEvaluation = departmentIdInt

		quaEvaCont = append(quaEvaCont, saveData)
	}
	var infoAttrErr error
	if len(quaEvaCont) > 0 {
		infoAttrErr = affairDb.Create(&quaEvaCont).Error
	}
	if delOldContErr == nil && infoAttrErr == nil {
		delOldContErr = affairDb.Commit().Error
		if delOldContErr != nil {
			delOldContErr = affairDb.Rollback().Error
			response.Result(102, err, "数据写入失败！请重新提交！", c)
			return
		}
		response.Result(0, err, "数据写入成功！", c)
	} else {
		delOldContErr = affairDb.Rollback().Error
		response.Result(102, err, "数据写入失败！请重新提交！", c)
	}

}