package payment

import (
	"context"
	"fmt"

	"go.uber.org/zap"
	"gitea.pena/PenaSide/treasurer/internal/errors"
	"gitea.pena/PenaSide/treasurer/internal/models"
	"gitea.pena/PenaSide/treasurer/internal/models/yandex"
	"gitea.pena/PenaSide/treasurer/internal/utils"
)

type PaymentStrategyService interface {
	CreatePaymentBankCard(ctx context.Context, uuid string, payment *models.CreatePayment[yandex.Receipt]) (*models.CreatePaymentResult, errors.Error)
	CreatePayment(ctx context.Context, uuid string, payment *models.CreatePayment[yandex.Receipt]) (*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) CreatePaymentBankCard(ctx context.Context, request *models.CreatePayment[yandex.Receipt]) (string, errors.Error) {
		receiver.logger.Info("f<CreatePaymentBankCard> of <YandexPaymentService>", zap.Any("Customer", request.Requisites.Customer), zap.Any("Items",request.Requisites.Items))
	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[yandex.Receipt]) (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
}