package initialize

import (
	"gitea.pena/PenaSide/treasurer/internal/errors"
	"gitea.pena/PenaSide/treasurer/internal/payment_provider"
	"gitea.pena/PenaSide/treasurer/internal/payment_provider/alchemy"
	"gitea.pena/PenaSide/treasurer/internal/payment_provider/yoomoney"
	"gitea.pena/PenaSide/treasurer/internal/service/callback"
	"gitea.pena/PenaSide/treasurer/internal/service/mock"
	"gitea.pena/PenaSide/treasurer/internal/service/payment"
	"gitea.pena/PenaSide/treasurer/internal/service/status"
	"go.uber.org/zap"
)

type ServicesDeps struct {
	Logger       *zap.Logger
	Repositories Repositories
	Clients      Clients
	Config       Config
}

type Services struct {
	Callback      *callback.Service
	Payment       *payment.Service
	YandexPayment *payment.Yandex
	Status        *status.Service
	//YandexWebhook    *webhook.Yandex
	Mock             *mock.Service
	PaymentProviders []payment_provider.PaymentProvider
}

func NewServices(deps ServicesDeps) (*Services, errors.Error) {
	callbackService, err := callback.New(callback.Deps{
		Logger:            deps.Logger,
		CallbackClient:    deps.Clients.Callback,
		PaymentRepository: deps.Repositories.Payment,
	})
	if err != nil {
		return nil, err
	}

	yandexPaymentService, err := payment.NewYandex(payment.YandexPaymentServiceDeps{
		Logger:              deps.Logger,
		YandexPaymentClient: deps.Clients.Yandex,
	})
	if err != nil {
		return nil, err
	}

	paymentService, err := payment.New(payment.Deps{
		Logger:                 deps.Logger,
		PaymentRepository:      deps.Repositories.Payment,
		PaymentStrategyService: yandexPaymentService,
	})
	if err != nil {
		return nil, err
	}

	statusService, err := status.New(status.Deps{
		Logger:            deps.Logger,
		PaymentRepository: deps.Repositories.Payment,
	})
	if err != nil {
		return nil, err
	}

	// todo не используется
	//yandexWebhookService, err := webhook.NewYandex(webhook.YandexDeps{
	//	Logger:              deps.Logger,
	//	YandexWebhookClient: deps.Clients.Yandex,
	//	HttpDomain:          deps.Config.HttpDomain,
	//})
	//if err != nil {
	//	return nil, err
	//}

	yoomoneyMockService, err := mock.NewYoomoneyMockService(mock.YoomoneyMockServiceDeps{
		Logger:              deps.Logger,
		YooMoneyPaymentsURL: deps.Config.YooMoneyPaymentsURL,
	})
	if err != nil {
		return nil, err
	}

	mockService, err := mock.New(mock.Deps{
		Logger:              deps.Logger,
		Enabled:             deps.Config.IsMock,
		MockServiceHost:     deps.Config.MockServiceHost,
		YoomoneyMockService: yoomoneyMockService,
	})
	if err != nil {
		return nil, err
	}

	yooMoneyProvider, err := yoomoney.New(yoomoney.Deps{
		Logger: deps.Logger,
		Config: &yoomoney.Config{
			StoreID:     deps.Config.YooMoneyStoreID,
			SecretKey:   deps.Config.YooMoneySecretKey,
			WebhooksURL: deps.Config.YooMoneyWebhooksURL,
			PaymentsURL: deps.Config.YooMoneyPaymentsURL,
		},
		Repository:              deps.Repositories.Payment,
		CallbackService:         callbackService,
		PaymentMethodRepository: deps.Repositories.PaymentMethod,
	})
	if err != nil {
		return nil, err
	}

	alchemyProvider := alchemy.New(alchemy.Deps{
		Repository: deps.Repositories.Payment,
		Logger:     deps.Logger,
		Config: &alchemy.Config{
			WalletAddress: deps.Config.AlchemyWalletAddress,
		},
	})

	return &Services{
		Callback:      callbackService,
		Payment:       paymentService,
		YandexPayment: yandexPaymentService,
		Status:        statusService,
		//YandexWebhook:    yandexWebhookService,
		Mock:             mockService,
		PaymentProviders: []payment_provider.PaymentProvider{yooMoneyProvider, alchemyProvider},
	}, nil
}