package service

import (
	"fmt"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/xredis"
	"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/evaluation_project/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_project/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	taskCommand "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
	taskService "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/service"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
)

type EvaluationProjectService struct {
}

func NewEvaluationProjectService() *EvaluationProjectService {
	newRoleService := &EvaluationProjectService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationProjectService) Create(in *command.CreateProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复
	count, err := projectRepository.Count(map[string]interface{}{"name": in.Name, "cycleId": in.CycleId, "companyId": in.CompanyId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if count > 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "名称已存在")
	}

	newProject := &domain.EvaluationProject{
		Id:        0,
		Name:      in.Name,
		Describe:  in.Describe,
		CompanyId: in.CompanyId,
		CycleId:   in.CycleId,
		CreatorId: in.CreatorId,
		State:     domain.ProjectStateWaitConfig,
		HrBp:      in.HrBp,
		Pmp:       in.Pmp,
		PmpIds:    in.PmpIds,
	}
	project, err := projectRepository.Insert(newProject)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project
	if len(project.PmpIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}

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

}

func (rs *EvaluationProjectService) Update(in *command.UpdateProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复（排除自己）
	count, err := projectRepository.Count(map[string]interface{}{"name": in.Name, "cycleId": in.CycleId, "companyId": in.CompanyId, "notId": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if count > 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "名称已存在")
	}

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	project.Name = in.Name
	project.Describe = in.Describe
	project.HrBp = in.HrBp
	project.Pmp = in.Pmp
	project.PmpIds = in.PmpIds

	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project
	if len(project.PmpIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}

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

func (rs *EvaluationProjectService) UpdateTemplate(in *command.UpdateProjectTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 如果是已经启用的项目，只能编辑环节的截至时间
	if project.State == domain.ProjectStateEnable {
		end, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeEnd, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		maxTime := cycle.TimeEnd.Local()
		if end.After(maxTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
		}
		// 更新项目模板中的环节时间
		if project.Template != nil {
			for i := range project.Template.LinkNodes {
				node := project.Template.LinkNodes[i]
				node.TimeEnd = &end
			}
		}
		// 更新项目截止时间（暂时环节中的时间未分开）
		project.EndTime = end
		project, err = projectRepository.Insert(project)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		// 项目调整截止时间，同步更新任务时间
		if err := rs.updateTaskTime(transactionContext, in.Id, &end); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return project, nil
	} else {
		//_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
		//if err != nil {
		//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		//}
		//// 周期内的所有项目，员工不能重复被评估
		//rids := map[string]bool{}
		//for i := range projects {
		//	it := projects[i]
		//	// 排除当前项目
		//	if in.Id == it.Id {
		//		continue
		//	}
		//	// 启用状态
		//	if it.State == domain.ProjectStateEnable {
		//		for j := range it.Recipients {
		//			rids[it.Recipients[j]] = true
		//		}
		//	}
		//}
		//repeatNum := 0
		//for i := range in.Recipients {
		//	id := in.Recipients[i]
		//	if _, ok := rids[id]; ok {
		//		repeatNum++
		//	}
		//}
		//if repeatNum > 0 {
		//	return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("有%d人已经在本周期其他项目内，需要将他们移除", repeatNum))
		//}

		cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.TemplateId, "includeDeleted": true})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if cycleTemplate == nil || cycleTemplate.Template == nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加模板")
		}

		// 指标任务的项目（存在一项类型为任务指标），必须添加项目负责人
		var isIndicatorTypeTask = false
	outerLoop:
		for i := range cycleTemplate.Template.LinkNodes {
			var node = cycleTemplate.Template.LinkNodes[i]
			for j := range node.NodeContents {
				if node.NodeContents[j].IndicatorType == domain.IndicatorTypeTask {
					isIndicatorTypeTask = true
					break outerLoop
				}
			}
		}
		if isIndicatorTypeTask && len(in.PrincipalId) == 0 {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "请选择任务负责人")
		}

		start, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeStart, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		end, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeEnd, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		minTime := cycle.TimeStart.Local()
		maxTime := cycle.TimeEnd.Local()

		if start.Before(minTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估起始时间不能超出周期起始时间")
		}

		if end.After(maxTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
		}

		// 判断起始时间，是否有被评估人的任务
		assessTaskRepository := factory.CreateStaffAssessTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, assessTasks, err := assessTaskRepository.Find(map[string]interface{}{
			"companyId": in.CompanyId,
			"cycleId":   in.CycleId,
			"beginDay":  start.Format("2006-01-02"),
		})

		rids := map[int]int{}
		for i1 := range assessTasks {
			it := assessTasks[i1]
			for i2 := range it.ExecutorId {
				rids[it.ExecutorId[i2]] = 0
			}
		}
		for i := range in.Recipients {
			id := in.Recipients[i]
			id2, _ := strconv.Atoi(id)
			if _, ok := rids[id2]; ok {
				year, month, day := start.Date()
				start0 := time.Date(year, month, day, 0, 0, 0, 0, time.Local) // 当前时间0点0分0秒时刻
				today := start0.Add(24 * time.Hour).Format("2006-01-02 15:04:05")
				return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("当前时间已有正在进行的项目，请将项目开始时间设置至 %s 之后", today))
			}
		}

		if project.State == domain.ProjectStateWaitConfig {
			project.State = domain.ProjectStateWaitActive
		}
		project.Recipients = in.Recipients
		project.PrincipalId = in.PrincipalId
		project.Template = cycleTemplate.Template

		// 项目起始截止时间（环节中的时间暂未分开计算）
		project.BeginTime = start
		project.EndTime = end
		for i := range project.Template.LinkNodes {
			node := project.Template.LinkNodes[i]
			node.KpiCycle = in.KpiCycle // 设置周期
			node.TimeStart = &start
			node.TimeEnd = &end
		}
		project, err = projectRepository.Insert(project)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return project, nil
	}
}

// 更新项目截止时间，同步任务截止时间
func (rs *EvaluationProjectService) updateTaskTime(context application.TransactionContext, projectId int64, end *time.Time) error {
	// 查看任务过程，重新日计算任务截至期
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": context})
	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": projectId})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	now := time.Now().Local()
	year, month, day := now.Date()
	nowO := time.Date(year, month, day, 0, 0, 0, 0, time.Local) // 当前时间0点0分0秒时刻

	for i := range tasks {
		task := tasks[i]

		if end != nil {
			task.TimeEnd = end // 先赋值
		}

		if task.NextSentAt == nil { // 重新计算
			// 环节起始和截止本地时间
			startLocal := task.TimeStart.Local()
			sY, sM, sD := startLocal.Date()
			startLocal = time.Date(sY, sM, sD, 0, 0, 0, 0, time.Local) // 开始时间以0点开始计算

			// 在当前时间之前，则计算下一个周期时间
			if startLocal.Before(nowO) {
				nextTime := utils.NextTime(nowO, startLocal, task.KpiCycle)
				task.NextSentAt = &nextTime
			} else {
				task.NextSentAt = &startLocal
			}

			// 注.最后一次发送时间和重新计算后的时间相同时，继续获取下一个周期
			if task.LastSentAt != nil {
				nextY, nextM, nextD := task.NextSentAt.Local().Date()
				lastY, lastM, lastD := task.LastSentAt.Local().Date()
				if nextY == lastY && nextM == lastM && nextD == lastD {
					nextTime := utils.NextTimeInc(task.NextSentAt.Local(), task.KpiCycle)
					task.NextSentAt = &nextTime
				}
			}
		}

		// 如果超出截至时间，则周期置空
		if task.NextSentAt.Local().After(task.TimeEnd.Local()) {
			task.NextSentAt = nil
		}

		// 更新任务
		task, err := taskRepository.Insert(task)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	return nil
}

func (rs *EvaluationProjectService) Get(in *command.GetProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project

	userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	if len(project.PmpIds) > 0 {
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}

	if len(project.Recipients) > 0 {
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.Recipients, "limit": len(project.Recipients)})
		projectAdapter.TransformRecipientAdapter(users, project.PrincipalId)
	}

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

func (rs *EvaluationProjectService) Remove(in *command.DeleteProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
	staffRepository := factory.CreateStaffAssessTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
	summaryRepository := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := projectRepository.Remove(project); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 删除项目已生成的周期评估数据
	if err := staffRepository.RemoveByProjectId(int(project.Id)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 删除项目已生成的周期评估数据
	if err := summaryRepository.RemoveByProjectId(int(project.Id)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 移除项目关联的所有定时任务
	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": project.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range tasks {
		if _, err := taskRepository.Remove(tasks[i]); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

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

func (rs *EvaluationProjectService) List(in *command.QueryProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	total, projects, err := projectRepository.Find(tool_funs.SimpleStructToMap(in), "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	now := time.Now().Unix()
	pmpUsers := make([]*domain.User, 0)
	pmpUserIds := make([]int64, 0)
	for i := range projects {
		project := projects[i]
		for j := range project.PmpIds {
			userId, _ := strconv.ParseInt(project.PmpIds[j], 10, 64)
			pmpUserIds = append(pmpUserIds, userId)
		}

		// 如果是已启用状态时，当前时间超过截至时间显示【已结束】
		if project.State == domain.ProjectStateEnable {
			if now > project.EndTime.Unix() {
				project.State = domain.ProjectStateDisable
			}
		}

	}

	if len(pmpUserIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": pmpUserIds, "limit": len(pmpUserIds)})
		pmpUsers = users
	}

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

	projectAdapters := adapter.TransformProjectListAdapter(projects, pmpUsers)
	return tool_funs.SimpleWrapGridMap(total, projectAdapters), nil
}

func (rs *EvaluationProjectService) Activate(in *command.ActivateProjectCommand) (interface{}, error) {
	lock := xredis.NewLockProjectId(int(in.Id))
	err := lock.Lock()
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		lock.UnLock()
	}()

	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if project.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加评估模板")
	}
	if len(project.Recipients) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
	}
	if project.State == domain.ProjectStateEnable {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目已启动")
	}
	if project.State == domain.ProjectStatePause {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目暂停中，先进行恢复")
	}
	// 周期内的所有项目，已启用的员工不能重复被评估
	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": project.CompanyId, "cycleId": project.CycleId}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	userMap := map[string]*domain.User{}
	for i := range projects {
		it := projects[i]
		// 排除当前项目
		if in.Id == it.Id {
			continue
		}
		// 启用状态的被评估人
		if it.State == domain.ProjectStateEnable {
			for j := range it.Recipients {
				userMap[it.Recipients[j]] = nil
			}
		}
	}
	ids := make([]string, 0)
	for k := range userMap {
		ids = append(ids, k)
	}
	if len(ids) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, err := userRepository.Find(map[string]interface{}{"ids": ids})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range users {
			s64 := strconv.FormatInt(users[i].Id, 10)
			userMap[s64] = users[i]
		}
		var build strings.Builder
		for i := range project.Recipients {
			id := project.Recipients[i]
			if user, ok := userMap[id]; ok {
				build.WriteString("[")
				build.WriteString(user.Name)
				build.WriteString("]")
			}
		}
		if build.Len() > 0 {
			return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("请先停止%s正在进行的项目", build.String()))
		}
	}

	project.State = domain.ProjectStateEnable
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 项目中指标任务负责人
	var principalId = 0
	var projectTaskService = taskService.NewTaskService()
	if len(project.PrincipalId) > 0 {
		intId, _ := strconv.Atoi(project.PrincipalId)
		principalId = intId
	}

	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": project.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(tasks) == 0 {
		now := time.Now().Local()
		year, month, day := now.Date()
		nowO := time.Date(year, month, day, 0, 0, 0, 0, time.Local) // 当前时间0点0分0秒时刻
		for i := range project.Template.LinkNodes {
			node := project.Template.LinkNodes[i]
			task := &domain.NodeTask{
				Id:           0,
				CompanyId:    project.CompanyId,
				CycleId:      project.CycleId,
				ProjectId:    project.Id,
				NodeId:       node.Id,
				NodeType:     node.Type,
				NodeName:     node.Name,
				NodeDescribe: node.Describe,
				NodeSort:     i + 1,
				TimeStart:    node.TimeStart,
				TimeEnd:      node.TimeEnd,
				KpiCycle:     node.KpiCycle,
			}

			// 环节起始和截止本地时间
			startLocal := task.TimeStart.Local()
			sY, sM, sD := startLocal.Date()
			startLocal = time.Date(sY, sM, sD, 0, 0, 0, 0, time.Local) // 开始时间以0点开始计算
			endLocal := task.TimeEnd.Local()

			// 在当前时间之前，则计算下一个周期时间
			if startLocal.Before(nowO) {
				nextTime := utils.NextTime(nowO, startLocal, node.KpiCycle)
				task.NextSentAt = &nextTime
			} else {
				task.NextSentAt = &startLocal
			}
			// 如果超出截至时间，则周期置空
			if task.NextSentAt.After(endLocal) {
				task.NextSentAt = nil
			}

			_, err := taskRepository.Insert(task)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}

			// 任务指标生成任务
			for j := range node.NodeContents {
				content := node.NodeContents[j]
				if content.IndicatorType == domain.IndicatorTypeTask {
					if principalId == 0 {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请选择任务负责人")
					}
					err := projectTaskService.CreateTask(transactionContext, &taskCommand.CreateTaskCommand{
						Name:     content.Name,
						LeaderId: principalId,
					})
					if err != nil {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
					}
				}
			}
		}

		err = rs.generateEvaluationItemUsed(transactionContext, project)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

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

func (rs *EvaluationProjectService) Pause(in *command.ActivateProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if project.State != domain.ProjectStateEnable {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目未启动")
	}

	project.State = domain.ProjectStatePause
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": project.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	for i := range tasks {
		it := tasks[i]
		it.NextSentAt = nil
		_, err = taskRepository.Insert(it)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

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

func (rs *EvaluationProjectService) Resume(in *command.ActivateProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if project.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加评估模板")
	}
	if len(project.Recipients) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
	}
	if project.State == domain.ProjectStateEnable {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目已启动")
	}

	// 周期内的所有项目，已启用的员工不能重复被评估
	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": project.CompanyId, "cycleId": project.CycleId}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	userMap := map[string]*domain.User{}
	for i := range projects {
		it := projects[i]
		// 排除当前项目
		if in.Id == it.Id {
			continue
		}
		// 启用状态的被评估人
		if it.State == domain.ProjectStateEnable {
			for j := range it.Recipients {
				userMap[it.Recipients[j]] = nil
			}
		}
	}
	ids := make([]string, 0)
	for k := range userMap {
		ids = append(ids, k)
	}
	if len(ids) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, err := userRepository.Find(map[string]interface{}{"ids": ids})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range users {
			s64 := strconv.FormatInt(users[i].Id, 10)
			userMap[s64] = users[i]
		}
		var build strings.Builder
		for i := range project.Recipients {
			id := project.Recipients[i]
			if user, ok := userMap[id]; ok {
				build.WriteString("[")
				build.WriteString(user.Name)
				build.WriteString("]")
			}
		}
		if build.Len() > 0 {
			return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("请先停止%s正在进行的项目", build.String()))
		}
	}

	project.State = domain.ProjectStateEnable
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 项目恢复，同步更新任务时间
	if err = rs.updateTaskTime(transactionContext, in.Id, nil); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

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

func (rs *EvaluationProjectService) Copy(in *command.CopyProjectCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// ID重置
	project.Id = 0
	project.Name = project.Name + " 副本"
	project.CreatorId = in.CreatorId
	project.Recipients = make([]string, 0) // 重置被评估人
	project.PrincipalId = ""               // 重置任务负责人

	// 如果拷贝已经启用的模板，默认先设置为待启用
	if project.State == domain.ProjectStateEnable || project.State == domain.ProjectStatePause {
		project.State = domain.ProjectStateWaitActive
	}
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return project, nil
}

func (rs *EvaluationProjectService) CheckRecipients(in *command.CheckRecipientCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})

	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 周期内的所有项目，员工不能重复被评估
	rids := map[string]bool{}
	for i := range projects {
		it := projects[i]
		// 排除当前项目
		if in.Id == it.Id {
			continue
		}
		if it.State == domain.ProjectStateEnable {
			for j := range it.Recipients {
				rids[it.Recipients[j]] = true
			}
		}
	}
	repeatNum := 0
	for i := range in.Recipients {
		id := in.Recipients[i]
		if _, ok := rids[id]; ok {
			repeatNum++
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{"repeatNum": repeatNum}, nil
}

func (rs *EvaluationProjectService) generateEvaluationItemUsed(transactionContext application.TransactionContext, project *domain.EvaluationProject) error {
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	var err error
	cnt, _, err := itemUsedRepo.Find(map[string]interface{}{"evaluationProjectId": project.Id, "limit": 1})
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, "检查评估选项"+err.Error())
	}
	if cnt > 0 {
		return nil
	}
	var itemUsedList []*domain.EvaluationItemUsed
	nowTime := time.Now()
	for _, v := range project.Template.LinkNodes {
		for i2, v2 := range v.NodeContents {
			item := domain.EvaluationItemUsed{
				Id:                  0,
				CompanyId:           int(project.CompanyId),
				EvaluationProjectId: int(project.Id),
				NodeId:              int(v.Id),
				NodeType:            v.Type,
				SortBy:              i2 + 1,
				Category:            v2.Category,
				Name:                v2.Name,
				PromptTitle:         v2.PromptTitle,
				PromptText:          v2.PromptText,
				EntryItems:          v2.EntryItems,
				Weight:              v2.Weight,
				Required:            v2.Required,
				EvaluatorId:         int(v2.EvaluatorId),
				IndicatorType:       v2.IndicatorType,
				CreatedAt:           nowTime,
				UpdatedAt:           nowTime,
			}
			if v2.Rule != nil {
				item.RuleType = v2.Rule.Type
				item.Rule = *v2.Rule
			}
			itemUsedList = append(itemUsedList, &item)
		}
	}

	err = itemUsedRepo.BatchInsert(itemUsedList)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

func (rs *EvaluationProjectService) CheckTaskTemplate(in *command.CheckTaskTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.TemplateId, "includeDeleted": true})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cycleTemplate == nil || cycleTemplate.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "未找到模板")
	}

	// 指标任务的项目（存在一项类型为任务指标），必须添加项目负责人
	var indicatorTypeTask = 0
outerLoop:
	for i := range cycleTemplate.Template.LinkNodes {
		var node = cycleTemplate.Template.LinkNodes[i]
		for j := range node.NodeContents {
			if node.NodeContents[j].IndicatorType == domain.IndicatorTypeTask {
				indicatorTypeTask = 1
				break outerLoop
			}
		}
	}

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

	return map[string]interface{}{"indicatorTypeTask": indicatorTypeTask}, nil
}

// 修复数据用
func (rs *EvaluationProjectService) FixEvaluationItemUsed(id int) error {

	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": id})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = rs.generateEvaluationItemUsed(transactionContext, project)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}