package payment

import (
	"context"
	"log"

	"go.uber.org/zap"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/errors"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/models"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/proto/treasurer"
)

type paymentClient interface {
	GetPaymentLinkBankCard(ctx context.Context, request *treasurer.GetBankCardPaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkYooMoney(ctx context.Context, request *treasurer.GetPaymentLinkBody) (string, errors.Error)
	GetPaymentLinkQIWI(ctx context.Context, request *treasurer.GetPhonePaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkSberPay(ctx context.Context, request *treasurer.GetPhonePaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkAlfaClick(ctx context.Context, request *treasurer.GetLoginPaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkTinkoff(ctx context.Context, request *treasurer.GetPaymentLinkBody) (string, errors.Error)
	GetPaymentLinkSberbankB2B(ctx context.Context, request *treasurer.GetB2BPaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkMobile(ctx context.Context, request *treasurer.GetPhonePaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkCash(ctx context.Context, request *treasurer.GetPhonePaymentLinkRequest) (string, errors.Error)
	GetPaymentLinkInstallments(ctx context.Context, request *treasurer.GetPaymentLinkBody) (string, errors.Error)
}

type authClient interface {
	GetUser(ctx context.Context, userID string) (*models.User, errors.Error)
}

type Deps struct {
	Logger            *zap.Logger
	ConfigurationGRPC *models.ConfigurationGRPC
	PaymentClient     paymentClient
	AuthClient        authClient
}

type Service struct {
	logger            *zap.Logger
	configurationGRPC *models.ConfigurationGRPC
	paymentClient     paymentClient
	authClient        authClient
}

func New(deps Deps) *Service {
	if deps.Logger == nil {
		log.Panicln("logger is nil on <New (payment service)>")
	}

	if deps.ConfigurationGRPC == nil {
		log.Panicln("ConfigurationGRPC is nil on <New (payment service)>")
	}

	if deps.PaymentClient == nil {
		log.Panicln("PaymentClient is nil on <New (payment service)>")
	}

	if deps.AuthClient == nil {
		log.Panicln("AuthClient is nil on <New (payment service)>")
	}

	return &Service{
		logger:        deps.Logger,
		paymentClient: deps.PaymentClient,
		authClient:    deps.AuthClient,
	}
}

func (receiver *Service) GetPaymentLink(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	if _, userErr := receiver.authClient.GetUser(ctx, request.UserID); userErr != nil {
		receiver.logger.Error("failed to get user on <GetPaymentLink> on <PaymentService>",
			zap.Error(userErr),
			zap.String("userID", request.UserID),
		)

		return "", userErr
	}

	switch request.Body.Type {
	case models.PaymentTypeBankCard:
		return receiver.GetPaymentLinkBankCard(ctx, request)
	case models.PaymentTypeYoomoney:
		return receiver.GetPaymentLinkYooMoney(ctx, request)
	case models.PaymentTypeQiwi:
		return receiver.GetPaymentLinkQIWI(ctx, request)
	case models.PaymentTypeSberPay:
		return receiver.GetPaymentLinkSberPay(ctx, request)
	case models.PaymentTypeAlfabank:
		return receiver.GetPaymentLinkAlfaClick(ctx, request)
	case models.PaymentTypeTinkoff:
		return receiver.GetPaymentLinkTinkoff(ctx, request)
	case models.PaymentTypeMobile:
		return receiver.GetPaymentLinkMobile(ctx, request)
	case models.PaymentTypeCash:
		return receiver.GetPaymentLinkCash(ctx, request)
	}

	return "", errors.NewWithMessage("invalid payment method type", errors.ErrInvalidArgs)
}

func (receiver *Service) GetPaymentLinkBankCard(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkBankCard(ctx, &treasurer.GetBankCardPaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		BankCard: &treasurer.BankCardInformation{
			Number:      request.Body.BankCard.Number,
			ExpiryYear:  request.Body.BankCard.ExpiryYear,
			ExpiryMonth: request.Body.BankCard.ExpiryMonth,
		},
	})
	if err != nil {
		receiver.logger.Error("failed to get bankcard payment link on <GetPaymentLinkBankCard> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkYooMoney(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkYooMoney(ctx, &treasurer.GetPaymentLinkBody{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
	})
	if err != nil {
		receiver.logger.Error("failed to get yoomoney payment link on <GetPaymentLinkYooMoney> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkQIWI(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkQIWI(ctx, &treasurer.GetPhonePaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		Phone: request.Body.PhoneNumber,
	})
	if err != nil {
		receiver.logger.Error("failed to get qiwi payment link on <GetPaymentLinkQIWI> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkSberPay(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkSberPay(ctx, &treasurer.GetPhonePaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		Phone: request.Body.PhoneNumber,
	})
	if err != nil {
		receiver.logger.Error("failed to get sberpay payment link on <GetPaymentLinkSberPay> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkAlfaClick(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkAlfaClick(ctx, &treasurer.GetLoginPaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		Login: request.Body.Login,
	})
	if err != nil {
		receiver.logger.Error("failed to get alfaclick payment link on <GetPaymentLinkAlfaClick> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkTinkoff(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkTinkoff(ctx, &treasurer.GetPaymentLinkBody{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
	})
	if err != nil {
		receiver.logger.Error("failed to get tinkoff payment link on <GetPaymentLinkTinkoff> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkMobile(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkMobile(ctx, &treasurer.GetPhonePaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		Phone: request.Body.PhoneNumber,
	})
	if err != nil {
		receiver.logger.Error("failed to get mobile payment link on <GetPaymentLinkMobile> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}

func (receiver *Service) GetPaymentLinkCash(ctx context.Context, request *models.GetPaymentLinkRequest) (string, errors.Error) {
	link, err := receiver.paymentClient.GetPaymentLinkCash(ctx, &treasurer.GetPhonePaymentLinkRequest{
		MainSettings: &treasurer.MainPaymentSettings{
			Currency:         request.Body.Currency,
			Amount:           request.Body.Amount,
			UserID:           request.UserID,
			ClientIP:         request.ClientIP,
			CallbackHostGRPC: []string{receiver.configurationGRPC.Domen},

			// TODO: добавить
			ReturnURL: "",
		},
		Phone: request.Body.PhoneNumber,
	})
	if err != nil {
		receiver.logger.Error("failed to get cash payment link on <GetPaymentLinkCash> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return link, nil
}