package service

import (
	"fmt"
	"sort"
	"strconv"
	"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"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/staff_assess/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/staff_assess/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/staff_assess/query"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/log"
)

// 员工评绩效评估
type StaffAssessServeice struct {
}

func NewStaffAssessServeice() *StaffAssessServeice {
	newService := &StaffAssessServeice{}
	return newService
}

// 获取我参与过的评估任务列表
func (srv StaffAssessServeice) SearchAssessTaskMe(param *query.SearchAssessMeQuery) (map[string]interface{}, 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()
	}()

	staffAssessTaskRepo := dao.NewStaffAssessDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	var limit int = 200
	var offset int = 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	offset = (param.PageNumber - 1) * param.PageSize
	assessTaskList, err := staffAssessTaskRepo.SearchAssessTaskMe(param.UserId, param.CompanyId, limit, offset)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询评估任务"+err.Error())
	}
	cnt, err := staffAssessTaskRepo.CountAssessTaskMe(param.UserId, param.CompanyId)
	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())
	}
	listData := make([]adapter.SearchAssessMeResp, 0, len(assessTaskList))
	var temp adapter.SearchAssessMeResp
	for _, v := range assessTaskList {
		temp = adapter.SearchAssessMeResp{
			AssessTaskId:          v.Id,
			BeginTime:             v.BeginTime.Local().Format("2006-01-02 15:04:05"),
			EndTime:               v.EndTime.Local().Format("2006-01-02 15:04:05"),
			CycleId:               v.CycleId,
			CycleName:             v.CycleName,
			EvaluationProjectId:   v.EvaluationProjectId,
			EvaluationProjectName: v.EvaluationProjectName,
		}
		listData = append(listData, temp)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), listData), nil
}

// 获取项目评估进度描述
func (srv StaffAssessServeice) AssessTaskDesc(param *query.AssessTaskDescQuery) (*adapter.AssessTaskDescResp, 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()
	}()
	// 获取评估任务
	staffAssessTaskRepo := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取个人参与的评估流程
	staffAssessRepo := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	assessTaskData, err := staffAssessTaskRepo.FindOne(map[string]interface{}{
		"id": param.AssessTaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "评估任务不存在，"+err.Error())
	}
	//返回的数据结果
	result := adapter.AssessTaskDescResp{
		AssessTaskId:          assessTaskData.Id,
		EvaluationProjectId:   assessTaskData.EvaluationProjectId,
		EvaluationProjectName: assessTaskData.EvaluationProjectName,
		CycleName:             assessTaskData.CycleName,
		BeginTime:             assessTaskData.BeginTime.Local().Format("2006-01-02 15:04-05"),
		EndTime:               assessTaskData.EndTime.Local().Format("2006-01-02 15:04-05"),
		StepList:              []adapter.AssessTaskStep{},
	}

	for _, v := range assessTaskData.StepList {
		stepItem := adapter.AssessTaskStep{
			SortBy:       v.SortBy,
			LinkNodeName: v.LinkNodeName,
			LinkNodeId:   v.LinkNodeId,
			BeginTime:    v.BeginTime.Local().Format("2006-01-02 15:04:05"),
			EndTime:      v.EndTime.Local().Format("2006-01-02 15:04:05"),
			LinkNodeType: v.LinkNodeType,
			Desc:         fmt.Sprintf("截止日期：%s", v.EndTime.Local().Format("2006-01-02 15:04:05")),
			Status:       "",
		}
		switch v.LinkNodeType {
		case domain.LinkNodeSelfAssessment:
			//个人自评完成情况
			_, assessSelfData, err := staffAssessRepo.Find(map[string]interface{}{
				"staffAssessTaskId": assessTaskData.Id,
				"executorId":        param.UserId,
				"typesList":         []string{string(domain.AssessSelf)},
			})
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
			}
			if len(assessSelfData) > 0 {
				stepItem.Status = string(assessSelfData[0].Status)
			}
			stepItem.Desc = fmt.Sprintf("截止日期：%s", stepItem.EndTime)
		case domain.LinkNodeAllInvite:
			//邀请别人评估自己
			_, assessInviteData, err := staffAssessRepo.Find(map[string]interface{}{
				"staffAssessTaskId": assessTaskData.Id,
				"targetUserId":      param.UserId,
				"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
				"limit":             5,
			})
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
			}
			if len(assessInviteData) > 0 {
				stepItem.Status = string(domain.StaffAssessCompleted)
			} else {
				stepItem.Status = string(domain.StaffAssessUncompleted)
			}
			//待邀请人数，为5人减去已邀请的人数。若邀请人数已等于或大于5人，则只显示截止日期即可
			if len(assessInviteData) > 5 {
				stepItem.Desc = fmt.Sprintf("截止日期：%s", stepItem.EndTime)
			} else {
				stepItem.Desc = fmt.Sprintf("截止日期：%s  待邀请%d人", stepItem.EndTime, 5-len(assessInviteData))
			}
		case domain.LinkNodeAllAssessment:
			//我评估别人，被邀请评估
			_, assessInviteList, err := staffAssessRepo.Find(map[string]interface{}{
				"staffAssessTaskId": assessTaskData.Id,
				"executorId":        param.UserId,
				"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
			})
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
			}

			if len(assessInviteList) > 0 {
				stepItem.Status = string(domain.StaffAssessCompleted)
				stepItem.Desc = fmt.Sprintf("截止日期：%s", stepItem.EndTime)
				for _, v := range assessInviteList {
					if v.Status == domain.StaffAssessUncompleted {
						stepItem.Status = string(domain.StaffAssessUncompleted)
						break
					}
				}
			}
		case domain.LinkNodeSuperiorAssessment:
			//我评估别人，上级评估
			_, assessSupperList, err := staffAssessRepo.Find(map[string]interface{}{
				"staffAssessTaskId": assessTaskData.Id,
				"executorId":        param.UserId,
				"typesList":         []string{string(domain.AssessSuper)},
			})
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
			}
			if len(assessSupperList) > 0 {
				stepItem.Status = string(domain.StaffAssessCompleted)
				stepItem.Desc = fmt.Sprintf("截止日期：%s", stepItem.EndTime)
				uncompletedNum := 0
				for _, v := range assessSupperList {
					if v.Status == domain.StaffAssessUncompleted {
						uncompletedNum += 1
					}
				}
				if uncompletedNum > 0 {
					stepItem.Status = string(domain.StaffAssessUncompleted)
					stepItem.Desc = fmt.Sprintf("截止日期：%s 待评估%d人", stepItem.EndTime, uncompletedNum)
				}
			}
		}
		result.StepList = append(result.StepList, stepItem)
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return &result, nil
}

// 获取个人的自评反馈历史记录列表
func (srv StaffAssessServeice) AssessSelfList(param *query.AssessSelfListQuery) (map[string]interface{}, 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()
	}()
	//获取个人参与的评估流程
	staffAssessRepo := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	var limit int = 100
	var offset int = 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	offset = (param.PageNumber - 1) * param.PageSize
	condition := map[string]interface{}{
		"executorId": param.UserId,
		"companyId":  param.CompanyId,
		"typesList":  []string{string(domain.AssessSelf)},
		"limit":      limit,
		"endTime":    time.Now(), //获取历史记录
	}
	if offset > 0 {
		condition["offset"] = offset
	}
	//获取历史列表
	cnt, assessList, err := staffAssessRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取评估任务列表，"+err.Error())
	}

	//获取公司数据
	companyRep := factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	companyData, err := companyRep.FindOne(map[string]interface{}{
		"id": param.CompanyId,
	})
	if err != nil {
		log.Logger.Error("获取公司信息，" + err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取公司信息，"+err.Error())
	}

	//获取用户数据
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userData, err := userRepo.FindOne(map[string]interface{}{
		"id": param.UserId,
	})
	if err != nil {
		log.Logger.Error("获取用户信息，" + err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取用户信息，"+err.Error())
	}

	supperUserList, _ := srv.getStaffSuper(transactionContext, *userData)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	listData := make([]adapter.AssessSelfList, 0, len(assessList))
	var itemTemp adapter.AssessSelfList
	for _, v := range assessList {
		itemTemp = adapter.AssessSelfList{
			AssessId:              v.Id,
			BeginTime:             v.BeginTime.Local().Format("2006-01-02 15:04:05"),
			EndTime:               v.EndTime.Local().Format("2006-01-02 15:04:05"),
			CycleId:               v.CycleId,
			CycleName:             v.CycleName,
			EvaluationProjectId:   v.EvaluationProjectId,
			EvaluationProjectName: v.EvaluationProjectName,
		}
		listData = append(listData, itemTemp)
	}
	userInfo := adapter.StaffInfo{
		UserName:       userData.Name,
		CompanyName:    companyData.Name,
		SupperUserName: "",
		DutyTime:       userData.EntryTime,
	}
	for _, v := range supperUserList {
		userInfo.SupperUserName = userInfo.SupperUserName + v.Name + " "
	}
	result := tool_funs.SimpleWrapGridMap(int64(cnt), listData)
	result["userInfo"] = userInfo
	return result, nil
}

// 根据项目评估的配置，创建员工的评估任务
func (srv StaffAssessServeice) CreateStaffAssessTask(transactionContext application.TransactionContext, param *command.CreateStaffAssessTask) (map[string]interface{}, error) {
	log.Logger.Debug("CreateStaffAssessTask 获取参数", map[string]interface{}{
		"param": param,
	})
	assessTaskRepo := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskBeginTime, err := time.ParseInLocation("2006-01-02 15:04:05", param.BeginTime, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "任务开始时间填写错误，"+param.BeginTime)
	}
	taskEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", param.EndTime, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "任务结束时间填写错误，"+param.EndTime)
	}
	nowTime := time.Now()

	assessTaskData := &domain.StaffAssessTask{
		Id:                    0,
		CompanyId:             param.CompanyId,
		EvaluationProjectId:   param.EvaluationProjectId,
		EvaluationProjectName: param.EvaluationProjectName,
		CycleId:               param.CycleId,
		CycleName:             param.CycleName,
		BeginTime:             taskBeginTime,
		EndTime:               taskEndTime,
		StepList:              []domain.AssessTaskStep{},
		ExecutorId:            []int{},
		CreatedAt:             nowTime,
		UpdatedAt:             nowTime,
		DeletedAt:             nil,
		BeginDay:              taskBeginTime.Local().Format("2006-01-02"),
	}
	executorIds := []int{}              //提取评估的参与人id
	executorIdMap := map[int]struct{}{} //过滤重复的用户
	//从入参中提取参与人
	for _, v := range param.ExecutorId {
		if _, ok := executorIdMap[v]; ok {
			continue
		}
		executorIdMap[v] = struct{}{}
		executorIds = append(executorIds, v)
	}
	assessTaskData.ExecutorId = executorIds
	for _, v := range param.StepList {
		stepBeginTime, err := time.ParseInLocation("2006-01-02 15:04:05", param.BeginTime, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "评估环节开始时间填写错误，"+param.BeginTime)
		}
		stepEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", param.EndTime, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "评估环节结束时间填写错误，"+param.EndTime)
		}
		step := domain.AssessTaskStep{
			SortBy:       v.SortBy,
			LinkNodeId:   v.LinkNodeId,
			LinkNodeName: v.LinkNodeName,
			LinkNodeType: v.LinkNodeType,
			BeginTime:    stepBeginTime,
			EndTime:      stepEndTime,
		}
		assessTaskData.StepList = append(assessTaskData.StepList, step)
	}
	//添加员工的节点任务
	assessList, err := srv.createStaffAssess(transactionContext, assessTaskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "生成个人评估项"+err.Error())
	}

	//合并项目评估的新旧数据
	_, assassessTaskList, err := assessTaskRepo.Find(map[string]interface{}{
		"evaluationProjectId": param.EvaluationProjectId,
		"beginDay":            taskBeginTime.Local().Format("2006-01-02"),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询同日期同项目已存在的评估任务"+err.Error())
	}

	if len(assassessTaskList) > 0 {
		//就数据中提取参与人
		for _, v := range assessTaskData.ExecutorId {
			if _, ok := executorIdMap[v]; ok {
				continue
			}
			executorIdMap[v] = struct{}{}
			executorIds = append(executorIds, v)
		}
		assassessTaskList[0].UpdatedAt = time.Now()
		assassessTaskList[0].ExecutorId = executorIds
		//更新步骤
		assassessTaskList[0].StepList = append(assassessTaskList[0].StepList, assessTaskData.StepList...)
		assessTaskData = assassessTaskList[0]
		//排序流程环节
		stepList := domain.SortTaskStep(assessTaskData.StepList)
		sort.Sort(stepList)
	}
	_, err = assessTaskRepo.Save(assessTaskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存评估任务"+err.Error())
	}

	//保存 员工的评估任务
	assessRepo := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for i := range assessList {
		assessList[i].StaffAssessTaskId = assessTaskData.Id
		_, err = assessRepo.Save(&assessList[i])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存个人评估项"+err.Error())
		}
	}

	//处理生成的项目评估

	return map[string]interface{}{
		"assessTaskId": assessTaskData.Id,
	}, nil
}

// 添加节点任务
func (srv StaffAssessServeice) createStaffAssess(transactionContext application.TransactionContext, param *domain.StaffAssessTask) ([]domain.StaffAssess, error) {
	selfUserId := []int{}           //评估的参与人
	userIdMap := map[int]struct{}{} //过滤重复的用户
	for _, v := range param.ExecutorId {
		if _, ok := userIdMap[v]; ok {
			continue
		}
		selfUserId = append(selfUserId, v)
	}
	// 获取用户的信息
	if len(selfUserId) == 0 {
		log.Logger.Error("createStaffAssess", map[string]interface{}{
			"param": param,
		})
		return nil, application.ThrowError(application.ARG_ERROR, "未填写评估任务的执行人")
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工信息
	_, userList, err := userRepo.Find(map[string]interface{}{
		"ids":    selfUserId,
		"status": 1,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取员工信息"+err.Error())
	}
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取用户的部门
	userDepartmentMap := map[int64][]*domain.Department{}
	for _, v := range userList {
		if len(v.DepartmentId) == 0 {
			continue
		}
		_, departmemtList, err := departmentRepo.Find(map[string]interface{}{
			"ids": v.DepartmentId,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取员工的部门信息"+err.Error())
		}
		userDepartmentMap[v.Id] = departmemtList
	}
	assessList := []domain.StaffAssess{}
	//数据样板
	stepSelfTemp := domain.StaffAssess{
		Id:                    0,
		CompanyId:             param.CompanyId,
		EvaluationProjectId:   param.EvaluationProjectId,
		EvaluationProjectName: param.EvaluationProjectName,
		CycleId:               param.CycleId,
		CycleName:             param.CycleName,
		StaffAssessTaskId:     param.Id,
		// TargetUser:            domain.StaffDesc{},
		// TargetDepartment:      nil,
		// Executor:              domain.StaffDesc{},
		Types: "",
		// LinkNodeId: v.LinkNodeId,
		Status: domain.StaffAssessUncompleted,
		// BeginTime:  time.Time{},
		// EndTime:    time.Time{},
		CreatedAt: param.CreatedAt,
		UpdatedAt: param.UpdatedAt,
		DeletedAt: nil,
	}
	for _, v := range param.StepList {
		if v.LinkNodeType == domain.LinkNodeSelfAssessment {
			//员工自评
			stepSelfTemp.BeginTime = v.BeginTime
			stepSelfTemp.EndTime = v.EndTime
			stepSelfTemp.LinkNodeId = v.LinkNodeId
			stepSelfTemp.LinkNodeName = v.LinkNodeName
			stepSelfTemp.Types = domain.AssessSelf
			assessListTemp := srv.createStaffAssessSelf(stepSelfTemp, userList, userDepartmentMap)
			assessList = append(assessList, assessListTemp...)
		}
		if v.LinkNodeType == domain.LinkNodeSuperiorAssessment {
			// 创建上级评估
			stepSelfTemp.BeginTime = v.BeginTime
			stepSelfTemp.EndTime = v.EndTime
			stepSelfTemp.LinkNodeId = v.LinkNodeId
			stepSelfTemp.LinkNodeName = v.LinkNodeName
			stepSelfTemp.Types = domain.AssessSuper
			assessListTemp2, err := srv.createStaffAssessSupper(transactionContext, stepSelfTemp, userList, userDepartmentMap)
			if err != nil {
				return nil, err
			}
			assessList = append(assessList, assessListTemp2...)
		}
	}
	return assessList, nil
}

// 构建员工自评
func (srv StaffAssessServeice) createStaffAssessSelf(assessTemp domain.StaffAssess,
	userList []*domain.User, userDepartmentMap map[int64][]*domain.Department) []domain.StaffAssess {
	result := []domain.StaffAssess{}
	for _, usr := range userList {
		assessTemp.TargetUser = domain.StaffDesc{
			UserId:   int(usr.Id),
			Account:  usr.Account,
			UserName: usr.Name,
		}
		assessTemp.Executor = domain.StaffDesc{
			UserId:   int(usr.Id),
			Account:  usr.Account,
			UserName: usr.Name,
		}
		if depList, ok := userDepartmentMap[usr.Id]; ok {
			for _, dep := range depList {
				assessTemp.TargetDepartment = append(assessTemp.TargetDepartment, domain.StaffDepartment{
					DepartmentId:   int(dep.Id),
					DepartmentName: dep.Name,
				})
			}
		}
		result = append(result, assessTemp)
	}
	return result
}

// 构建员工的上级评估
func (srv StaffAssessServeice) createStaffAssessSupper(
	transactionContext application.TransactionContext,
	assessTemp domain.StaffAssess,
	userList []*domain.User, userDepartmentMap map[int64][]*domain.Department,
) ([]domain.StaffAssess, error) {
	var assessList []domain.StaffAssess
	for _, v := range userList {
		//获取上级
		chargeUserList, err := srv.getStaffSuper(transactionContext, *v)
		if err != nil {
			return nil, err
		}
		if len(chargeUserList) == 0 {
			continue
		}
		for _, v2 := range chargeUserList {
			assessTemp.TargetUser = domain.StaffDesc{
				UserId:   int(v.Id),
				Account:  v.Account,
				UserName: v.Name,
			}
			assessTemp.Executor = domain.StaffDesc{
				UserId:   int(v2.Id),
				Account:  v2.Account,
				UserName: v2.Name,
			}
			targetDepartment := []domain.StaffDepartment{}
			if departmentList, ok := userDepartmentMap[v.Id]; ok {
				for _, department := range departmentList {
					targetDepartment = append(targetDepartment, domain.StaffDepartment{
						DepartmentId:   int(department.Id),
						DepartmentName: department.Name,
					})
				}
			}
			assessTemp.TargetDepartment = targetDepartment
			assessList = append(assessList, assessTemp)
		}

	}
	return assessList, nil
}

// 获取某个员工360评估邀请的人员
func (srv StaffAssessServeice) GetAssessInviteUser(param *query.GetAssessInviteUserQuery) (*adapter.AssessInviteUserResp, 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()
	}()

	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	assessTaskReps := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	assessTaskData, err := assessTaskReps.FindOne(map[string]interface{}{
		"id": param.AssessTaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取评估任务"+err.Error())
	}
	_, assessList, err := assessReps.Find(map[string]interface{}{
		"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
		"staffAssessTaskId": param.AssessTaskId,
		"targetUserId":      param.UserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取个人评估任务"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	result := adapter.AssessInviteUserResp{
		AssessTaskId:    assessTaskData.Id,
		InviteDiffSuper: []domain.StaffDesc{},
		InviteSameSuper: []domain.StaffDesc{},
	}
	for _, v := range assessTaskData.StepList {
		if v.LinkNodeType != domain.LinkNodeAllInvite {
			continue
		}
		result.LinkNodeId = v.LinkNodeId
		result.LinkNodeName = v.LinkNodeName
		result.BeginTime = v.BeginTime.Local().Format("2006-01-02 15:04:05")
		result.EndTime = v.EndTime.Local().Format("2006-01-02 15:04:05")
		break
	}
	for _, v := range assessList {
		if v.Types == domain.AssessInviteDiffSuper {
			result.InviteDiffSuper = append(result.InviteDiffSuper, v.Executor)
		}
		if v.Types == domain.AssessInviteSameSuper {
			result.InviteSameSuper = append(result.InviteDiffSuper, v.Executor)
		}
	}
	return &result, nil
}

// 保存某个员工360邀请的人员
func (srv StaffAssessServeice) SaveAssessInviteUser(param *command.SaveAssessInvite) (map[string]interface{}, error) {
	inviteSameSuperId := []int{}
	userIdMap := map[int]struct{}{} //过滤重复的id
	InviteDiffSuperId := []int{}
	for _, v := range param.InviteDiffSuper {
		id, err := strconv.Atoi(v)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "用户填写错误")
		}
		if _, ok := userIdMap[id]; ok {
			continue
		}
		userIdMap[id] = struct{}{}
		InviteDiffSuperId = append(InviteDiffSuperId, id)
	}
	for _, v := range param.InviteSameSuper {
		id, err := strconv.Atoi(v)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "用户填写错误")
		}
		if _, ok := userIdMap[id]; ok {
			continue
		}
		userIdMap[id] = struct{}{}
		inviteSameSuperId = append(inviteSameSuperId, id)
	}
	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()
	}()
	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	assessTaskReps := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	assessTaskData, err := assessTaskReps.FindOne(map[string]interface{}{
		"id": param.AssessTaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取评估任务"+err.Error())
	}

	//获取邀请评估的节点
	var inviteNode *domain.AssessTaskStep
	for _, v := range assessTaskData.StepList {
		if v.LinkNodeType == domain.LinkNodeAllAssessment {
			cp := v
			inviteNode = &cp
			break
		}
	}
	if inviteNode == nil {
		return nil, application.ThrowError(application.ARG_ERROR, "评估任务没有邀请评估的环节")
	}
	//检查节点的结束时间
	endTimeInt := inviteNode.EndTime.Unix()
	if endTimeInt < time.Now().Unix() {
		e := fmt.Sprintf("该环节已在%s截止", inviteNode.EndTime.Local().Format("2006-01-02 15:04:05"))
		return nil, application.ThrowError(application.BUSINESS_ERROR, e)
	}

	targetUser, err := userRepo.FindOne(map[string]interface{}{
		"id": param.TargetUserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取被评估员工"+err.Error())
	}
	//被评估人的部门
	var targetUserDepartment []domain.StaffDepartment
	if len(targetUser.DepartmentId) > 0 {
		_, departmentList, err := departmentRepo.Find(map[string]interface{}{
			"ids": targetUser.DepartmentId,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取部门信息"+err.Error())
		}
		for _, v := range departmentList {
			targetUserDepartment = append(targetUserDepartment, domain.StaffDepartment{
				DepartmentId:   int(v.Id),
				DepartmentName: v.Name,
			})
		}
	}
	//邀请的相同上级的员工
	var inviteSameSuper []domain.StaffDesc
	if len(inviteSameSuperId) > 0 {
		_, userList, err := userRepo.Find(map[string]interface{}{
			"ids":    inviteSameSuperId,
			"status": 1,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取用户信息"+err.Error())
		}
		for _, v := range userList {
			inviteSameSuper = append(inviteSameSuper, domain.StaffDesc{
				UserId:   int(v.Id),
				UserName: v.Name,
				Account:  v.Account,
			})
		}
	}
	//邀请的不同上级的员工
	var inviteDiffSuper []domain.StaffDesc
	if len(InviteDiffSuperId) > 0 {
		_, userList, err := userRepo.Find(map[string]interface{}{
			"ids":    InviteDiffSuperId,
			"status": 1,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取用户信息"+err.Error())
		}
		for _, v := range userList {
			inviteDiffSuper = append(inviteDiffSuper, domain.StaffDesc{
				UserId:   int(v.Id),
				UserName: v.Name,
				Account:  v.Account,
			})
		}
	}
	//获取员工邀请的人
	_, assessList, err := assessReps.Find(map[string]interface{}{
		"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
		"staffAssessTaskId": param.AssessTaskId,
		"targetUserId":      param.TargetUserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取员工邀请的人"+err.Error())
	}
	//比对新旧数据
	nowTime := time.Now()
	assessMap := map[string]*domain.StaffAssess{}
	for _, v := range assessList {
		//假设为删除
		v.DeletedAt = &nowTime
		key := fmt.Sprintf("%s%d", string(v.Types), v.Executor.UserId)
		assessMap[key] = v
	}
	newAssessList := []*domain.StaffAssess{}
	//邀请同上级的员工
	for _, v := range inviteSameSuper {
		key := fmt.Sprintf("%s%d", string(domain.AssessInviteSameSuper), v.UserId)
		if _, ok := assessMap[key]; ok {
			assessMap[key].DeletedAt = nil
		} else {
			newAssessList = append(newAssessList, &domain.StaffAssess{
				Id:                    0,
				CompanyId:             assessTaskData.CompanyId,
				EvaluationProjectId:   assessTaskData.EvaluationProjectId,
				EvaluationProjectName: assessTaskData.EvaluationProjectName,
				CycleId:               assessTaskData.CycleId,
				CycleName:             assessTaskData.CycleName,
				StaffAssessTaskId:     assessTaskData.Id,
				TargetUser: domain.StaffDesc{
					UserId:   int(targetUser.Id),
					Account:  targetUser.Account,
					UserName: targetUser.Name,
				},
				TargetDepartment: targetUserDepartment,
				Executor:         v,
				Types:            domain.AssessInviteSameSuper,
				LinkNodeId:       inviteNode.LinkNodeId,
				LinkNodeName:     inviteNode.LinkNodeName,
				Status:           domain.StaffAssessUncompleted,
				BeginTime:        inviteNode.BeginTime,
				EndTime:          inviteNode.EndTime,
				CreatedAt:        nowTime,
				UpdatedAt:        nowTime,
				DeletedAt:        nil,
			})
		}
	}
	for _, v := range inviteDiffSuper {
		key := fmt.Sprintf("%s%d", string(domain.AssessInviteDiffSuper), v.UserId)
		if _, ok := assessMap[key]; ok {
			assessMap[key].DeletedAt = nil
		} else {
			newAssessList = append(newAssessList, &domain.StaffAssess{
				Id:                    0,
				CompanyId:             assessTaskData.CompanyId,
				EvaluationProjectId:   assessTaskData.EvaluationProjectId,
				EvaluationProjectName: assessTaskData.EvaluationProjectName,
				CycleId:               assessTaskData.CycleId,
				CycleName:             assessTaskData.CycleName,
				StaffAssessTaskId:     assessTaskData.Id,
				TargetUser: domain.StaffDesc{
					UserId:   int(targetUser.Id),
					Account:  targetUser.Account,
					UserName: targetUser.Name,
				},
				TargetDepartment: targetUserDepartment,
				Executor:         v,
				Types:            domain.AssessInviteDiffSuper,
				LinkNodeId:       inviteNode.LinkNodeId,
				LinkNodeName:     inviteNode.LinkNodeName,
				Status:           domain.StaffAssessUncompleted,
				BeginTime:        inviteNode.BeginTime,
				EndTime:          inviteNode.EndTime,
				CreatedAt:        nowTime,
				UpdatedAt:        nowTime,
				DeletedAt:        nil,
			})
		}
	}
	assessList = append(assessList, newAssessList...)
	for i := range assessList {
		_, err = assessReps.Save(assessList[i])
		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())
	}
	result := map[string]interface{}{
		"assessTaskId": assessTaskData.Id,
	}
	return result, nil
}

// 获取员工自评的评估内容详情
func (srv StaffAssessServeice) GetAssessSelfInfo(param *query.AssessSelfInfoQuery) (*adapter.AssessInfoResp, 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()
	}()
	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工的评估
	_, assessList, err := assessReps.Find(map[string]interface{}{
		"companyId":         param.CompanyId,
		"staffAssessTaskId": param.AssessTaskId,
		"targetUserId":      param.TargetUserId,
		"typesList":         []string{string(domain.AssessSelf)},
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的评估"+err.Error())
	}
	if len(assessList) == 0 {
		return &adapter.AssessInfoResp{}, nil
	}
	assessData := assessList[0]

	assessContentList := []*domain.StaffAssessContent{}
	if assessData.Status == domain.StaffAssessCompleted {
		//已完成
		assessContentRepo := factory.CreateStaffAssessContentRepository(map[string]interface{}{
			"transactionContext": transactionContext,
		})
		_, assessContentList, err = assessContentRepo.Find(map[string]interface{}{
			"staffAssessId": assessData.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	} else if assessData.Status == domain.StaffAssessUncompleted {
		//未完成
		assessContentList, err = srv.getAssessSelfInfoUncompleted(transactionContext, assessData)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	}

	//获取员工描述
	staffDesc, _ := srv.getStaffDescrip(transactionContext, int64(param.TargetUserId))
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	result := adapter.AssessInfoResp{
		AssessId:              assessData.Id,
		CycleId:               assessData.CycleId,
		CycleName:             assessData.CycleName,
		LinkNodeId:            assessData.LinkNodeId,
		LinkNodeName:          assessData.LinkNodeName,
		EvaluationProjectId:   assessData.EvaluationProjectId,
		EvaluationProjectName: assessData.EvaluationProjectName,
		BeginTime:             assessData.BeginTime.Local().Format("2006-01-02 15:04:05"),
		EndTime:               assessData.EndTime.Local().Format("2006-01-02 15:04:05"),
		Status:                string(assessData.Status),
		TargetUserId:          assessData.TargetUser.UserId,
		TargetUserName:        assessData.TargetUser.UserName,
		CompanyId:             assessData.CompanyId,
		CompanyName:           "",
		SupperUser:            "",
		DutyTime:              "",
		AssessContent:         assessContentList,
	}
	if staffDesc != nil {
		result.CompanyName = staffDesc.CompanyName
		result.SupperUser = staffDesc.SupperUserName
		result.DutyTime = staffDesc.DutyTime
	}
	return &result, nil
}

// 获取未完成的员工评估内容
func (srv StaffAssessServeice) getAssessSelfInfoUncompleted(transactionContext application.TransactionContext,
	assess *domain.StaffAssess) ([]*domain.StaffAssessContent, error) {
	projectRepo := factory.CreateEvaluationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	projectData, err := projectRepo.FindOne(map[string]interface{}{
		"id": assess.EvaluationProjectId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
	}
	if projectData.Template == nil {
		return nil, nil
	}
	var linkNode *domain.LinkNode
	for _, v := range projectData.Template.LinkNodes {
		if v.Id == int64(assess.LinkNodeId) {
			linkNode = v
			break
		}
	}
	if linkNode == nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "未获得评估环节配置"+err.Error())
	}

	var nodeContentList []*domain.NodeContent
	if len(linkNode.NodeContents) > 0 {
		nodeContentList = linkNode.NodeContents
	} else {
		//如果当前节点没有评估内容，就去 使用自评节点的评估内容
		for _, v := range projectData.Template.LinkNodes {
			if v.Type == domain.LinkNodeSelfAssessment {
				nodeContentList = v.NodeContents
			}
		}
	}
	ruleRepo := factory.CreateEvaluationRuleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	ruleMap := map[int64]*domain.EvaluationRule{}
	for _, v := range nodeContentList {
		if _, ok := ruleMap[v.RuleId]; ok {
			continue
		}
		ruleData, err := ruleRepo.FindOne(map[string]interface{}{
			"id": v.RuleId,
		})
		if err == nil {
			ruleMap[v.RuleId] = ruleData
		}
	}

	var contentList []*domain.StaffAssessContent
	nowTime := time.Now()
	for i, v := range nodeContentList {
		item := &domain.StaffAssessContent{
			Id:            0,
			StaffAssessId: assess.Id,
			SortBy:        i + 1,
			Category:      v.Category,
			Name:          v.Name,
			PromptTitle:   v.PromptTitle,
			PromptText:    v.PromptText,
			Remark:        nil,
			Value:         "",
			ReteResult:    "",
			CreatedAt:     nowTime,
			Weight:        v.Weight,
			Required:      v.Required,
			UpdatedAt:     nowTime,
			DeletedAt:     nil,
			// Rule: ,
		}
		if ruleVal, ok := ruleMap[v.RuleId]; ok {
			item.Rule = *ruleVal
		}
		var remarks []domain.AssessContemtRemark
		for _, vv := range v.EntryItems {
			ritem := domain.AssessContemtRemark{
				Title:      vv.Title,
				HintText:   vv.HintText,
				Definition: vv.Definition,
				RemarkText: "",
			}
			remarks = append(remarks, ritem)
		}
		item.Remark = remarks
		contentList = append(contentList, item)
	}
	return contentList, nil
}

// 选择员工评估可邀请的用户
func (srv StaffAssessServeice) SelectAssessInviteUser(param *query.SelectAssessInviteUser) (map[string]interface{}, 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,
	})
	targetUser, err := userRepo.FindOne(map[string]interface{}{
		"id": param.TargetUserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工信息"+err.Error())
	}
	//获取被评估的目标用户的部门
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	var targetUserDepartment []*domain.Department
	if len(targetUser.DepartmentId) > 0 {
		_, targetUserDepartment, err = departmentRepo.Find(map[string]interface{}{
			"ids": targetUser.DepartmentId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取部门信息"+err.Error())
		}
	}
	//获取部门主管的id
	targetUserCharge := map[int64]struct{}{}
	for _, v := range targetUserDepartment {
		for _, vv := range v.ChargeUserIds {
			targetUserCharge[vv] = struct{}{}
		}
	}
	//
	targetUserDepartmentMap := map[int64]struct{}{}
	for _, v := range targetUserDepartment {
		targetUserDepartmentMap[v.Id] = struct{}{}
	}
	//查询员工数据
	condition := map[string]interface{}{
		"companyId": param.CompanyId,
		"name":      param.InviteUserName,
		"limit":     20,
		"status":    1,
	}
	if param.PageSize > 0 {
		condition["limit"] = param.PageSize
	}
	offset := (param.PageNumber - 1) * param.PageSize
	if offset > 0 {
		condition["offset"] = offset
	}
	cnt, userList, err := userRepo.Find(condition)
	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())
	}
	listData := []adapter.SelectInviteUser{}
	for _, v := range userList {
		item := adapter.SelectInviteUser{
			UserId:   int(v.Id),
			UserName: v.Name,
			IsSupper: false,
			Types:    2, //默认是不同上级
		}
		if _, ok := targetUserCharge[v.Id]; ok {
			item.IsSupper = true
		}
		for _, vv := range v.DepartmentId {
			if _, ok := targetUserDepartmentMap[int64(vv)]; ok {
				item.Types = 1 //设为相同上级
				break
			}
		}
		listData = append(listData, item)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), listData), nil
}

// 获取我要执行的的360评估，用户列表和评估填写的值
func (srv StaffAssessServeice) ListExecutorInviteAssess(param *query.ListInviteUserAssessQuery) (
	*adapter.ListInviteUserAssessResp, 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()
	}()
	//获取对应的评估任务
	assessRepo := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	assessTaskRepo := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	//获取 executorId 对应的360评估任务 用户
	condition := map[string]interface{}{
		"staffAssessTaskId": param.AssessTaskId,
		"executorId":        param.ExecutorId,
		"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
		"limit":             20,
	}
	if param.PageSize > 0 {
		condition["limit"] = param.PageSize
	}
	offset := (param.PageNumber - 1) * param.PageSize
	if offset > 0 {
		condition["offset"] = offset
	}

	cnt, assessList, err := assessRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	var assessContentList []*domain.StaffAssessContent
	if len(assessList) > 0 {
		//获取评估用的所有评估项
		assessContentList, err = srv.getAssessSelfInfoUncompleted(transactionContext, assessList[0])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取评估任务"+err.Error())
		}
	}
	//可变的表格列
	changeableHeader := []adapter.ListTableHeader{}
	//列名与字段对应
	keyMap := map[string]string{}
	for i, v := range assessContentList {
		name := fmt.Sprintf("%s-%s", v.Category, v.Name)
		key := fmt.Sprintf("k%d", i)
		keyMap[name] = key
		changeableHeader = append(changeableHeader, adapter.ListTableHeader{
			Key:  key,
			Name: name,
		})
	}
	assessContentRepo := factory.CreateStaffAssessContentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	// 获取已经填报的内容
	changeableRows := map[int]map[string]string{}
	for _, v := range assessList {
		_, contentList, err := assessContentRepo.Find(map[string]interface{}{
			"staffAssessId": v.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取评估内容"+err.Error())
		}
		row := map[string]string{}
		for _, vv := range contentList {
			name := fmt.Sprintf("%s-%s", vv.Category, vv.Name)
			if kk, ok := keyMap[name]; ok {
				row[kk] = vv.Value
			}
		}
		changeableRows[v.TargetUser.UserId] = row
	}

	//获取360邀请评估完成情况
	//我评估别人，被邀请评估
	cnnt, _, err := assessRepo.Find(map[string]interface{}{
		"staffAssessTaskId": param.AssessTaskId,
		"executorId":        param.ExecutorId,
		"typesList":         []string{string(domain.AssessInviteDiffSuper), string(domain.AssessInviteSameSuper)},
		"status":            domain.StaffAssessUncompleted,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
	}

	assessTaskData, err := assessTaskRepo.FindOne(map[string]interface{}{
		"id": param.AssessTaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取评估任务"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	//评估填写数据行转列
	tableHeader := []adapter.ListTableHeader{
		{Key: "userName", Name: "姓名"},
		{Key: "status", Name: "状态"},
		{Key: "types", Name: "360°评估关系"},
		{Key: "endTime", Name: "360°评估截止日期"},
	}
	tableHeader = append(tableHeader, changeableHeader...)
	listData := []map[string]string{}
	for _, v := range assessList {
		m := map[string]string{
			"userName": v.TargetUser.UserName,
			"userId":   strconv.Itoa(v.TargetUser.UserId),
			"status":   string(v.Status),
			"types":    string(v.Types),
			"endTime":  v.EndTime.Local().Format("2006-01-02 15:04:05"),
			"assessId": strconv.Itoa(v.Id),
		}
		switch v.Status {
		case domain.StaffAssessCompleted:
			m["status"] = "已经完成"
		case domain.StaffAssessUncompleted:
			m["status"] = "未完成"
		}

		switch v.Types {
		case domain.AssessInviteDiffSuper:
			m["types"] = "不同上级同事"
		case domain.AssessInviteSameSuper:
			m["types"] = "相同上级同事"
		}
		if row, ok := changeableRows[v.TargetUser.UserId]; ok {
			for k, v := range row {
				m[k] = v
			}
		} else {
			for _, v := range changeableHeader {
				m[v.Key] = ""
			}
		}
		listData = append(listData, m)
	}
	result := adapter.ListInviteUserAssessResp{
		TableHeader: tableHeader,
		List:        listData,
		Total:       cnt,
	}
	for _, v := range assessTaskData.StepList {
		if v.LinkNodeType == domain.LinkNodeAllAssessment {
			result.LinkNodeId = v.LinkNodeId
			result.LinkNodeName = v.LinkNodeName
			result.LintNodeDesc = fmt.Sprintf("截止时间 %s 待评估%d人", v.EndTime.Local().Format("2006-01-02 15:04:05"), cnnt)
		}
	}
	return &result, nil
}

// 获取我需要执行的上级评估成员列表
func (srv StaffAssessServeice) ListExecutorSupperAssess(param *query.ListSupperAssessQuery) (map[string]interface{}, 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()
	}()
	//获取对应的评估任务
	assessRepo := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	limit := 20
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	condition := map[string]interface{}{
		"staffAssessTaskId": param.AssessTaskId,
		"executorId":        param.ExecutorId,
		"typesList":         []string{string(domain.AssessSuper)},
		"limit":             limit,
		"targetUserName":    param.UserName,
	}
	offset := (param.PageNumber - 1) * param.PageSize
	if offset > 0 {
		condition["offset"] = offset
	}
	//获取 executorId 对应的上级评估列表
	cnt, assessList, err := assessRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	userIds := []int{}
	for _, v := range assessList {
		userIds = append(userIds, v.TargetUser.UserId)
	}
	//获取员工信息
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	var targetUserList []*domain.User
	if len(userIds) > 0 {
		_, targetUserList, _ = userRepo.Find(map[string]interface{}{
			"ids": userIds,
		})
	}
	//获取职位信息
	positionRepo := factory.CreatePositionRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工的职位
	userPositionMap := map[int64][]*domain.Position{}
	for _, v := range targetUserList {
		if len(v.PositionId) == 0 {
			continue
		}
		_, positionList, _ := positionRepo.Find(map[string]interface{}{
			"ids": v.PositionId,
		})
		userPositionMap[v.Id] = positionList
	}

	//获取员工邀请的人完成360评估的数量
	var inviteCompletedCount []dao.CountData
	if len(userIds) > 0 {
		d := dao.NewStaffAssessDao(map[string]interface{}{
			"transactionContext": transactionContext,
		})
		inviteCompletedCount, err = d.CountInviteAssessByTargetUser(userIds, param.AssessTaskId)
		if err != nil {
			log.Logger.Error("获取员工邀请的人完成情况" + err.Error())
		}
	}
	assessTaskRepo := factory.CreateStaffAssessTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	assessTaskData, err := assessTaskRepo.FindOne(map[string]interface{}{
		"id": param.AssessTaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取评估任务"+err.Error())
	}
	//我评估别人，被邀请评估
	cnnt, _, err := assessRepo.Find(map[string]interface{}{
		"staffAssessTaskId": param.AssessTaskId,
		"executorId":        param.ExecutorId,
		"typesList":         []string{string(domain.AssessSuper)},
		"status":            string(domain.StaffAssessUncompleted),
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取个人的评估环节"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	resultList := []adapter.ListSupperAssessResp{}
	for _, v := range assessList {
		item := adapter.ListSupperAssessResp{
			AssessId:        v.Id,
			UserId:          v.TargetUser.UserId,
			UserName:        v.TargetUser.UserName,
			EndTime:         v.EndTime.Local().Format("2006-01-02 15:04:05"),
			InviteCompleted: 0,
			Status:          string(v.Status),
			InviteTotal:     5,
			Department:      "",
			Position:        "",
			DutyTime:        "",
		}
		//填入部门
		for _, vv := range v.TargetDepartment {
			item.Department += vv.DepartmentName + " "
		}
		for _, vv := range targetUserList {
			if vv.Id != int64(v.TargetUser.UserId) {
				continue
			}
			//填入入职时间
			item.DutyTime = vv.CreatedAt.Local().Format("2006-01-02 15:04:05")
			//填入职位
			for _, vvv := range userPositionMap[vv.Id] {
				item.Position += vvv.Name + " "
			}
			break
		}
		//
		for _, vv := range inviteCompletedCount {
			if v.TargetUser.UserId == vv.TargetUserId {
				item.InviteCompleted = vv.InviteCompleted
				item.InviteTotal = vv.InviteTotal
				break
			}
		}
		resultList = append(resultList, item)
	}
	result := tool_funs.SimpleWrapGridMap(int64(cnt), resultList)
	result["linkNodeName"] = ""
	result["linkNodeId"] = ""
	result["lintNodeDesc"] = ""
	for _, v := range assessTaskData.StepList {
		if v.LinkNodeType == domain.LinkNodeSuperiorAssessment {
			result["linkNodeName"] = v.LinkNodeName
			result["linkNodeId"] = fmt.Sprintf("%d", v.LinkNodeId)
			result["lintNodeDesc"] = fmt.Sprintf("截止时间 %s 待评估 %d 人", v.EndTime.Local().Format("2006-01-02 15:04:05"), cnnt)
		}
	}
	return result, nil
}

// 根据staffAssessId 获取评估的填写信息
func (srv StaffAssessServeice) GetAssessInfo(param *query.AssessInfoQuery) (*adapter.AssessInfoResp, 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()
	}()
	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工的评估
	_, assessList, err := assessReps.Find(map[string]interface{}{
		"companyId": param.CompanyId,
		"id":        param.AssessId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的评估"+err.Error())
	}
	if len(assessList) == 0 {
		return &adapter.AssessInfoResp{}, nil
	}
	assessData := assessList[0]
	assessContentList := []*domain.StaffAssessContent{}
	if assessData.Status == domain.StaffAssessCompleted {
		//已完成
		assessContentRepo := factory.CreateStaffAssessContentRepository(map[string]interface{}{
			"transactionContext": transactionContext,
		})
		_, assessContentList, err = assessContentRepo.Find(map[string]interface{}{
			"staffAssessId": assessData.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	} else if assessData.Status == domain.StaffAssessUncompleted {
		//未完成
		assessContentList, err = srv.getAssessSelfInfoUncompleted(transactionContext, assessData)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	}

	targetUserDesc, err := srv.getStaffDescrip(transactionContext, int64(assessData.TargetUser.UserId))
	if err != nil {
		log.Logger.Error("获取员工描述" + err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	result := adapter.AssessInfoResp{
		AssessId:              assessData.Id,
		CycleId:               assessData.CycleId,
		CycleName:             assessData.CycleName,
		LinkNodeId:            assessData.LinkNodeId,
		LinkNodeName:          assessData.LinkNodeName,
		EvaluationProjectId:   assessData.EvaluationProjectId,
		EvaluationProjectName: assessData.EvaluationProjectName,
		BeginTime:             assessData.BeginTime.Local().Format("2006-01-02 15:04:05"),
		EndTime:               assessData.EndTime.Local().Format("2006-01-02 15:04:05"),
		Status:                string(assessData.Status),
		TargetUserId:          assessData.TargetUser.UserId,
		TargetUserName:        assessData.TargetUser.UserName,
		CompanyId:             assessData.CompanyId,
		CompanyName:           "",
		SupperUser:            "",
		DutyTime:              "",
		AssessContent:         assessContentList,
	}
	if len(assessContentList) == 0 {
		result.AssessContent = []*domain.StaffAssessContent{}
	}
	if targetUserDesc != nil {
		result.CompanyName = targetUserDesc.CompanyName
		result.SupperUser = targetUserDesc.SupperUserName
		result.DutyTime = targetUserDesc.DutyTime
	}
	return &result, nil
}

// 获取员工信息描述
func (srv *StaffAssessServeice) getStaffDescrip(transactionContext application.TransactionContext, userid int64) (*adapter.StaffInfo, error) {
	//获取用户数据
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userData, err := userRepo.FindOne(map[string]interface{}{
		"id": userid,
	})
	if err != nil {
		log.Logger.Error("获取用户信息，" + err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取用户信息，"+err.Error())
	}

	//获取公司数据
	companyRep := factory.CreateCompanyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	companyData, err := companyRep.FindOne(map[string]interface{}{
		"id": userData.CompanyId,
	})
	if err != nil {
		log.Logger.Error("获取公司信息，" + err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取公司信息，"+err.Error())
	}
	// departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
	// 	"transactionContext": transactionContext,
	// })
	// //查找员工的部门
	// var departmentList []*domain.Department
	// if len(userData.DepartmentId) > 0 {

	// }

	// var supperUserList []*domain.User
	// if len(userData.DepartmentId) > 0 {
	// 	_, departmentList, err := departmentRepo.Find(map[string]interface{}{
	// 		"ids": userData.DepartmentId,
	// 	})
	// 	if err != nil {
	// 		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取部门信息，"+err.Error())
	// 	}
	// 	var chargeUserIds []int64
	// 	for _, v := range departmentList {
	// 		chargeUserIds = append(chargeUserIds, v.ChargeUserIds...)
	// 	}
	// 	if len(chargeUserIds) > 0 {
	// 		_, supperUserList, err = userRepo.Find(map[string]interface{}{
	// 			"ids": chargeUserIds,
	// 		})
	// 		if err != nil {
	// 			return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取员工上级信息，"+err.Error())
	// 		}
	// 	}
	// }
	supperUserList, _ := srv.getStaffSuper(transactionContext, *userData)
	userInfo := adapter.StaffInfo{
		UserName:       userData.Name,
		CompanyName:    companyData.Name,
		SupperUserName: "",
		DutyTime:       userData.EntryTime,
	}
	for _, v := range supperUserList {
		userInfo.SupperUserName = userInfo.SupperUserName + v.Name + " "
	}
	return &userInfo, nil
}

// 提交评估数据
func (srv StaffAssessServeice) SaveAssessInfo(param *command.SaveAssessInfoCommand) (map[string]interface{}, 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()
	}()
	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工的评估
	assessData, err := assessReps.FindOne(map[string]interface{}{
		"id": param.AssessId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的评估"+err.Error())
	}

	//检查截止时间
	endTimeInt := assessData.EndTime.Unix()
	if endTimeInt < time.Now().Unix() {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "当前环节已过截止时间，提交后无法修改内容")
	}
	//检查执行人
	if assessData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "当前用户不是评估的执行人")
	}
	if assessData.Executor.UserId != param.ExecutorId {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "当前用户不是评估的执行人")
	}
	assessContentRepo := factory.CreateStaffAssessContentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//待更新的评估填写信息
	assessContentList := []*domain.StaffAssessContent{}
	if assessData.Status == domain.StaffAssessCompleted {
		//已完成
		_, assessContentList, err = assessContentRepo.Find(map[string]interface{}{
			"staffAssessId": assessData.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	} else if assessData.Status == domain.StaffAssessUncompleted {
		//未完成
		assessContentList, err = srv.getAssessSelfInfoUncompleted(transactionContext, assessData)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取项目填写内容"+err.Error())
		}
	}
	//处理提交上来的数据
	paramContentMap := map[string]command.AssesssContent{}
	for i, v := range param.AssessContent {
		key := fmt.Sprintf("%s-%s", v.Category, v.Name)
		paramContentMap[key] = param.AssessContent[i]
	}
	//更新的评估填写信息
	for _, v := range assessContentList {
		key := fmt.Sprintf("%s-%s", v.Category, v.Name)
		item, ok := paramContentMap[key]
		if !ok {
			continue
		}
		v.Value = item.Value
		if v.Required == 1 {
			//转换填入的评估值
			err = v.TransformValue()
			if err != nil {
				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
			}
		}
		for ii := range v.Remark {
			for _, vvv := range item.Remark {
				if v.Remark[ii].Title == vvv.Title {
					v.Remark[ii].RemarkText = vvv.RemarkText
					break
				}
			}
		}
	}
	//保存信息
	for i := range assessContentList {
		_, err = assessContentRepo.Save(assessContentList[i])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存评估填写内容"+err.Error())
		}
	}
	assessData.Status = domain.StaffAssessCompleted
	assessData.UpdatedAt = time.Now()
	_, err = assessReps.Save(assessData)
	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())
	}
	return map[string]interface{}{
		"assessId": assessData.Id,
	}, nil
}

// 获取员工被评估的列表
func (srv StaffAssessServeice) ListTargetUserAssess(param *query.ListTargetUserAssessQuery) (map[string]interface{}, 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()
	}()
	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取员工的评估
	cnt, assessList, err := assessReps.Find(map[string]interface{}{
		"assessTaskId": param.AssessTaskId,
		"companyId":    param.CompanyId,
		"targetUserId": param.TargetUserId,
		"typesList":    param.Types,
	})
	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())
	}

	return tool_funs.SimpleWrapGridMap(int64(cnt), assessList), nil
}

//获取员工的上级是谁 ，TODO
func (srv StaffAssessServeice) getStaffSuper(transactionContext application.TransactionContext, targetUser domain.User) ([]*domain.User, error) {
	departmentRepo := factory.CreateDepartmentRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	var departmemtList []*domain.Department
	var err error
	if len(targetUser.DepartmentId) > 0 {
		_, departmemtList, err = departmentRepo.Find(map[string]interface{}{
			"ids": targetUser.DepartmentId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的部门列表"+err.Error())
		}
	}
	if len(departmemtList) == 0 {
		//找不到员工的部门
		companyRepo := factory.CreateCompanyRepository(map[string]interface{}{
			"transactionContext": transactionContext,
		})
		companyData, err := companyRepo.FindOne(map[string]interface{}{
			"id": targetUser.CompanyId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的公司"+err.Error())
		}
		//公司作为最顶级
		departmemtList = append(departmemtList, &domain.Department{
			Id:            0,
			CompanyId:     companyData.Id,
			Level:         0,
			Name:          companyData.Name,
			ParentId:      0,
			ChargeUserIds: companyData.ChargeUserIds,
			Path:          "",
			CreatedAt:     time.Time{},
			UpdatedAt:     time.Time{},
			DeletedAt:     &time.Time{},
		})

	}
	//获取部门管理员
	var chargeUserIds []int64
	var targetUserAsManager *domain.Department
loop:
	for _, v := range departmemtList {
		if len(v.ChargeUserIds) == 0 {
			continue
		}
		//检查员工自身是否是管理员
		for _, vv := range v.ChargeUserIds {
			if vv == targetUser.Id {
				targetUserAsManager = v
				break loop
			}
		}
		chargeUserIds = append(chargeUserIds, v.ChargeUserIds...)
	}
	if targetUserAsManager != nil {
		//清空原有的管理员
		chargeUserIds = []int64{}
		//员工自身是否是管理员，查找父级部门
		_, parentDepartment, err := departmentRepo.Find(map[string]interface{}{
			"id": targetUserAsManager.ParentId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工现在部门的父级"+err.Error())
		}
		for _, v := range parentDepartment {
			chargeUserIds = append(chargeUserIds, v.ChargeUserIds...)
		}
	}

	var chargeUserList []*domain.User
	if len(chargeUserIds) > 0 {
		_, chargeUserList, err = userRepo.Find(map[string]interface{}{
			"ids":    chargeUserIds,
			"status": 1, //正常的用户
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取主管员工数据"+err.Error())
		}
	}
	return chargeUserList, nil
}