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_template/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
)

type EvaluationTemplateService struct {
}

func NewEvaluationTemplateService() *EvaluationTemplateService {
	newRoleService := &EvaluationTemplateService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationTemplateService) Create(in *command.CreateTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复
	count, err := templateRepository.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, "已存在相同名称的评估模板")
	}

	linkNodes := make([]*domain.LinkNode, 0)

	sid, _ := utils.NewSnowflakeId()

	// 自评反馈
	selfLinkNode := &domain.LinkNode{
		Id:           sid + 1,
		Type:         domain.LinkNodeSelfAssessment,
		Name:         "填写自评反馈",
		NodeContents: make([]*domain.NodeContent, 0),
		KpiCycle:     domain.KpiCycleDay,
	}
	// 有环节自评评估内容，则直接使用
	if len(in.NodeContents) > 0 {
		selfLinkNode.NodeContents = in.NodeContents
	}

	linkNodes = append(linkNodes, selfLinkNode)
	linkNodes = append(linkNodes, &domain.LinkNode{
		Id:           sid + 2,
		Type:         domain.LinkNodeAllInvite,
		Name:         "360°邀请",
		NodeContents: make([]*domain.NodeContent, 0),
		KpiCycle:     domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Id:           sid + 3,
		Type:         domain.LinkNodeAllAssessment,
		Name:         "360°评估",
		NodeContents: make([]*domain.NodeContent, 0),
		KpiCycle:     domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Id:           sid + 4,
		Type:         domain.LinkNodeSuperiorAssessment,
		Name:         "上级评估",
		NodeContents: make([]*domain.NodeContent, 0),
		KpiCycle:     domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Id:           sid + 5,
		Type:         domain.LinkNodeViewResult,
		Name:         "绩效结果查看",
		NodeContents: make([]*domain.NodeContent, 0),
		KpiCycle:     domain.KpiCycleDay,
	})

	newTemplate := &domain.EvaluationTemplate{
		Id:        0,
		Name:      in.Name,
		Describe:  in.Describe,
		CompanyId: in.CompanyId,
		CreatorId: in.CreatorId,
		State:     domain.TemplateStateWaitConfig,
		LinkNodes: linkNodes,
	}
	if in.State > domain.TemplateStateWaitConfig {
		newTemplate.State = in.State
	}

	template, err := templateRepository.Insert(newTemplate)
	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 template, nil

}

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

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

	// 检测名称重复（排除自己）
	count, err := templateRepository.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, "名称已存在")
	}

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

	template.Name = in.Name
	template.Describe = in.Describe
	template.LinkNodes = in.LinkNodes

	// 完成配置保存，更新状态
	if in.FinishConfig == 1 && template.State == domain.TemplateStateWaitConfig {
		template.State = domain.TemplateStateWaitActive
	}

	template, err = templateRepository.Insert(template)
	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 template, nil
}

func (rs *EvaluationTemplateService) Get(in *command.GetTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	template, err := templateRepository.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 template, nil
}

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

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

	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := templateRepository.Remove(template); 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 template, nil
}

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

	queryOptions := tool_funs.SimpleStructToMap(in)
	if len(in.CreatedAt) == 0 {
		delete(queryOptions, "createdAt") // 删除创建时间
	}

	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	total, templates, err := templateRepository.Find(queryOptions, "link_nodes")
	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, templates), nil
}

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

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

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

	template.State = in.State
	template, err = templateRepository.Insert(template)
	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 template, nil
}

func (rs *EvaluationTemplateService) Copy(in *command.CopyTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// ID重置
	template.Id = 0
	template.Name = template.Name + " 副本"
	template.CreatorId = in.CreatorId

	// 如果拷贝已经启用的模板，默认先设置为待启用
	if template.State == domain.TemplateStateEnable {
		template.State = domain.TemplateStateWaitActive
	}

	// 流程环节ID重置
	sid, _ := utils.NewSnowflakeId()
	for i := range template.LinkNodes {
		template.LinkNodes[i].Id = sid + int64(i+1)
	}

	template, err = templateRepository.Insert(template)
	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 template, nil
}