package positionkpi

import (
	"strconv"
	"strings"
	"time"

	"gin_server_admin/commonus"
	"gin_server_admin/global"
	"gin_server_admin/model/assessmentmodel"
	"gin_server_admin/model/common/response"
	"gin_server_admin/model/hrsystem"

	"github.com/gin-gonic/gin"
)

// 岗位指标操作
// 入口
func (a *ApiMethod) Index(c *gin.Context) {
	outPut := commonus.MapOut()
	response.Result(0, outPut, "角色管理入口获取成功", c)
}

// 添加岗位指标
func (a *ApiMethod) AddPostTarget(c *gin.Context) {
	var requestData addPostTarget
	c.ShouldBindJSON(&requestData)
	if requestData.Title == "" {
		response.Result(100, requestData, "请输入指标名称！", c)
		return
	}
	if requestData.Type == 0 {
		requestData.Type = 2
	}
	if requestData.ScoringMethod == 0 {
		requestData.ScoringMethod = 1
	}
	if requestData.RelevantDepartments == "" {
		response.Result(101, requestData, "请选择该指标归属部门！", c)
		return
	}
	if len(requestData.DepartmentsPost) < 1 {
		response.Result(102, requestData, "请选择该指标归属岗位！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(103, requestData, "请选择指标归属维度！", c)
		return
	}
	if requestData.Unit == "" {
		response.Result(104, requestData, "请输入该指标计算单位！", c)
		return
	}
	if requestData.Cycle == 0 {
		requestData.Cycle = 1
	}
	if requestData.CycleAttr == 0 {
		requestData.CycleAttr = 1
	}

	var saveData assessmentmodel.PostTarget
	saveData.Title = requestData.Title //标题"`
	saveData.Type = requestData.Type   //1：定性考核；2：定量考核"`
	saveData.State = 1                 //状态（1：启用；2：禁用；3：删除）"`
	saveData.Time = time.Now().Unix()  //创建时间"`
	saveData.Share = 2                 //1：共用；2：私用"`
	departmentId, _ := strconv.ParseInt(requestData.RelevantDepartments, 10, 64)
	saveData.ReleDepart = departmentId                                        //相关部门"`
	saveData.DepartmentsPost = strings.Join(requestData.DepartmentsPost, ",") //相关岗位"`
	dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
	saveData.Dimension = dimensionId                                    //维度"`
	saveData.Key = commonus.GetFileNumberEs()                           //UUID"`
	saveData.Report = strings.Join(requestData.Report, ",")             //上报人"`
	saveData.Unit = requestData.Unit                                    //单位"`
	saveData.Cycle = requestData.Cycle                                  //1：班；2：天；3：周；4：月；5：季度；6：年"`
	saveData.Cycleattr = requestData.CycleAttr                          //辅助计数"`
	saveData.ScoringMethod = requestData.ScoringMethod                  //计分方式（1：自动；2：手动）"`
	saveData.VisibleRange = strings.Join(requestData.VisibleRange, ",") //可见范围"`
	saveData.VisibleGroup = strings.Join(requestData.VisibleGroup, ",") //可见范围(集团)"`
	err := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
	if err != nil {
		response.Result(105, err.Error(), "数据写入失败！", c)
		return
	}
	response.Result(0, saveData, "数据写入成功！", c)
}

// 编辑岗位指标
func (a *ApiMethod) EditPostTarget(c *gin.Context) {
	var requestData editPostTargetCont
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		response.Result(100, requestData, "请输入指标名称！", c)
		return
	}
	where := commonus.MapOut()
	where["`id`"] = requestData.Id
	var postTargetCont assessmentmodel.PostTarget
	err := postTargetCont.GetCont(where)
	if err != nil {
		response.Result(100, requestData, "该指标不存在！", c)
		return
	}
	saveData := commonus.MapOut()
	if requestData.Title != "" && requestData.Title != postTargetCont.Title {
		saveData["title"] = requestData.Title
	}
	if requestData.Type != 0 && requestData.Type != postTargetCont.Type {
		saveData["type"] = requestData.Type
	}
	if requestData.ScoringMethod != 0 && requestData.ScoringMethod != postTargetCont.ScoringMethod {
		saveData["scoring_method"] = requestData.ScoringMethod
	}
	if requestData.RelevantDepartments != "" {
		departmentId, _ := strconv.ParseInt(requestData.RelevantDepartments, 10, 64)
		if departmentId != postTargetCont.ReleDepart {
			saveData["rele_depart"] = departmentId
		}

	}
	if len(requestData.DepartmentsPost) > 0 {
		departPostStr := strings.Join(requestData.DepartmentsPost, ",")
		if departPostStr != postTargetCont.DepartmentsPost {
			saveData["departments_post"] = departPostStr
		}
	}
	if requestData.Dimension != "" {
		dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
		if dimensionId != postTargetCont.Dimension {
			saveData["dimension"] = dimensionId
		}
	}
	if len(requestData.Report) > 0 {
		reportStr := strings.Join(requestData.Report, ",")
		if reportStr != postTargetCont.Report {
			saveData["report"] = reportStr
		}
	}
	if requestData.Unit != "" && requestData.Unit != postTargetCont.Unit {
		saveData["unit"] = requestData.Unit
	}
	if requestData.Cycle != 0 && requestData.Cycle != postTargetCont.Cycle {
		saveData["cycle"] = requestData.Cycle
	}
	if requestData.CycleAttr != 0 && requestData.CycleAttr != postTargetCont.Cycleattr {
		saveData["cycleattr"] = requestData.CycleAttr
	}

	if len(requestData.VisibleRange) > 0 {
		visibleRangeStr := strings.Join(requestData.VisibleRange, ",")
		if visibleRangeStr != postTargetCont.VisibleRange {
			saveData["visible_range"] = visibleRangeStr
		}
	}
	if len(requestData.VisibleGroup) > 0 {
		visibleGroupStr := strings.Join(requestData.VisibleGroup, ",")
		if visibleGroupStr != postTargetCont.VisibleGroup {
			saveData["visible_group"] = visibleGroupStr
		}
	}
	if len(saveData) > 0 {
		saveData["time"] = time.Now().Unix()
		saveErr := postTargetCont.EditCont(where, saveData)
		if saveErr != nil {
			response.Result(101, saveErr, "数据编辑失败！", c)
		} else {
			response.Result(0, saveData, "数据编辑成功！", c)
		}
	} else {
		response.Result(0, saveData, "数据编辑成功！", c)
	}
}

// 编辑岗位指标状态
func (a *ApiMethod) EditState(c *gin.Context) {
	var requestData editState
	c.ShouldBindJSON(&requestData)
	if requestData.Id == "" {
		response.Result(100, requestData, "请输入指标名称！", c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsTrue == 0 {
		requestData.IsTrue = 2
	}
	where := commonus.MapOut()
	where["`id`"] = requestData.Id
	var postTargetCont assessmentmodel.PostTarget
	err := postTargetCont.GetCont(where)
	if err != nil {
		response.Result(100, requestData, "该指标不存在！", c)
		return
	}
	saveData := commonus.MapOut()
	saveData["`state`"] = requestData.State
	if requestData.State != 3 {
		saveErr := postTargetCont.EditCont(where, saveData)
		if saveErr != nil {
			response.Result(101, saveErr, "数据编辑失败！", c)
			return
		}
	} else {
		if requestData.IsTrue == 1 {
			err := postTargetCont.DelCont(where)
			if err != nil {
				response.Result(101, err, "数据编辑失败！", c)
				return
			}
		} else {
			saveErr := postTargetCont.EditCont(where, saveData)
			if saveErr != nil {
				response.Result(101, saveErr, "数据编辑失败！", c)
				return
			}
		}
	}
	if postTargetCont.Type == 1 {
		if requestData.State != 3 {
			eidtDingXing(postTargetCont.Id, requestData.State)
		} else {
			if requestData.IsTrue == 1 {
				var postSunTargetInfo assessmentmodel.PostSunTarget
				postSunTargetInfo.DelCont(map[string]interface{}{"`parent_id`": postTargetCont.Id})
				var postDetailsInfo assessmentmodel.PostTargetDetails
				postDetailsInfo.DelCont(map[string]interface{}{"`parent_id`": postTargetCont.Id})
			} else {
				eidtDingXing(postTargetCont.Id, requestData.State)
			}
		}
	}
	response.Result(0, saveData, "数据编辑成功！", c)
}

// 编辑定性考核关联项目
/*

 */
func eidtDingXing(postTarKey int64, delVal int) {
	var postSunTargetInfo assessmentmodel.PostSunTarget
	postSunTargetInfo.EditCont(map[string]interface{}{"`parent_id`": postTarKey}, map[string]interface{}{"`state`": delVal, "`time`": time.Now().Unix()})
	var postDetailsInfo assessmentmodel.PostTargetDetails
	postDetailsInfo.EditCont(map[string]interface{}{"`parentid`": postTarKey}, map[string]interface{}{"`state`": delVal, "`time`": time.Now().Unix()})
}

// 岗位指标列表
func (a *ApiMethod) PostTargetList(c *gin.Context) {
	var requestData postTargetList
	c.ShouldBindJSON(&requestData)
	if requestData.Page == 0 {
		requestData.Page = 1
	}
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	var postTargetListAry []outPostTargetList
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PostTarget{}).Where("`state` BETWEEN 1 AND 2")

	if requestData.Title != "" {
		gormDb = gormDb.Where("`title` LIKE ?", "%"+requestData.Title+"%")
	}
	if requestData.Type != 0 {
		gormDb = gormDb.Where("`type` = ?", requestData.Type)
	}
	if requestData.ScoringMethod != 0 {
		gormDb = gormDb.Where("`scoring_method` = ?", requestData.ScoringMethod)
	}
	if requestData.RelevantDepartments != "" {
		gormDb = gormDb.Where("`rele_depart` = ?", requestData.RelevantDepartments)
	}
	if requestData.DepartmentsPost != "" {
		gormDb = gormDb.Where("FIND_IN_SET(?,`departments_post`)", requestData.DepartmentsPost)
	}
	if requestData.Dimension != "" {
		gormDb = gormDb.Where("`dimension` = ?", requestData.Dimension)
	}
	if requestData.Report != "" {
		gormDb = gormDb.Where("FIND_IN_SET(?,`report`)", requestData.Report)
	}
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}

	err := gormDb.Order("`id` desc").Limit(requestData.PageSize).Offset(commonus.CalculatePages(requestData.Page, requestData.PageSize)).Find(&postTargetListAry).Error
	if err != nil {
		response.Result(103, err.Error(), "没有数据！", c)
	}
	for i, v := range postTargetListAry {
		//关联维度
		var dimCont assessmentmodel.DutyClass
		dimCont.GetCont(map[string]interface{}{"`id`": v.Dimension}, "`title`")
		postTargetListAry[i].DimensionName = dimCont.Title
		//关联部门
		var orgCont hrsystem.AdministrativeOrganization
		orgCont.GetCont(map[string]interface{}{"`id`": v.ReleDepart}, "`name`")
		postTargetListAry[i].DepartmentName = orgCont.Name
		//岗位
		if v.DepartmentsPost != "" {
			postAry := strings.Split(v.DepartmentsPost, ",")
			if len(postAry) > 0 {
				var postContLost []hrsystem.AdministrativeOrganization
				postErr := global.GVA_DB_HrDataBase.Model(&hrsystem.AdministrativeOrganization{}).Select("`id`,`name`").Where("`id` IN ?", postAry).Find(&postContLost).Error
				if postErr == nil {
					for _, pv := range postContLost {
						var postInfo idAndName
						postInfo.Id = strconv.FormatInt(pv.Id, 10)
						postInfo.Name = pv.Name
						postTargetListAry[i].PostAry = append(postTargetListAry[i].PostAry, postInfo)
					}
				}
			}

		}

		//提报人
		if v.Report != "" {
			reportAry := strings.Split(v.Report, ",")
			if len(reportAry) > 0 {
				var peopleList []hrsystem.PersonArchives
				peopleErr := global.GVA_DB_HrDataBase.Model(&hrsystem.PersonArchives{}).Select("`key`,`number`,`name`,`icon`").Where("`key` IN ?", reportAry).Find(&peopleList).Error
				if peopleErr == nil {
					for _, manv := range peopleList {
						var namCont reportUser
						namCont.Id = strconv.FormatInt(manv.Id, 10)
						namCont.Name = manv.Name
						namCont.Number = manv.Number
						namCont.Icon = manv.Icon
						postTargetListAry[i].ReportAry = append(postTargetListAry[i].ReportAry, namCont)
					}
				}
			}
		}
	}
	countSum := len(postTargetListAry)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, postTargetListAry)
	response.Result(0, printData, "查询成功！", c)
}