package domain_service

import (
	"fmt"
	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/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
	}
}