package domain_service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	coreDomain "github.com/linmadan/egglib-go/core/domain"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/factory"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/repository"
	"time"
)

type CashPoolService struct {
	coreDomain.BaseEventPublisher
	transactionContext *pgTransaction.TransactionContext
}

func (service *CashPoolService) Input(companyId int64, operatorUid int64, cash float64) (*domain.CashPool, error) {
	var cashPoolRepository domain.CashPoolRepository
	var employeeRepository domain.EmployeeRepository

	if repository, err := repository.NewEmployeeRepository(service.transactionContext); err != nil {
		return nil, err
	} else {
		employeeRepository = repository
	}

	transactionContext, err := factory.CreateTransactionContext(nil)

	var employeeDao *dao.EmployeeDao
	if value, err := factory.CreateEmployeeDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		employeeDao = value
	}

	var systemExchangedCash float64
	if value, err := employeeDao.CalculateSystemCash(companyId); err != nil  {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		systemExchangedCash = value
	}

	var (
		systemChangedSuMoney float64
		systemUnChangeSuMoney float64
	)
	if value1, value2, err := employeeDao.CalculateSystemSuMoney(companyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		systemChangedSuMoney = value1
		systemUnChangeSuMoney = value2
	}

	operator, err := employeeRepository.FindOne(map[string]interface{}{
		"uid": operatorUid,
	})
	if err != nil {
		return nil, err
	}
	if operator == nil {
		return nil, fmt.Errorf("无效的操作者")
	}

	currentCashPool, err := cashPoolRepository.FindOne(map[string]interface{}{
		"companyId": companyId,
	})
	if err != nil {
		return nil, err
	}
	if currentCashPool.ExchangedCash > cash {
		return nil, fmt.Errorf("当前投入现金少于系统已兑换现金值")
	}

	cashPoolInfo := &domain.CashPool{
		CompanyId: companyId,
		Cash: cash,
		ExchangedCash: systemExchangedCash,
		UnExchangeCash: currentCashPool.UnExchangeCash + cash,
		ExchangedSuMoney: systemChangedSuMoney,
		UnExchangeSuMoney: systemUnChangeSuMoney,
		Rate: systemExchangedCash / systemChangedSuMoney,
		Operator: operator.EmployeeInfo,
		CreateTime: time.Now(),
	}

	if cashPool, err := cashPoolRepository.Save(cashPoolInfo); err != nil {
		return nil, err
	} else {
		return cashPool, nil
	}
}

func NewCashPoolService(transactionContext *pgTransaction.TransactionContext) (*CashPoolService, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &CashPoolService{
			transactionContext: transactionContext,
		}, nil
	}
}