package factory

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	pgDB "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/pg"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/repository"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
)

func CreateTransactionContext(options map[string]interface{}) (application.TransactionContext, error) {
	return pg.NewPGTransactionContext(pgDB.DB), nil
}

// StartTransaction 事务创建
func StartTransaction() (application.TransactionContext, error) {
	transactionContext, err := 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())
	}
	return transactionContext, nil
}

// ValidateStartTransaction 事务创建并校验入参
func ValidateStartTransaction(in interface{}) (application.TransactionContext, error) {
	if err := utils.ValidateCommand(in); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	return StartTransaction()
}

func CreateCompanyRepository(options map[string]interface{}) domain.CompanyRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewCompanyRepository(transactionContext)
}

func CreateUserRepository(options map[string]interface{}) domain.UserRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewUserRepository(transactionContext)
}

func CreateDepartmentRepository(options map[string]interface{}) domain.DepartmentRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewDepartmentRepository(transactionContext)
}

func CreatePositionRepository(options map[string]interface{}) domain.PositionRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewPositionRepository(transactionContext)
}

func CreateRoleRepository(options map[string]interface{}) domain.RoleRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewRoleRepository(transactionContext)
}

func CreateRoleUserRepository(options map[string]interface{}) domain.RoleUserRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewRoleUserRepository(transactionContext)
}

func CreateReceivedMessageRepository(options map[string]interface{}) domain.ReceivedMessageRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewReceivedMessageRepository(transactionContext)
}

func CreateEvaluationRuleRepository(options map[string]interface{}) domain.EvaluationRuleRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationRuleRepository(transactionContext)
}

func CreateEvaluationTemplateRepository(options map[string]interface{}) domain.EvaluationTemplateRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationTemplateRepository(transactionContext)
}

func CreateEvaluationCycleRepository(options map[string]interface{}) domain.EvaluationCycleRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationCycleRepository(transactionContext)
}

func CreateEvaluationCycleTemplateRepository(options map[string]interface{}) domain.EvaluationCycleTemplateRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationCycleTemplateRepository(transactionContext)
}

func CreateEvaluationProjectRepository(options map[string]interface{}) domain.EvaluationProjectRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationProjectRepository(transactionContext)
}

func CreateNodeTaskRepository(options map[string]interface{}) domain.NodeTaskRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewNodeTaskRepository(transactionContext)
}

func CreateStaffAssessRepository(options map[string]interface{}) domain.StaffAssessRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewStaffAssessRepository(transactionContext)
}

func CreateStaffAssessContentRepository(options map[string]interface{}) domain.StaffAssessContentRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewStaffAssessContentRepository(transactionContext)
}

func CreateStaffAssessTaskRepository(options map[string]interface{}) domain.StaffAssessTaskRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewStaffAssessTaskRepository(transactionContext)
}

func CreateStaffAssessCacheRepository(options map[string]interface{}) domain.StaffAssessCacheRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewStaffAssessCacheRepository(transactionContext)
}

func CreateSummaryEvaluationRepository(options map[string]interface{}) domain.SummaryEvaluationRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewSummaryEvaluationRepository(transactionContext)
}

func CreateSummaryEvaluationValueRepository(options map[string]interface{}) domain.SummaryEvaluationValueRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewSummaryEvaluationValueRepository(transactionContext)
}

func CreateEvaluationItemUsedRepository(options map[string]interface{}) domain.EvaluationItemUsedRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewEvaluationItemUsedRepository(transactionContext)
}

func CreatePermissionRepository(options map[string]interface{}) domain.PermissionRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewPermissionRepository(transactionContext)
}

func CreateLogSmsRepository(options map[string]interface{}) domain.LogSmsRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewLogSmsRepository(transactionContext)
}

func CreateMessagePersonalRepository(options map[string]interface{}) domain.MessagePersonalRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewMessagePersonalRepository(transactionContext)
}
func CreateTaskRepository(options map[string]interface{}) domain.TaskRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewTaskRepository(transactionContext)
}

func CreateTaskStageRepository(options map[string]interface{}) domain.TaskStageRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewTaskStageRepository(transactionContext)
}

func CreateTaskIgnoreRepository(options map[string]interface{}) domain.TaskIgnoreRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewTaskIgnoreRepository(transactionContext)
}

func CreateTaskRecordRepository(options map[string]interface{}) domain.TaskRecordRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewTaskRecordRepository(transactionContext)
}

func CreateTaskLevelRepository(options map[string]interface{}) domain.TaskLevelRepository {
	var transactionContext *pg.TransactionContext
	if value, ok := options["transactionContext"]; ok {
		transactionContext = value.(*pg.TransactionContext)
	}
	return repository.NewTaskLevelRepository(transactionContext)
}