package service

import (
	"fmt"

	"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/query"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

//获取我的项目周期
func (srv StaffAssessServeice) SearchAssessCycelMe(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
	assessCycleList, err := staffAssessTaskRepo.SearchAssessCycleMe(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.AssessCycleDayResp, 0, len(assessCycleList))
	var temp adapter.AssessCycleDayResp
	for _, v := range assessCycleList {
		temp = adapter.AssessCycleDayResp{
			CycleId:   v.CycleId,
			CycleName: v.CycleName,
			BeginDay:  v.BeginDay,
		}
		listData = append(listData, temp)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), listData), nil
}

//获取我的项目周期进度描述
func (srv StaffAssessServeice) AssessCycleMeDesc(param *query.AssessCycleDescQuery) (*adapter.AssessCycleDescResp, 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,
	})
	assessTaskDataAny, err := staffAssessTaskRepo.FindOne(map[string]interface{}{
		"cycleId":  param.CycleId,
		"beginDay": param.BeginDay,
		"limit":    1,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "评估任务不存在，"+err.Error())
	}
	_, myAssessTask, err := staffAssessTaskRepo.Find(map[string]interface{}{
		"cycleId":    param.CycleId,
		"beginDay":   param.BeginDay,
		"executorId": param.UserId,
		"limit":      1,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "我的评估任务不存在，"+err.Error())
	}
	//返回的数据结果
	result := adapter.AssessCycleDescResp{
		CycleId:   int(assessTaskDataAny.CycleId),
		CycleName: assessTaskDataAny.CycleName,
		BeginDay:  assessTaskDataAny.BeginDay,
		StepList:  []adapter.AssessTaskStep{},
	}

	for _, v := range assessTaskDataAny.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:
			if len(myAssessTask) > 0 {
				//个人自评完成情况
				_, assessSelfData, err := staffAssessRepo.Find(map[string]interface{}{
					"staffAssessTaskId": myAssessTask[0].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:
			if len(myAssessTask) > 0 {
				//邀请别人评估自己
				_, 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{}{
				"beginDay":   param.BeginDay,
				"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
}