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"
	permissionSrv "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/permission"
	permissionCmd "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/permission/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

func getPermission(companyId int64) (*domain.Permission, error) {
	srv := &permissionSrv.PermissionService{}
	permissionData, err := srv.Get(&permissionCmd.GetPermissionCommand{
		CompanyId: companyId,
	})
	if err != nil {
		return nil, err
	}
	return permissionData, nil
}

// ListCycleAndProject
// 自评小结列表，自评评估列表
func (srv *SummaryEvaluationService) ListCycleAndProject(param *command.QueryCycleList) (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()
	}()
	limit := 600
	offset := 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	if param.PageNumber > 0 {
		offset = (param.PageNumber - 1) * param.PageSize
	}
	assessDao := dao.NewStaffAssessDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	projectList, err := assessDao.ListCycleAndProject(param.UserId, param.CompanyId, param.CycleId, offset, limit)
	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())
	}

	cycleList := []adapter.CycleAndProjctListAdapter{}
	for _, v := range projectList {
		m := adapter.CycleAndProjctListAdapter{
			CycleId:      v.CycleId,
			CycleName:    v.CycleName,
			ProjectId:    v.EvaluationProjectId,
			ProjectName:  v.EvaluationProjectName,
			TargetUserId: v.TargetUserId,
		}

		cycleList = append(cycleList, m)
	}
	return tool_funs.SimpleWrapGridMap(int64(len(projectList)), cycleList), nil

}

// 周期综合自评小结详情
func (srv *SummaryEvaluationService) CountEvaluationSelfLevelV2(param *command.QueryEvaluationSelf) (*adapter.EvaluationInfoCountCodeAdapter, 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()
	}()
	//统计周期内，评估项等级的数量
	assessDao := dao.NewStaffAssessDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"limit":        1,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"types":        domain.EvaluationSelf,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		return &adapter.EvaluationInfoCountCodeAdapter{}, nil
	}
	evaluationData := evaluationList[0]
	levelCodeCountList, err := assessDao.CountAssessContentLevelCode(param.ProjectId, param.TargetUserId, domain.AssessSelf, param.CycleId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": param.ProjectId,
		"nodeType":            int(domain.LinkNodeSelfAssessment),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})

	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 获取组装基本信息
	evaluationBase := srv.getSummaryEvaluation(transactionContext, evaluationData)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	evaluationItems := srv.buildSummaryItemValue(itemList, itemValues)

	levelCodeMap := map[int][]adapter.LevalCodeCount{}
	for _, v := range evaluationItems {
		codes := v.Rule.GetLevelCodes()
		levelCode := []adapter.LevalCodeCount{}
		for _, v2 := range codes {
			levelCode = append(levelCode, adapter.LevalCodeCount{
				Code:   v2,
				Number: 0,
			})
		}
		levelCodeMap[v.EvaluationItemId] = levelCode
	}
	levelCodeCountMap := map[string]int{}
	for _, v := range levelCodeCountList {
		key := fmt.Sprintf("%s-%s-%s", v.Category, v.Name, v.LevelValue)
		levelCodeCountMap[key] = v.Cnt
	}

	evaluationItemCount := []adapter.EvaluationItemCountCodeAdapter{}
	for i := range evaluationItems {
		itemCount := adapter.EvaluationItemCountCodeAdapter{
			EvaluationItemAdapter: evaluationItems[i],
			LevelCount:            []adapter.LevalCodeCount{},
		}
		evaluationItemCount = append(evaluationItemCount, itemCount)
		itemId := evaluationItems[i].EvaluationItemId
		levelCodes, ok := levelCodeMap[itemId]
		if !ok {
			continue
		}
		evaluationItemCount[i].LevelCount = levelCodes
		for i2 := range levelCodes {
			key := fmt.Sprintf("%s-%s-%s",
				evaluationItems[i].Category,
				evaluationItems[i].Name,
				levelCodes[i2].Code,
			)
			if mVal, ok := levelCodeCountMap[key]; ok {
				levelCodes[i2].Number = mVal
			}
		}
	}
	evaluationInfo := adapter.EvaluationInfoCountCodeAdapter{
		EvaluationBaseAdapter: evaluationBase,
		EvaluationItems:       evaluationItemCount,
	}
	return &evaluationInfo, nil
}