package assessment

import (
	"strconv"
	"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/gin-gonic/gin"
)

//具体职责
func (d *DutyHandle) DutyList(c *gin.Context) {
	var requestData dutyRequest
	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.DutyContent{})
	if requestData.ParentId != "" {
		parenId, parenIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
		if parenIdErr == nil {
			gormDb = gormDb.Where("`dc_parent` = ?", parenId)
		}
	}
	if requestData.Title != "" {
		gormDb = gormDb.Where("dc_title LIKE ?", "%"+requestData.Title+"%")
	}

	if requestData.State != 0 {
		gormDb = gormDb.Where("`dc_state` = ?", requestData.State)
	} else {
		gormDb = gormDb.Where("`dc_state` IN ?", []int{1, 2})
	}

	if requestData.AssEssType != 0 {
		gormDb = gormDb.Where("`dc_type` = ?", requestData.AssEssType)

	}

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

	var dutyList []assessmentmodel.DutyContent
	dutyListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&dutyList).Error
	if dutyListerr != nil {
		response.Result(103, dutyListerr, "数据获取失败！", c)
		return
	}
	var outDutyMap []dutyOutput
	for _, val := range dutyList {
		var outDutyInfo dutyOutput
		outDutyInfo.Id = val.Id
		outDutyInfo.Title = val.Title
		outDutyInfo.Time = val.Time
		outDutyInfo.State = val.State
		outDutyInfo.PartId = val.PartId
		outDutyInfo.UserType = val.UserType
		outDutyInfo.UserDump = val.UserDump
		outDutyInfo.Dump = val.Dump
		outDutyInfo.OutId = strconv.FormatInt(outDutyInfo.Id, 10)

		outDutyInfo.UnitTitle = val.Uniteing
		outDutyInfo.Cycle = val.Cycles
		outDutyInfo.CycleAttr = val.CycleAttres
		outDutyInfo.Content = val.Contentes
		outDutyInfo.Type = val.Types

		outDutyInfo.ParentIdStr = strconv.FormatInt(val.PartId, 10)
		isTrue, parentCont := GetAssEssCont(val.PartId)
		if isTrue == true {
			outDutyInfo.ParentTitle = parentCont.Title
		}
		outDutyInfo.DumpTitle = ""
		if val.UserDump != 0 {
			usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name", "worker_man.wm_bf_id", "worker_man.wm_ws_id", "worker_man.wm_pt_id", "worker_man.wm_group"}, map[string]interface{}{"wm_key": val.UserDump})
			if usErr == true {
				outDutyInfo.UserName = usCont.Name

				isTrueBranFact, branFactCont := GetBranchFactory(usCont.DepartmentId)
				if isTrueBranFact == true {
					outDutyInfo.DumpTitle = branFactCont.Name
				}

			}
		}

		if val.Dump != 0 {
			isTruew, bfCont := GetBranchFactory(val.Dump)
			if isTruew == true {
				outDutyInfo.DumpTitle = bfCont.Name
			}
		}

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

//添加考核细则
func (d *DutyHandle) AddDutyInfo(c *gin.Context) {
	var requestData addDutyContent
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Title == "" {
		response.Result(102, err, "请输入考核细则名称", c)
		return
	}
	if requestData.ParentId == "" {
		response.Result(103, err, "请指定该具体归属于考核项目", c)
		return
	}
	outDutyCont := commonus.MapOut()
	inFoErres := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_parent` = ? AND `dc_title` = ?", requestData.ParentId, requestData.Title).First(&outDutyCont).Error
	if inFoErres == nil {
		response.Result(105, inFoErres, "该考核项目下此考核细则已经存在！请不要重复提交", c)
		return
	}
	// if requestData.SectionId == "" {
	// 	response.Result(103, err, "请指定该考核细则执行部门", c)
	// 	return
	// }
	if requestData.Type == 0 {
		requestData.Type = 1
	}

	var dutyInfo assessmentmodel.DutyContent
	dutyInfo.Id = commonus.GetFileNumberEs()
	dutyInfo.Title = requestData.Title
	dutyInfo.Time = time.Now().Unix()
	dutyInfo.State = 1
	dutyInfo.UserType = 1
	parentId, parentIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
	if parentIdErr == nil {
		dutyInfo.PartId = parentId
	} else {
		dutyInfo.PartId = 0
	}
	// userID, userIDErr := strconv.ParseInt(requestData.UserId, 10, 64)
	// if userIDErr != nil {
	// 	userID = 0
	// }
	dutyInfo.Types = requestData.Type
	// dutyInfo.UserDump = userID
	// DumpID, DumpIDErr := strconv.ParseInt(requestData.SectionId, 10, 64)
	// if DumpIDErr != nil {
	// 	DumpID = 0
	// }
	// dutyInfo.Dump = DumpID
	assContErr, assCont := GetAssEssCont(parentId)
	if assContErr != true {
		response.Result(103, err, "该考核项目不存在！请你检查！", c)
		return
	}
	dutyInfo.Uniteing = assCont.Unites
	dutyInfo.Cycles = assCont.Cycle
	dutyInfo.CycleAttres = assCont.CycleAttr
	dutyInfo.Contentes = requestData.Content

	// if requestData.Type == 1 {
	// 	dutyInfo.UserDump = userID
	// 	dutyInfo.Dump = 0
	// } else {
	// 	dutyInfo.UserDump = 0
	// 	dutyInfo.Dump = userID
	// }
	dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&dutyInfo).Error
	if dutyInfoErr != nil {
		response.Result(104, dutyInfo, "数据写入失败！", c)
	} else {
		response.Result(0, dutyInfo, "数据写入成功！", c)
	}
}

//获取具体职责
func (d *DutyHandle) GetDutyInfo(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 dutyOutput
	inFoErr := global.GVA_DB_Performanceappraisal.Where("`dc_id` = ?", requestData.Id).First(&dutyOutInfo).Error
	if inFoErr != nil {
		response.Result(103, inFoErr, "数据查询失败！", c)
		return
	}

	dutyOutInfo.OutId = strconv.FormatInt(dutyOutInfo.Id, 10)
	dutyOutInfo.ParentIdStr = strconv.FormatInt(dutyOutInfo.PartId, 10)
	isTrue, parentCont := GetAssEssCont(dutyOutInfo.PartId)
	if isTrue == true {
		dutyOutInfo.ParentTitle = parentCont.Title
	}

	if dutyOutInfo.Dump != 0 {
		isTruew, bfCont := GetBranchFactory(dutyOutInfo.Dump)
		if isTruew == true {
			dutyOutInfo.DumpTitle = bfCont.Name
		}
	}

	if dutyOutInfo.UserDump != 0 {
		dutyOutInfo.UserDumpId = strconv.FormatInt(dutyOutInfo.UserDump, 10)
		usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name", "worker_man.wm_bf_id", "worker_man.wm_ws_id", "worker_man.wm_pt_id", "worker_man.wm_group"}, map[string]interface{}{"wm_key": dutyOutInfo.UserDump})
		if usErr == true {
			dutyOutInfo.UserName = usCont.Name

			isTrueBranFact, branFactCont := GetBranchFactory(usCont.DepartmentId)
			if isTrueBranFact == true {
				dutyOutInfo.DumpTitle = branFactCont.Name
			}

		}
	}

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

//编辑具体职责
func (d *DutyHandle) EiteDutyInfor(c *gin.Context) {
	var requestData eiteDutyCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	saveData := commonus.MapOut()
	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.Title == "" {
		response.Result(103, err, "请输入具体职责", c)
		return
	}

	var dutyOutInfo dutyOutput
	inFoErr := global.GVA_DB_Performanceappraisal.Where("`dc_id` = ?", requestData.Id).First(&dutyOutInfo).Error
	if inFoErr != nil {
		response.Result(103, inFoErr, "数据查询失败！", c)
		return
	}
	if requestData.Title != "" && requestData.Title != dutyOutInfo.Title {
		outDutyCont := commonus.MapOut()
		inFoErres := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_parent` = ? AND `dc_title` = ?", requestData.ParentId, requestData.Title).First(&outDutyCont).Error
		if inFoErres == nil {
			response.Result(105, inFoErr, "该考核细则已经存在！请不要重复提交", c)
			return
		}
	}

	if requestData.ParentId != "" {
		parentIdInt, parentErr := strconv.ParseInt(requestData.ParentId, 10, 64)
		if parentErr == nil {
			saveData["dc_parent"] = parentIdInt
		}
	}
	if requestData.Type != 0 {
		saveData["dc_type"] = requestData.Type
	}
	if requestData.UserId != "" {
		userID, userIDErr := strconv.ParseInt(requestData.UserId, 10, 64)
		if userIDErr != nil {
			userID = 0
		}
		saveData["dc_user_dump"] = userID
	}

	if requestData.SectionId != "" {
		sectionID, sectionIDErr := strconv.ParseInt(requestData.SectionId, 10, 64)
		if sectionIDErr != nil {
			sectionID = 0
		}
		saveData["dc_dump"] = sectionID
	}

	var assessInfo assessmentmodel.DutyContent
	saveData["dc_title"] = requestData.Title
	saveData["dc_time"] = time.Now().Unix()
	isTrue, isErr := eiteDutyInfoCont(requestData.Id, assessInfo, saveData)
	if isTrue != true {
		response.Result(104, isErr, "修改失败！", c)
		return
	}
	response.Result(0, saveData, "修改成功！", c)
}

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

//修改考核项目的状态
func (d *DutyHandle) EiteDutyState(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["dc_state"] = requestData.State
	saveData["dc_time"] = time.Now().Unix()
	var eiteAssEssStateInfo assessmentmodel.DutyContent
	if requestData.IsDel != 1 {
		isTrue, dutyErr := eiteDutyInfoCont(requestData.Id, eiteAssEssStateInfo, 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("ai_id = ?", requestData.Id).Delete(&eiteAssEssStateInfo).Error
			if archiveInfoErr != nil {
				response.Result(104, requestData, "删除失败！", c)
				return
			}
			response.Result(0, requestData, "删除成功！", c)
		} else {
			isTrue, saveErr := eiteDutyInfoCont(requestData.Id, eiteAssEssStateInfo, saveData)
			if isTrue != true {
				response.Result(105, saveErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}

//获取职责类别内容
func GetDutyInfoCont(id int64) (isTrue bool, ContInfo assessmentmodel.DutyContent) {
	isTrue = false
	err := global.GVA_DB_Performanceappraisal.Where("dc_id = ?", id).First(&ContInfo).Error
	if err == nil {
		isTrue = true
	}
	return
}

//获取职责类别内容
func GetDutyInfoContAll(id int64) (isTrue bool, outAssDutyInfo outAessDuty) {
	isTrue = false
	var ContInfo dutyAssClass
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Select("dc_title", "dc_parent", "ai_title", "ai_parent").Joins("left join assessmentitems on assessmentitems.ai_id = dutycontent.dc_parent").Where("dc_id = ?", id).First(&ContInfo).Error
	if err != nil {
		return
	}
	outAssDutyInfo.AssessId = ContInfo.PartId
	outAssDutyInfo.AssessTitle = ContInfo.AssTitle
	outAssDutyInfo.DutyTitle = ContInfo.Title
	outAssDutyInfo.ClassId = ContInfo.AssPartId
	classErr, classInfo := GetDutyClassCont(ContInfo.AssPartId)
	if classErr == true {
		outAssDutyInfo.ClassTitle = classInfo.Title
	}
	isTrue = true
	return
}