package service

import (
	"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"
	roleService "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

type SummaryEvaluationServeice struct {
}

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

// GetCycleList
// 获取周期列表
func (srv *SummaryEvaluationServeice) GetCycleList(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()
	}()
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := 300
	offset := 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	if param.PageNumber > 0 {
		offset = (param.PageNumber - 1) * param.PageSize
	}

	cycleData, err := evaluationDao.GetPersonalCycleList(param.UserId, offset, limit)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取周期列表"+err.Error())
	}

	cnt, err := evaluationDao.CountPersonalCycleList(param.UserId)
	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.CycleListAdapter{}
	for _, v := range cycleData {
		m := adapter.CycleListAdapter{
			CycleId:    v.CycleId,
			CycleName:  v.CycleName,
			ExecutorId: v.ExecutorId,
		}
		cycleList = append(cycleList, m)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), cycleList), nil
}

// GetMenu
// 根据周期获取菜单显示
func (srv *SummaryEvaluationServeice) GetMenu(param *command.QueryMenu) (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()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	//查找我的绩效
	_, selfEvaluation, err := evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.EvaluationSelf),
		"executorId": param.UserId,
		"limit":      1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//查找360评估,统计未完成的
	cnt360, _, err := evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.Evaluation360),
		"executorId": param.UserId,
		"limit":      1,
		"status":     string(domain.EvaluationUncompleted),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//查询上级评估，统计未完成
	cntSuper, _, err := evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.EvaluationSelf),
		"executorId": param.UserId,
		"limit":      1,
		"status":     string(domain.EvaluationUncompleted),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//查询人资评估,统计未完成
	cntHrbp, _, err := evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.EvaluationHrbp),
		"executorId": param.UserId,
		"limit":      1,
		"status":     string(domain.EvaluationUncompleted),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	isHrbp, err := roleService.GetHRBP(transactionContext, param.CompanyId, param.UserId)
	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())
	}

	menuList := []adapter.MenuListAdapter{}

	//模块-我的绩效
	menu1 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "我的绩效",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu1_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "填写综合自评",
		StatusName: "",
		Types:      "填写综合自评",
	}
	menu1_2 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "查看综合自评",
		StatusName: "",
		Types:      "查看综合自评",
	}
	if len(selfEvaluation) > 0 {
		if selfEvaluation[0].Status == domain.EvaluationCompleted {
			menu1_1.StatusName = "已完成"
		} else {
			menu1_1.StatusName = "未完成"
		}
		if selfEvaluation[0].CheckResult == domain.EvaluationCheckCompleted {
			menu1_2.StatusName = "已完成"
		} else {
			menu1_2.StatusName = "未完成"
		}
	}
	menu1.Child = append(menu1.Child, menu1_1, menu1_2)
	menuList = append(menuList, menu1)
	menu2 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "给他人评估",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu2_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "360综评",
		StatusName: "",
		Types:      "360综评",
	}
	if cnt360 > 0 {
		menu2_1.StatusName = "未完成"
	} else {
		menu2_1.StatusName = "已完成"
	}
	menu2.Child = append(menu2.Child, menu2_1)
	menuList = append(menuList, menu2)
	menu3 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "人资评估",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu3_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "上级综评",
		StatusName: "",
		Types:      "上级综评",
	}
	if cntHrbp > 0 {
		menu3_1.StatusName = "未完成"
	} else {
		menu3_1.StatusName = "已完成"
	}
	menu3.Child = append(menu3.Child, menu3_1)
	//hrbp 才有这个菜单
	if isHrbp > 0 {
		menuList = append(menuList, menu3)
	}
	menu4 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "我的团队绩效",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu4_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "上级综评",
		StatusName: "",
		Types:      "上级综评",
	}
	if cntSuper > 0 {
		menu4_1.StatusName = "未完成"
	} else {
		menu4_1.StatusName = "已完成"
	}
	menu4.Child = append(menu4.Child, menu4_1)
	menuList = append(menuList, menu4)
	result := map[string]interface{}{
		"menus": menuList,
	}
	return result, nil
}

// buildSummaryItemValue 将填写值填充进评估项
func (srv *SummaryEvaluationServeice) buildSummaryItemValue(itemList []*domain.EvaluationItemUsed, valueList []*domain.SummaryEvaluationValue) (
	itemValues []adapter.EvaluationItemAdapter) {
	itemValues = []adapter.EvaluationItemAdapter{}
	valueMap := map[int]*domain.SummaryEvaluationValue{}
	for _, v := range valueList {
		valueMap[v.EvaluationItemId] = v
	}
	for _, v := range itemList {
		item := adapter.EvaluationItemAdapter{
			EvaluationItemId: v.Id,
			SortBy:           v.SortBy,
			Category:         v.Category,
			Name:             v.Name,
			PromptTitle:      v.PromptTitle,
			PromptText:       v.PromptText,
			EntryItems:       v.EntryItems,
			RuleType:         v.RuleType,
			Rule:             v.Rule,
			Weight:           v.Weight,
			Required:         v.Required,
			Value:            "",
			Score:            "",
			Remark:           "",
		}
		value, ok := valueMap[v.Id]
		if !ok {
			continue
		}
		item.Score = value.Score
		item.Value = value.Value
		item.Remark = value.Remark
		itemValues = append(itemValues, item)
	}
	return itemValues
}

// 获取综合自评详情
func (srv *SummaryEvaluationServeice) GetEvaluationSelf(param *command.QueryEvaluationInfo) (*adapter.EvaluationInfoAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	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.CompanyId,
		"executorId": param.ExecutorId,
		"types":      domain.EvaluationSelf,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	evaluationData := evaluationList[0]
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"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())
	}

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

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	result := adapter.EvaluationInfoAdapter{
		SummaryEvaluationId:   evaluationData.Id,
		CycleId:               int(evaluationData.CycleId),
		CycleName:             evaluationData.CycleName,
		EvaluationProjectId:   evaluationData.EvaluationProjectId,
		EvaluationProjectName: evaluationData.EvaluationProjectName,
		LinkNodeId:            evaluationData.NodeId,
		BeginTime:             evaluationData.BeginTime.Format("2006-01-02 15:04:05"),
		EndTime:               evaluationData.EndTime.Format("2006-01-02 15:04:05"),
		Status:                string(evaluationData.Status),
		EvaluationItems:       itemValuesAdapter,
	}
	return &result, nil
}

// 编辑综合自评详情
func (srv *SummaryEvaluationServeice) EditEvaluationSelf(param *command.EditEvaluationValue) (map[string][]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationData, err := evaluationRepo.FindOne(map[string]interface{}{
		"id": param.SummaryEvaluationId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if evaluationData.Executor.UserId != param.ExecutorId {

		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	if evaluationData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	_, itemList, err := itemUsedRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

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

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

	evaluationValueMap := map[int]*domain.SummaryEvaluationValue{}
	for _, v := range itemList {
		newValue := &domain.SummaryEvaluationValue{}
		newValue.SetBlankValue(evaluationData, v)
		evaluationValueMap[v.Id] = newValue
	}
	for _, v := range itemValueList {
		if mValue, ok := evaluationValueMap[v.EvaluationItemId]; ok {
			mValue.Id = v.Id
		}
	}

	nowTime := time.Now()
	for _, v := range param.EvaluationItems {
		updatedData, ok := evaluationValueMap[v.EvaluationItemId]
		if !ok {
			updatedData.UpdatedAt = nowTime
			updatedData.Value = v.Value
			updatedData.Remark = v.Remark
		}
	}
	evaluationValueList := []*domain.SummaryEvaluationValue{}
	for _, v := range evaluationValueMap {
		err = itemValueRepo.Save(v)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		evaluationValueList = append(evaluationValueList, v)
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	itemValueAdapter := srv.buildSummaryItemValue(itemList, evaluationValueList)
	return map[string][]adapter.EvaluationItemAdapter{
		"EvaluationItems": itemValueAdapter,
	}, nil
}