package payment

import (
	"context"
	"fmt"

	"go.uber.org/zap"
	"penahub.gitlab.yandexcloud.net/external/treasurer/internal/errors"
	"penahub.gitlab.yandexcloud.net/external/treasurer/internal/models"
	"penahub.gitlab.yandexcloud.net/external/treasurer/internal/utils"
)

type PaymentStrategyService interface {
	CreatePaymentPhone(ctx context.Context, uuid string, payment *models.CreatePayment[string]) (*models.CreatePaymentResult, errors.Error)
	CreatePaymentBankCard(ctx context.Context, uuid string, payment *models.CreatePayment[*models.BankCard]) (*models.CreatePaymentResult, errors.Error)
	CreatePayment(ctx context.Context, uuid string, payment *models.CreatePayment[*any]) (*models.CreatePaymentResult, errors.Error)
	CreatePaymentLogin(ctx context.Context, uuid string, payment *models.CreatePayment[string]) (*models.CreatePaymentResult, errors.Error)
}

type PaymentRepository interface {
	Insert(context.Context, *models.Payment) (*models.Payment, errors.Error)
}

type Deps struct {
	Logger                 *zap.Logger
	PaymentStrategyService PaymentStrategyService
	PaymentRepository      PaymentRepository
}

type Service struct {
	logger                 *zap.Logger
	paymentStrategyService PaymentStrategyService
	paymentRepository      PaymentRepository
}

func New(deps Deps) (*Service, errors.Error) {
	if deps.Logger == nil {
		return nil, errors.NewWithMessage("logger is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	if deps.PaymentStrategyService == nil {
		return nil, errors.NewWithMessage("PaymentStrategyService is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	if deps.PaymentRepository == nil {
		return nil, errors.NewWithMessage("PaymentRepository is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	return &Service{
		logger:                 deps.Logger,
		paymentStrategyService: deps.PaymentStrategyService,
		paymentRepository:      deps.PaymentRepository,
	}, nil
}

func (receiver *Service) CreatePaymentPhone(ctx context.Context, request *models.CreatePayment[string]) (string, errors.Error) {
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		receiver.logger.Error("failed to generate uuid on <CreatePaymentPhone> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := receiver.paymentStrategyService.CreatePaymentPhone(ctx, paymentUUID, request)
	if err != nil {
		receiver.logger.Error("failed to create payment on <CreatePaymentPhone> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := receiver.paymentRepository.Insert(ctx, response.Payment); err != nil {
		receiver.logger.Error("failed to insert payment on <CreatePaymentPhone> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}

func (receiver *Service) CreatePaymentBankCard(ctx context.Context, request *models.CreatePayment[*models.BankCard]) (string, errors.Error) {
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		receiver.logger.Error("failed to generate uuid on <CreatePaymentBankCard> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := receiver.paymentStrategyService.CreatePaymentBankCard(ctx, paymentUUID, request)
	if err != nil {
		receiver.logger.Error("failed to create payment on <CreatePaymentBankCard> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := receiver.paymentRepository.Insert(ctx, response.Payment); err != nil {
		receiver.logger.Error("failed to insert payment on <CreatePaymentBankCard> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}

func (receiver *Service) CreatePayment(ctx context.Context, request *models.CreatePayment[*any]) (string, errors.Error) {
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		receiver.logger.Error("failed to generate uuid on <CreatePayment> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := receiver.paymentStrategyService.CreatePayment(ctx, paymentUUID, request)
	if err != nil {
		receiver.logger.Error("failed to create payment on <CreatePayment> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := receiver.paymentRepository.Insert(ctx, response.Payment); err != nil {
		receiver.logger.Error("failed to insert payment on <CreatePayment> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}

func (receiver *Service) CreatePaymentLogin(ctx context.Context, request *models.CreatePayment[string]) (string, errors.Error) {
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		receiver.logger.Error("failed to generate uuid on <CreatePaymentLogin> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := receiver.paymentStrategyService.CreatePaymentLogin(ctx, paymentUUID, request)
	if err != nil {
		receiver.logger.Error("failed to create payment on <CreatePaymentLogin> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := receiver.paymentRepository.Insert(ctx, response.Payment); err != nil {
		receiver.logger.Error("failed to insert payment on <CreatePaymentLogin> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}

func (receiver *Service) GetAvailablePaymentMethods(_ context.Context) ([]models.PaymentType, errors.Error) {
	return []models.PaymentType{
		models.PaymentTypeBankCard,
		models.PaymentTypeTinkoff,
		models.PaymentTypeQiwi,
		models.PaymentTypeSberPay,
		models.PaymentTypeYoomoney,
		models.PaymentTypeMobile,
		models.PaymentTypeInstallments,
		models.PaymentTypeCash,
		models.PaymentTypeSBP,
		models.PaymentTypeSberB2B,
	}, nil
}