package service

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

	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	service "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

// Evaluation360List 获取360综评列表
func (srv *SummaryEvaluationService) Evaluation360List(param *command.QueryEvaluation360List) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	var searchTargetName string
	if len(param.SearchName) > 0 {
		searchTargetName = "%" + param.SearchName + "%"
	} else {
		searchTargetName = ""
	}
	limit := param.PageSize
	offset := limit * (param.PageNumber - 1)
	if offset < 0 {
		offset = 0
	}
	count, list, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":      param.CompanyId,
		"cycleId":        param.CycleId,
		"executorId":     param.UserId,
		"types":          domain.Evaluation360,
		"targetUserName": searchTargetName,
		"limit":          limit,
		"offset":         offset,
		"beginTime":      time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	ids := make([]int, 0)
	projectIds := make([]int, 0)
	for i := range list {
		ids = append(ids, list[i].Id)
		projectIds = append(projectIds, list[i].EvaluationProjectId)
	}

	// 固定列
	changeableHeader := []adapter.TableHeader{
		{Key: "targetUserName", Name: "姓名"},
		{Key: "statusVal", Name: "状态"},
		{Key: "relation", Name: "360°评估关系"},
		{Key: "endTime", Name: "360°评估截止日期"},
	}
	changeableRowMap := map[int]map[string]interface{}{}    // k,v（用户ID -> 数据集合）行数据内容
	itemMap := map[int][]*domain.EvaluationItemUsed{}       // k,v（项目ID -> 评估数组）归类评估内容
	valueMap := map[string]*domain.SummaryEvaluationValue{} // k,v（周期+评估 -> 提交值）
	uniqueColumnsMap := map[string]string{}                 // 列名称唯一

	if len(ids) > 0 {
		// 评估内容（注.使用自评模板，并过滤出360综评人的评估内容）
		_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{"evaluationProjectIds": projectIds, "nodeType": domain.LinkNodeSelfAssessment, "evaluatorId": param.UserId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		// 填写值
		_, valueList, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationIdList": ids})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		for i := range valueList {
			key := fmt.Sprintf("%d-%d", valueList[i].SummaryEvaluationId, valueList[i].EvaluationItemId)
			valueMap[key] = valueList[i]
		}

		for i := range itemList {
			item := itemList[i]
			key := fmt.Sprintf("k%d", i)
			name := fmt.Sprintf("%s-%s", item.Category, item.Name)
			if _, ok := uniqueColumnsMap[name]; !ok {
				changeableHeader = append(changeableHeader, adapter.TableHeader{Key: key, Name: name})
				uniqueColumnsMap[name] = key
			}

			pList, ok := itemMap[item.EvaluationProjectId]
			if !ok {
				pList = make([]*domain.EvaluationItemUsed, 0)
			}
			itemMap[item.EvaluationProjectId] = append(pList, item)
		}
	}

	now := time.Now().Local() // 当前时间
	var rowMap map[string]interface{}
	for i := range list {
		v := list[i]
		if rm, ok := changeableRowMap[v.TargetUser.UserId]; ok {
			rowMap = rm
		} else {
			rowMap = map[string]interface{}{}
			changeableRowMap[v.TargetUser.UserId] = rowMap
		}

		endTime := v.EndTime.Local()
		statusVal := ""
		if v.Status == domain.EvaluationCompleted {
			statusVal = "已完成"
		} else {
			if now.After(endTime) {
				statusVal = "已逾期"
			} else {
				statusVal = "待完成"
			}
		}
		rowMap["id"] = v.Id
		rowMap["targetUserId"] = strconv.Itoa(v.TargetUser.UserId)
		rowMap["targetUserName"] = v.TargetUser.UserName
		rowMap["statusVal"] = statusVal
		rowMap["relation"] = "项目组员"
		rowMap["endTime"] = endTime.Local().Format("2006-01-02 15:04")

		// 当前项目所有评估内容
		if pList, ok := itemMap[v.EvaluationProjectId]; ok {
			for _, item := range pList {
				name := fmt.Sprintf("%s-%s", item.Category, item.Name)
				if key, ok := uniqueColumnsMap[name]; ok { // 动态列用name -> key
					valueKey := fmt.Sprintf("%d-%d", v.Id, item.Id)
					if it, ok := valueMap[valueKey]; ok {
						if it.Weight > 0 {
							rowMap[key] = it.Score
						} else {
							rowMap[key] = it.Rating.Code
						}
					} else {
						rowMap[key] = ""
					}
				}
			}
		}
	}

	targetList := make([]map[string]interface{}, 0)
	for _, v1 := range list {
		rowMap := changeableRowMap[v1.TargetUser.UserId]
		for _, v2 := range changeableHeader { // 填充部分动态列缺失字段
			if _, ok := rowMap[v2.Key]; !ok {
				rowMap[v2.Key] = ""
			}
		}
		targetList = append(targetList, rowMap)
	}

	// 外层显示截止时间
	endTime := ""
	if len(list) > 0 {
		endTime = list[0].EndTime.Local().Format("2006-01-02 15:04:05")
	}

	result := &adapter.SummaryEvaluationAdapter{
		TableHeader: changeableHeader,
		Total:       count,
		List:        targetList,
	}
	grid := map[string]interface{}{
		"grid":    result,
		"endTime": endTime,
	}
	return grid, nil
}

// GetEvaluation360 获取360综评详情（我评估目标用户）
func (srv *SummaryEvaluationService) GetEvaluation360(param *command.QueryEvaluation360My) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	sEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 360评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": sEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"companyId":           param.CompanyId,
		"evaluatorId":         param.UserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": sEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = sEvaluation.Executor.UserName
	}
	// 评估项截止时间
	endTime := sEvaluation.EndTime.Local().Format("2006-01-02 15:04:05")
	return map[string]interface{}{"endTime": endTime, "list": itemValuesAdapter}, nil
}

// GetEvaluation360Complete 获取360综评详情(他人评估目标用户)（已完成状态）
func (srv *SummaryEvaluationService) GetEvaluation360Complete(param *command.QueryEvaluation360) (*[]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})
	_, evaluations, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":    param.CompanyId,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"types":        domain.Evaluation360,
		"status":       domain.EvaluationCompleted,
		"limit":        99999,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if len(evaluations) == 0 {
		list := make([]adapter.EvaluationItemAdapter, 0)
		return &list, nil
	}

	executorMap := map[int]domain.StaffDesc{} // 执行人
	evaluationIds := make([]int, 0)           // 评估周期ID
	for i := range evaluations {
		executor := evaluations[i].Executor
		executorMap[executor.UserId] = executor

		evaluationIds = append(evaluationIds, evaluations[i].Id)
	}
	// 得到项目ID
	evaluationProjectId := evaluations[0].EvaluationProjectId
	// 360评估内容（自评模板）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationIdList": evaluationIds,
		"types":                   domain.Evaluation360,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	filterItemList := make([]*domain.EvaluationItemUsed, 0) // 筛选有评估人的评估内容
	for i := range itemList {
		if itemList[i].EvaluatorId > 0 {
			filterItemList = append(filterItemList, itemList[i])
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(filterItemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		if executor, ok := executorMap[itemValuesAdapter[i].EvaluatorId]; ok {
			itemValuesAdapter[i].EvaluatorName = executor.UserName
		}
	}

	//result := adapter.EvaluationInfoAdapter{
	//	SummaryEvaluationId:   sEvaluation.Id,
	//	CycleId:               int(sEvaluation.CycleId),
	//	CycleName:             sEvaluation.CycleName,
	//	EvaluationProjectId:   sEvaluation.EvaluationProjectId,
	//	EvaluationProjectName: sEvaluation.EvaluationProjectName,
	//	LinkNodeId:            sEvaluation.NodeId,
	//	BeginTime:             sEvaluation.BeginTime.Format("2006-01-02 15:04:05"),
	//	EndTime:               sEvaluation.EndTime.Format("2006-01-02 15:04:05"),
	//	TargetUserId:          sEvaluation.TargetUser.UserId,
	//	TargetUserName:        sEvaluation.TargetUser.UserName,
	//	Status:                string(sEvaluation.Status),
	//	EvaluationItems:       itemValuesAdapter,
	//}
	return &itemValuesAdapter, nil
}

// EditEvaluation360 编辑提交360综评
func (srv *SummaryEvaluationService) EditEvaluation360(param *command.EditEvaluationValue) (map[string][]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	summaryEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if summaryEvaluation.Executor.UserId != param.ExecutorId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}
	if summaryEvaluation.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := itemUsedRepo.Find(map[string]interface{}{
		"evaluationProjectId": summaryEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         param.ExecutorId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValueList, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": summaryEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	err = srv.editEvaluationValue(summaryEvaluation, &itemValueList, itemList, param.EvaluationItems, nil, param.IsTemporary)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if !param.IsTemporary {
		//变更评估状态为已填写
		summaryEvaluation.Status = domain.EvaluationCompleted
	}

	//保存填写值
	for _, v := range itemValueList {
		err = itemValueRepo.Save(v)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

	//保存填写值
	err = evaluationRepo.Save(summaryEvaluation)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if !param.IsTemporary {
		err = srv.AfterCompletedEvaluation360Hrbp(summaryEvaluation)
		if err != nil {
			return nil, err
		}
	}

	itemValueAdapter := srv.buildSummaryItemValue(itemList, itemValueList)
	return map[string][]adapter.EvaluationItemAdapter{
		"evaluationItems": itemValueAdapter,
	}, nil
}

// EvaluationHRBPList 获取人资综评列表
func (srv *SummaryEvaluationService) EvaluationHRBPList(param *command.QueryEvaluationHRList) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	// 必须是HRBP权限的人才能编辑操作
	hrbp, err := service.GetHRBP(transactionContext, param.CompanyId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if hrbp != 1 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	staffAssessDaoRepo := dao.NewStaffAssessDao(map[string]interface{}{"transactionContext": transactionContext})
	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	positionRepo := factory.CreatePositionRepository(map[string]interface{}{"transactionContext": transactionContext})

	limit := param.PageSize
	offset := limit * (param.PageNumber - 1)
	if offset < 0 {
		offset = 0
	}
	condition := map[string]interface{}{
		"companyId": param.CompanyId,
		"cycleId":   param.CycleId,
		"types":     domain.EvaluationHrbp,
		"limit":     limit,
		"offset":    offset,
		"beginTime": time.Now(),
	}
	if len(param.SearchName) > 0 {
		condition["targetUserName"] = "%" + param.SearchName + "%"
	}
	count, list, err := evaluationRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	userIds := make([]int, 0)
	projectIds := make([]int, 0)
	projectCountMap := map[string]int{}         // 自评逾期数量
	userMap := map[int64]*domain.User{}         // 用户
	positionMap := map[int64]*domain.Position{} // 职位

	for i := range list {
		it := list[i]
		userIds = append(userIds, it.TargetUser.UserId)
		projectIds = append(projectIds, list[i].EvaluationProjectId)
	}
	if len(userIds) > 0 {
		_, users, err := userRepo.Find(map[string]interface{}{"ids": userIds, "companyId": param.CompanyId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		positionIds := make([]int, 0)
		for i := range users {
			userMap[users[i].Id] = users[i]
			positionIds = append(positionIds, users[i].PositionId...)

		}
		if len(positionIds) > 0 {
			_, positions, err := positionRepo.Find(map[string]interface{}{"ids": positionIds, "companyId": param.CompanyId})
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			for i := range positions {
				positionMap[positions[i].Id] = positions[i]
			}
		}
	}

	if len(projectIds) > 0 {
		targetCount, err := staffAssessDaoRepo.CountUncompletedSelfAssess(param.CompanyId, projectIds)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range targetCount {
			key := fmt.Sprintf("%d-%d", targetCount[i].EvaluationProjectId, targetCount[i].TargetUserId)
			projectCountMap[key] = targetCount[i].Cnt
		}
	}

	now := time.Now().Local() // 当前时间
	resultList := make([]*adapter.SummaryEvaluationHRBPAdapter, 0)
	for i := range list {
		v := list[i]
		endTime := v.EndTime.Local()
		// 状态
		statusVal := ""
		if v.Status == domain.EvaluationCompleted {
			statusVal = "已完成"
		} else {
			if now.After(endTime) {
				statusVal = "已逾期"
			} else {
				statusVal = "待完成"
			}
		}

		// 部门拼接
		var departmentBuild strings.Builder
		departmentBuild.WriteString("")
		for i2 := range v.TargetDepartment {
			departmentBuild.WriteString(v.TargetDepartment[i2].DepartmentName)
			if i2 != len(v.TargetDepartment)-1 {
				departmentBuild.WriteString(",")
			}
		}
		// 入职时间
		entryTime := ""
		// 职位拼接
		var positionBuild strings.Builder
		positionBuild.WriteString("")
		if user, ok := userMap[int64(v.TargetUser.UserId)]; ok {
			for i2 := range user.PositionId {
				if position, ok := positionMap[int64(user.PositionId[i2])]; ok {
					positionBuild.WriteString(position.Name)
					if i2 != len(user.PositionId)-1 {
						departmentBuild.WriteString(",")
					}
				}
			}
			entryTime = user.EntryTime
		}

		// 自评逾期数量
		overdueCount := 0
		key := fmt.Sprintf("%d-%d", v.EvaluationProjectId, v.TargetUser.UserId)
		if cnt, ok := projectCountMap[key]; ok {
			overdueCount = cnt
		}

		result := &adapter.SummaryEvaluationHRBPAdapter{
			Id:             v.Id,
			TargetUserId:   v.TargetUser.UserId,
			TargetUserName: v.TargetUser.UserName,
			Department:     departmentBuild.String(),
			Position:       positionBuild.String(),
			DutyTime:       entryTime,
			Status:         statusVal,
			EndTime:        endTime.Local().Format("2006-01-02 15:04"),
			OverdueCount:   overdueCount,
		}
		resultList = append(resultList, result)
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 外层显示截止时间
	endTime := ""
	if len(list) > 0 {
		endTime = list[0].EndTime.Local().Format("2006-01-02 15:04:05")
	}
	grid := tool_funs.SimpleWrapGridMap(int64(count), resultList)
	grid["endTime"] = endTime
	return grid, nil
	//return tool_funs.SimpleWrapGridMap(int64(count), resultList), nil
}

// GetEvaluationHRBP 获取人资综评详情
func (srv *SummaryEvaluationService) GetEvaluationHRBP(param *command.QueryEvaluationHRBPMy) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	sEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": sEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         -1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": sEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = sEvaluation.Executor.UserName
	}

	// 评估项截止时间
	endTime := sEvaluation.EndTime.Local().Format("2006-01-02 15:04:05")
	return map[string]interface{}{"endTime": endTime, "list": itemValuesAdapter}, nil
}

// GetEvaluationHRBPComplete 获取人资综评详情（已完成状态）
func (srv *SummaryEvaluationService) GetEvaluationHRBPComplete(param *command.QueryEvaluationHRBP) (*[]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	_, evaluations, err := evaluationRepo.Find(map[string]interface{}{
		"limit":        99999,
		"companyId":    param.CompanyId,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"status":       domain.EvaluationCompleted,
		"types":        domain.EvaluationHrbp},
	)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if len(evaluations) == 0 {
		list := make([]adapter.EvaluationItemAdapter, 0)
		return &list, nil
	}

	evaluationIds := make([]int, 0) // 评估周期ID
	for i := range evaluations {
		evaluationIds = append(evaluationIds, evaluations[i].Id)
	}
	// 得到项目ID
	evaluationProjectId := evaluations[0].EvaluationProjectId

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         -1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationIdList": evaluationIds,
		"types":                   domain.EvaluationHrbp,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = evaluations[0].Executor.UserName
	}
	return &itemValuesAdapter, nil
}

// EditEvaluationHRBP 编辑提交人资综评
func (srv *SummaryEvaluationService) EditEvaluationHRBP(param *command.EditEvaluationValue) (map[string][]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 必须是HRBP权限的人才能编辑操作
	hrbp, err := service.GetHRBP(transactionContext, param.CompanyId, param.ExecutorId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if hrbp != 1 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	summaryEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if summaryEvaluation.Types != domain.EvaluationHrbp {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}
	if summaryEvaluation.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := itemUsedRepo.Find(map[string]interface{}{
		"evaluationProjectId": summaryEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         -1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValueList, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": summaryEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	err = srv.editEvaluationValue(summaryEvaluation, &itemValueList, itemList, param.EvaluationItems, nil, param.IsTemporary)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if !param.IsTemporary {
		//变更评估状态为已填写
		summaryEvaluation.Status = domain.EvaluationCompleted
	}
	//保存填写值
	for _, v := range itemValueList {
		err = itemValueRepo.Save(v)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

	// 针对HRBP类型，更新最后一次操作的HRBP人
	user, err := userRepo.FindOne(map[string]interface{}{"id": param.ExecutorId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	summaryEvaluation.Executor.UserId = param.ExecutorId
	summaryEvaluation.Executor.Account = user.Account
	summaryEvaluation.Executor.UserName = user.Name
	summaryEvaluation.Executor.CompanyName = "" // 暂时无用
	summaryEvaluation.Status = domain.EvaluationCompleted

	//保存填写值
	err = evaluationRepo.Save(summaryEvaluation)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if !param.IsTemporary {
		err = srv.AfterCompletedEvaluation360Hrbp(summaryEvaluation)
		if err != nil {
			return nil, err
		}
	}
	itemValueAdapter := srv.buildSummaryItemValue(itemList, itemValueList)
	return map[string][]adapter.EvaluationItemAdapter{
		"evaluationItems": itemValueAdapter,
	}, nil
}