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})

	// 检测名称重复
	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())
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle

	for i := range templates {
		v := templates[i]
		cycleTemplate := &domain.EvaluationCycleTemplate{
			Id:       0,
			Name:     v.Name,
			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:        v.Id,
			Name:      v.Name,
			CreatedAt: v.CreatedAt,
		})
	}

	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,
				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].CreatedAt,
		})
	}

	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].CreatedAt,
		})
	}

	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())
	}
	return tool_funs.SimpleWrapGridMap(total, cycles), nil
}