package assessment

import (
	"strconv"
	"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/flipped-aurora/gin-vue-admin/server/model/testpage"
	"github.com/flipped-aurora/gin-vue-admin/server/model/wechat"
	"github.com/gin-gonic/gin"
)

//具体部门职责
func (d *DutyHandle) SpecificDutyList(c *gin.Context) {
	var requestData specificDutyRequest
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)

	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartDuty{}).Where("`de_satte` IN ?", []int{1, 2})
	if requestData.DepartmentId != "" {
		departId, departErr := strconv.ParseInt(requestData.DepartmentId, 10, 64)
		if departErr == nil {
			gormDb = gormDb.Where("`de_partid` = ?", departId)
		}

	}

	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}

	var dutyList []assessmentmodel.DepartDuty
	dutyListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&dutyList).Error
	if dutyListerr != nil {
		response.Result(103, dutyListerr, "数据获取失败！", c)
		return
	}
	var dutyListCont []specificDutyOut
	for _, val := range dutyList {
		var dutyCont specificDutyOut

		dutyCont.Id = val.Id
		dutyCont.Title = val.Title
		dutyCont.State = val.State
		dutyCont.Time = val.Time
		dutyCont.PartId = val.PartId
		dutyCont.ClassId = val.ClassId
		dutyCont.AssessId = val.AssessId
		dutyCont.DutyId = val.DutyId
		dutyCont.Rescore = val.Rescore
		dutyCont.OutId = strconv.FormatInt(val.Id, 10)

		//职责分类
		dutyCont.ClassIdStr = strconv.FormatInt(val.ClassId, 10)
		isTrue, classCont := GetDutyClassCont(val.ClassId)
		if isTrue == true {
			dutyCont.ClassTitle = classCont.Title
		}
		//职责项目
		dutyCont.AssEssIdStr = strconv.FormatInt(val.AssessId, 10)
		isTrueAssEss, assessCont := GetAssEssCont(val.AssessId)
		if isTrueAssEss == true {
			dutyCont.AssEssTitle = assessCont.Title
		}
		//具体职责
		dutyCont.DutyIdStr = strconv.FormatInt(val.DutyId, 10)
		isTrueDuty, dutyContInfo := GetDutyInfoCont(val.DutyId)
		if isTrueDuty == true {
			dutyCont.DutyTitle = dutyContInfo.Title
		}

		isTrueGroup, groupCont := GetGroupCont(val.Group)
		if isTrueGroup == true {
			dutyCont.GroupTitle = groupCont.Name
		}

		//具体职责
		dutyCont.ParentId = strconv.FormatInt(val.PartId, 10)
		isTrueBranFact, branFactCont := GetBranchFactory(val.PartId)
		if isTrueBranFact == true {
			dutyCont.ParentTitle = branFactCont.Name
		}

		dutyListCont = append(dutyListCont, dutyCont)
	}
	countSum := len(dutyListCont)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, dutyListCont)
	response.Result(0, printData, "查询成功！", c)
}

//添加具体职责
func (d *DutyHandle) AddSpecificDutyInfo(c *gin.Context) {
	var requestData addSpecificDutyCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	var parentId, classId, assessId, dutyId int64
	if requestData.ParentId == "" {
		response.Result(102, err, "请指定归属于被考核部门", c)
		return
	} else {
		parentId, _ = strconv.ParseInt(requestData.ParentId, 10, 64)
	}
	if requestData.ClassId == "" {
		response.Result(103, err, "请指定考核类别", c)
		return
	} else {
		classId, _ = strconv.ParseInt(requestData.ClassId, 10, 64)
	}
	if requestData.AssEssId == "" {
		response.Result(104, err, "请指定考核项目", c)
		return
	} else {
		assessId, _ = strconv.ParseInt(requestData.AssEssId, 10, 64)
	}
	if requestData.DutyId == "" {
		response.Result(105, err, "请指定考核具体职责", c)
		return
	} else {
		dutyId, _ = strconv.ParseInt(requestData.DutyId, 10, 64)
	}
	if requestData.Score < 1 {
		response.Result(106, err, "请指定该具体职责参考分值", c)
		return
	}
	var ScoreAll int64
	var specDutyInfo assessmentmodel.DepartDuty

	scoreErr := global.GVA_DB_Performanceappraisal.Model(&specDutyInfo).Where("`de_partid` = ?", parentId).Pluck("COALESCE(SUM(de_rescore), 0) as rescore", &ScoreAll).Error
	if scoreErr != nil {
		ScoreAll = 0
	}
	if ScoreAll+requestData.Score > 1000 {
		response.Result(107, err, "该部门的总分值超过100。请重新写入该考核项目参考分值！", c)
		return
	}
	if requestData.Group == 0 {
		requestData.Group = 3
	}
	specDutyInfo.Id = commonus.GetFileNumberEs()
	specDutyInfo.Title = ""
	specDutyInfo.State = 1
	specDutyInfo.Time = time.Now().Unix()
	specDutyInfo.PartId = parentId
	specDutyInfo.ClassId = classId
	specDutyInfo.AssessId = assessId
	specDutyInfo.DutyId = dutyId
	specDutyInfo.Rescore = requestData.Score
	specDutyInfo.Group = requestData.Group
	dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&specDutyInfo).Error
	if dutyInfoErr != nil {
		response.Result(108, specDutyInfo, "数据写入失败！", c)
	} else {
		response.Result(0, specDutyInfo, "数据写入成功！", c)
	}
}

//添加部门具体职责
func (d *DutyHandle) AddDepartDutyInfo(c *gin.Context) {
	var requestData addDepartDutyCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	var parentId, dutyId int64
	if requestData.ParentId == "" {
		response.Result(102, err, "请指定归属于被考核部门", c)
		return
	} else {
		parentIds, parentIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
		if parentIdErr != nil {
			response.Result(103, err, "请指定归属于被考核部门", c)
			return
		}
		parentId = parentIds
	}

	if requestData.DutyId == "" {
		response.Result(105, err, "请指定考核具体职责", c)
		return
	} else {
		dutyIds, dutyIdErr := strconv.ParseInt(requestData.DutyId, 10, 64)
		if dutyIdErr != nil {
			response.Result(103, err, "请指定考核具体职责", c)
			return
		}
		dutyId = dutyIds
	}

	assIsTrue, assInfo := GetDutyInfoContAll(dutyId)
	if assIsTrue != true {
		response.Result(104, dutyId, "请指定考核项目已禁止使用！", c)
		return
	}

	if requestData.Score < 1 {
		response.Result(105, err, "请指定该具体职责参考分值", c)
		return
	}
	var ScoreAll int64
	var specDutyInfo assessmentmodel.DepartDuty

	scoreErr := global.GVA_DB_Performanceappraisal.Model(&specDutyInfo).Where("`de_partid` = ?", parentId).Pluck("COALESCE(SUM(de_rescore), 0) as rescore", &ScoreAll).Error
	if scoreErr != nil {
		ScoreAll = 0
	}
	if ScoreAll+requestData.Score > 1000 {
		response.Result(106, err, "该部门的总分值超过100。请重新写入该考核项目参考分值！", c)
		return
	}
	//获取部门详细信息
	bfIsTrue, bfInfo := GetBranchFactory(parentId)
	if bfIsTrue != true {
		response.Result(107, err, "该部门不存在，请检查您的提交！", c)
		return
	}

	specDutyInfo.Id = commonus.GetFileNumberEs()
	specDutyInfo.Title = ""
	specDutyInfo.State = 1
	specDutyInfo.Time = time.Now().Unix()
	specDutyInfo.PartId = parentId
	specDutyInfo.ClassId = assInfo.ClassId
	specDutyInfo.AssessId = assInfo.AssessId
	specDutyInfo.DutyId = dutyId
	specDutyInfo.Rescore = requestData.Score
	specDutyInfo.Group = bfInfo.Group
	dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&specDutyInfo).Error
	if dutyInfoErr != nil {
		response.Result(108, specDutyInfo, "数据写入失败！", c)
	} else {
		response.Result(0, specDutyInfo, "数据写入成功！", c)
	}
}

//编辑具体内容
func (d *DutyHandle) EiteDepartDutyInfo(c *gin.Context) {
	var requestData eiteDepartDutyCont
	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
		}
	}
	saveData := commonus.MapOut()

	var parentId, dutyId int64
	if requestData.ParentId != "" {
		parentId, _ = strconv.ParseInt(requestData.ParentId, 10, 64)
		saveData["de_partid"] = parentId
		bfIsTrue, bfInfo := GetBranchFactory(parentId)
		if bfIsTrue == true {
			saveData["de_group"] = bfInfo.Group
		}

	}

	if requestData.DutyId != "" {
		dutyId, _ = strconv.ParseInt(requestData.DutyId, 10, 64)
		saveData["de_duty"] = dutyId
		assIsTrue, assInfo := GetAssEssCont(dutyId)
		if assIsTrue == true {
			saveData["de_class"] = assInfo.PartId
			saveData["de_assess"] = assInfo.Id
		}
	}
	if requestData.Score > 0 {
		var ScoreAll int64
		var specDutyInfo assessmentmodel.DepartDuty

		scoreErr := global.GVA_DB_Performanceappraisal.Model(&specDutyInfo).Where("`de_partid` = ?", parentId).Pluck("COALESCE(SUM(de_rescore), 0) as rescore", &ScoreAll).Error
		if scoreErr != nil {
			ScoreAll = 0
		}
		if ScoreAll+requestData.Score > 1000 {
			response.Result(107, err, "该部门的总分值超过100。请重新写入该考核项目参考分值！", c)
			return
		}
		saveData["de_rescore"] = requestData.Score
	}

	saveData["de_time"] = time.Now().Unix()
	isTrue, isErr := eiteSpecificDutyInfoCont(requestData.Id, saveData)
	if isTrue != true {
		response.Result(104, isErr, "修改失败！", c)
		return
	}
	response.Result(0, saveData, "修改成功！", c)

}

//获取部门具体考核项目
func (d *DutyHandle) GetSpecDutyCont(c *gin.Context) {
	var requestData commonus.SetId
	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 dutyOutInfo specificDutyOut
	inFoErr := global.GVA_DB_Performanceappraisal.Where("`de_id` = ?", requestData.Id).First(&dutyOutInfo).Error
	if inFoErr != nil {
		response.Result(103, inFoErr, "数据查询失败！", c)
		return
	}
	dutyOutInfo.OutId = strconv.FormatInt(dutyOutInfo.Id, 10)
	//职责分类
	dutyOutInfo.ClassIdStr = strconv.FormatInt(dutyOutInfo.ClassId, 10)
	isTrue, classCont := GetDutyClassCont(dutyOutInfo.ClassId)
	if isTrue == true {
		dutyOutInfo.ClassTitle = classCont.Title
	}
	//职责项目
	dutyOutInfo.AssEssIdStr = strconv.FormatInt(dutyOutInfo.AssessId, 10)
	isTrueAssEss, assessCont := GetAssEssCont(dutyOutInfo.AssessId)
	if isTrueAssEss == true {
		dutyOutInfo.AssEssTitle = assessCont.Title
	}
	//具体职责
	dutyOutInfo.DutyIdStr = strconv.FormatInt(dutyOutInfo.DutyId, 10)
	isTrueDuty, dutyCont := GetDutyInfoCont(dutyOutInfo.DutyId)
	if isTrueDuty == true {
		dutyOutInfo.DutyTitle = dutyCont.Title
	}

	isTrueGroup, groupCont := GetGroupCont(dutyOutInfo.Group)
	if isTrueGroup == true {
		dutyOutInfo.GroupTitle = groupCont.Name
	}

	//具体职责
	dutyOutInfo.ParentId = strconv.FormatInt(dutyOutInfo.PartId, 10)
	isTrueBranFact, branFactCont := GetBranchFactory(dutyOutInfo.PartId)
	if isTrueBranFact == true {
		dutyOutInfo.ParentTitle = branFactCont.Name
	}

	response.Result(0, dutyOutInfo, "数据查询成功！", c)
}

//获取集团信息
func GetGroupCont(id int64) (isTrue bool, ContInfo wechat.GroupForm) {
	isTrue = false
	err := global.GVA_DB_WatchDate.Where("g_id = ?", id).First(&ContInfo).Error
	if err == nil {
		isTrue = true
	}
	return
}

//获得分厂名称
func GetBranchFactory(id int64) (isTrue bool, ContInfo testpage.BranchFactory) {
	isTrue = false
	err := global.GVA_DB_Master.Where("bf_id = ?", id).First(&ContInfo).Error
	if err == nil {
		isTrue = true
	}
	return
}

//编辑具体内容
func (d *DutyHandle) EiteSpecFicDutyInfo(c *gin.Context) {
	var requestData eiteSpecificDutyCont
	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
		}
	}
	saveData := commonus.MapOut()

	var parentId, classId, assessId, dutyId int64
	if requestData.ParentId != "" {
		parentId, _ = strconv.ParseInt(requestData.ParentId, 10, 64)
		saveData["de_partid"] = parentId
	}
	if requestData.ClassId != "" {
		classId, _ = strconv.ParseInt(requestData.ClassId, 10, 64)
		saveData["de_class"] = classId
	}
	if requestData.AssEssId != "" {
		assessId, _ = strconv.ParseInt(requestData.AssEssId, 10, 64)
		saveData["de_assess"] = assessId
	}
	if requestData.DutyId != "" {
		dutyId, _ = strconv.ParseInt(requestData.DutyId, 10, 64)
		saveData["de_duty"] = dutyId
	}
	if requestData.Score > 0 {
		var ScoreAll int64
		var specDutyInfo assessmentmodel.DepartDuty

		scoreErr := global.GVA_DB_Performanceappraisal.Model(&specDutyInfo).Where("`de_partid` = ?", parentId).Pluck("COALESCE(SUM(de_rescore), 0) as rescore", &ScoreAll).Error
		if scoreErr != nil {
			ScoreAll = 0
		}
		if ScoreAll+requestData.Score > 1000 {
			response.Result(107, err, "该部门的总分值超过100。请重新写入该考核项目参考分值！", c)
			return
		}
		saveData["de_rescore"] = requestData.Score
	}

	if requestData.Group != 0 {
		saveData["de_group"] = requestData.Group
	}

	saveData["de_time"] = time.Now().Unix()
	isTrue, isErr := eiteSpecificDutyInfoCont(requestData.Id, saveData)
	if isTrue != true {
		response.Result(104, isErr, "修改失败！", c)
		return
	}
	response.Result(0, saveData, "修改成功！", c)

}

//编辑具体职责内容
func eiteSpecificDutyInfoCont(saveId int64, saveData map[string]interface{}) (isTrue bool, dutyClassInfoErr error) {
	var modelInfo assessmentmodel.DepartDuty
	isTrue = false
	dutyClassInfoErr = global.GVA_DB_Performanceappraisal.Model(&modelInfo).Where("de_id = ?", saveId).Updates(saveData).Error
	if dutyClassInfoErr != nil {
		return
	}
	isTrue = true
	return
}

//修改考核项目的状态
func (d *DutyHandle) EiteSpecficDutyState(c *gin.Context) {
	var requestData dutyClassState
	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
		}
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	saveData := commonus.MapOut()
	saveData["de_satte"] = requestData.State
	saveData["de_time"] = time.Now().Unix()
	var eiteAssEssStateInfo assessmentmodel.DepartDuty
	if requestData.IsDel != 1 {
		isTrue, dutyErr := eiteSpecificDutyInfoCont(requestData.Id, saveData)
		if isTrue != true {
			response.Result(103, dutyErr, "修改失败！", c)
			return
		}
		response.Result(0, requestData, "修改成功！", c)
	} else {
		if requestData.State == 3 {
			archiveInfoErr := global.GVA_DB_Performanceappraisal.Where("de_id = ?", requestData.Id).Delete(&eiteAssEssStateInfo).Error
			if archiveInfoErr != nil {
				response.Result(104, requestData, "删除失败！", c)
				return
			}
			response.Result(0, requestData, "删除成功！", c)
		} else {
			isTrue, saveErr := eiteSpecificDutyInfoCont(requestData.Id, saveData)
			if isTrue != true {
				response.Result(105, saveErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}