package subscriber

import (
	coreDomain "github.com/linmadan/egglib-go/core/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain/event"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/log"
)

type MessageServiceSubscriber struct {
	//TransactionContext *pgTransaction.TransactionContext
}

func (subscriber *MessageServiceSubscriber) HandleEvent(domainEvent coreDomain.DomainEvent) error {
	// 消息推送服务
	messageServiceGateway, err := factory.CreateMessageServiceGateway(nil)
	if err != nil {
		log.Logger.Error("消息推送服务初始化", map[string]interface{}{
			"err": err.Error(),
		})
		return nil
	}
	switch domainEvent.EventType() {
	case event.COOPERATION_APPLICATION_AGREED: // 共创申请审核通过
		cooperationApplicationAgreedEvent := domainEvent.(*event.CooperationApplicationAgreed)
		for _, agreedData := range cooperationApplicationAgreedEvent.CooperationApplicationAgreedData {
			data, err1 := messageServiceGateway.AgreeCooperationApplication(
				agreedData.CreationProjectId,
				agreedData.CreationProjectName,
				agreedData.CreationProjectNumber,
				agreedData.UserId,
				agreedData.UserBaseId,
				agreedData.OrgId,
				agreedData.CompanyId,
			)
			if err1 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err1.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}
		break
	case event.CREATION_CONTRACT_INFORM_JOINT: // 共创确认
		creationContractInformJointEvent := domainEvent.(*event.CreationContractInformJoint)
		for _, jointData := range creationContractInformJointEvent.CreationContractInformJointData {
			data, err2 := messageServiceGateway.InformJoinCreationContract(
				jointData.CreationContractId,
				jointData.CreationContractName,
				jointData.CreationContractNumber,
				jointData.CreationProjectId,
				jointData.CreationProjectNumber,
				jointData.CreationProjectName,
				jointData.UserId,
				jointData.UserBaseId,
				jointData.OrgId,
				jointData.CompanyId,
			)
			if err2 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err2.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}
		break
	case event.COOPERATION_APPLICATION_REJECTED: // 共创申请审核拒绝
		cooperationApplicationRejectedEvent := domainEvent.(*event.CooperationApplicationRejected)
		for _, rejectedData := range cooperationApplicationRejectedEvent.CooperationApplicationRejectedData {
			data, err3 := messageServiceGateway.RejectCooperationApplication(
				rejectedData.CreationProjectId,
				rejectedData.CreationProjectName,
				rejectedData.CreationProjectNumber,
				rejectedData.UserId,
				rejectedData.UserBaseId,
				rejectedData.OrgId,
				rejectedData.CompanyId,
			)
			if err3 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err3.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}

		break
	case event.CREDIT_ACCOUNT_PAID: // 账期结算支付
		creditAccountPaidEvent := domainEvent.(*event.CreditAccountPaid)
		for _, paidData := range creditAccountPaidEvent.CreditAccountPaidData {
			data, err4 := messageServiceGateway.PayCreditAccount(
				paidData.CreditAccountOrderNum,
				paidData.SettlementAmount,
				paidData.CreditAccountId,
				paidData.DividendsEstimateId,
				paidData.DividendsEstimateOrderNumber,
				paidData.UserId,
				paidData.UserBaseId,
				paidData.OrgId,
				paidData.CompanyId,
			)
			if err4 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err4.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}

		break
	case event.DIVIDENDS_ESTIMATED: // 账期结算
		dividendsEstimatedEvent := domainEvent.(*event.DividendsEstimated)
		for _, estimatedData := range dividendsEstimatedEvent.DividendsEstimatedData {
			data, err5 := messageServiceGateway.DividendsEstimate(
				estimatedData.CreditAccountOrderNum,
				estimatedData.SettlementAmount,
				estimatedData.CreditAccountId,
				estimatedData.DividendsEstimateId,
				estimatedData.DividendsEstimateOrderNumber,
				estimatedData.UserId,
				estimatedData.UserBaseId,
				estimatedData.OrgId,
				estimatedData.CompanyId,
			)
			if err5 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err5.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}
		break
	case event.DIVIDENDS_INFORM_EXPECTED: // 分红预算
		dividendsInformExpectedEvent := domainEvent.(*event.DividendsInformExpected)
		for _, expectedData := range dividendsInformExpectedEvent.DividendsInformExpectedData {
			data, err6 := messageServiceGateway.InformExpectedDividends(
				expectedData.CreationContractId,
				expectedData.CreationContractName,
				expectedData.CreationContractNumber,
				expectedData.CreationProjectId,
				expectedData.CreationProjectName,
				expectedData.ProductName,
				expectedData.UserId,
				expectedData.UserBaseId,
				expectedData.OrgId,
				expectedData.CompanyId,
				expectedData.DividendsEstimateId,
				expectedData.DividendsAmount,
			)
			if err6 != nil {
				log.Logger.Error("推送消息错误", map[string]interface{}{
					"err": err6.Error(),
				})
				return nil
			} else {
				log.Logger.Info("推送数据返回", data)
			}
		}

		break
	}
	return nil
}

func (subscriber *MessageServiceSubscriber) SubscribedToEventTypes() []string {
	return []string{
		event.COOPERATION_APPLICATION_AGREED,   // 同意共创申请
		event.CREATION_CONTRACT_INFORM_JOINT,   // 确认共创
		event.COOPERATION_APPLICATION_REJECTED, // 拒绝共创申请
		event.CREDIT_ACCOUNT_PAID,              // 账期支付
		event.DIVIDENDS_ESTIMATED,              // 账期结算
		event.DIVIDENDS_INFORM_EXPECTED,        // 分红预算
	}
}