package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_cycle/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_cycle/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"strconv"
)

type EvaluationCycleService struct {
}

func NewEvaluationCycleService() *EvaluationCycleService {
	newRoleService := &EvaluationCycleService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationCycleService) Create(in *command.CreateCycleCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复
	count, err := cycleRepository.Count(map[string]interface{}{"name": in.Name, "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, "已存在相同名称的周期")
	}

	_, templates, err := templateRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "ids": in.TemplateIds})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(templates) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "模板不存在, 请重新选择")
	}

	// 生成新周期数据
	newCycle := &domain.EvaluationCycle{
		Id:        0,
		Name:      in.Name,
		TimeStart: in.TimeStart,
		TimeEnd:   in.TimeEnd,
		CompanyId: in.CompanyId,
		CreatorId: in.CreatorId,
		KpiCycle:  in.KpiCycle,
	}
	cycle, err := cycleRepository.Insert(newCycle)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 获取所有模板中的规则对象数据
	ruleIdsMap := map[int64]int64{}
	for i := range templates {
		v := templates[i]
		for j := range v.LinkNodes {
			node := v.LinkNodes[j]
			for k := range node.NodeContents {
				nodeContent := node.NodeContents[k]
				if nodeContent.RuleId != 0 {
					ruleIdsMap[nodeContent.RuleId] = nodeContent.RuleId
				}
			}
		}
	}
	ruleIds := make([]int64, 0)
	for k := range ruleIdsMap {
		ruleIds = append(ruleIds, k)
	}

	_, rules, err := ruleRepository.Find(map[string]interface{}{"ids": ruleIds, "companyId": in.CompanyId})

	ruleMap := map[int64]*domain.EvaluationRule{}
	for i := range rules {
		ruleMap[rules[i].Id] = rules[i]
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
	for i := range templates {
		v := templates[i]

		// 对评估模板中的评估规则进行数据赋值
		for j := range v.LinkNodes {
			node := v.LinkNodes[j]
			for k := range node.NodeContents {
				nodeContent := node.NodeContents[k]
				if rule, ok := ruleMap[nodeContent.RuleId]; ok {
					nodeContent.Rule = rule
				}
			}
		}

		// 周期模板数据表中插入数据
		cycleTemplate := &domain.EvaluationCycleTemplate{
			Id:                0,
			Name:              v.Name,
			TemplateCreatedAt: v.CreatedAt,
			Template:          v,
			CycleId:           cycle.Id,
		}
		_, err := cycleTemplateRepository.Insert(cycleTemplate)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		// 输出模板简单信息
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
			Id:        cycleTemplate.Id,
			Name:      cycleTemplate.Name,
			CreatedAt: cycleTemplate.TemplateCreatedAt, // 模板创建时间
		})
	}

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

}

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

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

	// 检测名称重复（排除自己）
	count, err := cycleRepository.Count(map[string]interface{}{"name": in.Name, "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, "名称已存在")
	}

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

	_, oldCycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 当前周期的所有模板数据
	oldTemplateMap := map[int64]*domain.EvaluationCycleTemplate{}
	for i := range oldCycleTemplates {
		oldTemplateMap[oldCycleTemplates[i].Id] = oldCycleTemplates[i]
	}
	// 拆离新旧模板Id
	newTemplateIds := make([]int64, 0)
	for i := range in.TemplateIds {
		int64Id, _ := strconv.ParseInt(in.TemplateIds[i], 10, 64)
		if _, ok := oldTemplateMap[int64Id]; ok {
			delete(oldTemplateMap, int64Id) // 旧模板继续被引用
		} else {
			newTemplateIds = append(newTemplateIds, int64Id) // 增加新模板ID
		}
	}
	// 旧模板未被引用，则进行删除处理
	for k := range oldTemplateMap {
		_, err := cycleTemplateRepository.Remove(oldTemplateMap[k])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	// 增加新模板数据
	if len(newTemplateIds) > 0 {
		_, templates, err := templateRepository.Find(map[string]interface{}{"companyId": cycle.CompanyId, "ids": newTemplateIds})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range templates {
			v := templates[i]
			cycleTemplate := &domain.EvaluationCycleTemplate{
				Id:                0,
				Name:              v.Name,
				TemplateCreatedAt: v.CreatedAt,
				Template:          v,
				CycleId:           cycle.Id,
			}
			_, err := cycleTemplateRepository.Insert(cycleTemplate)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}

	cycle.Name = in.Name
	cycle.TimeStart = in.TimeStart
	cycle.TimeEnd = in.TimeEnd
	cycle.KpiCycle = in.KpiCycle
	cycle, err = cycleRepository.Insert(cycle)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
	for i := range cycleTemplates {
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
		})
	}

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

func (rs *EvaluationCycleService) Get(in *command.GetCycleCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

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

	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
	for i := range cycleTemplates {
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
		})
	}

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

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

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

	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := cycleRepository.Remove(cycle); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// FIXME 删除周期关联的所有模板...   还需要删除关联的定时内容
	if err := cycleTemplateRepository.BatchDeleteByCycleId(cycle.Id); 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 cycle, nil
}

func (rs *EvaluationCycleService) List(in *command.QueryCycleCommand) (interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
	total, cycles, err := cycleRepository.Find(tool_funs.SimpleStructToMap(in))
	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 tool_funs.SimpleWrapGridMap(total, cycles), nil
}

func (rs *EvaluationCycleService) StatisticCycleUser(in *command.StatisticCycleProjectUserCommand) (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(tool_funs.SimpleStructToMap(in), "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	userIds := make([]int64, 0)
	userIdMap := map[int64]int64{}
	for i := range projects {
		project := projects[i]
		for j := range project.Recipients {
			userId, _ := strconv.ParseInt(project.Recipients[j], 10, 64)
			userIdMap[userId] = userId
		}
	}
	for k := range userIdMap {
		userIds = append(userIds, k)
	}

	userTotal := 0
	departmentTotal := 0
	if len(userIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": userIds, "limit": len(userIds)})
		departmentIdMap := map[int]int{}
		for i := range users {
			for _, v := range users[i].DepartmentId {
				departmentIdMap[v] = v
			}
		}
		userTotal = len(users)
		departmentTotal = len(departmentIdMap)
	}

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

func (rs *EvaluationCycleService) CycleTemplateList(in *command.CycleTemplateListCommand) (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})
	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": in.CycleId}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	list := make([]*domain.TemplateSimple, 0)
	for i := range cycleTemplates {
		list = append(list, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
		})
	}

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

func (rs *EvaluationCycleService) CycleTemplate(in *command.CycleTemplateCommand) (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.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.TRANSACTION_ERROR, err.Error())
	}
	return cycleTemplate.Template, nil
}