package pg

import (
	"fmt"
	"furtuna-be/internal/entity"
	"furtuna-be/internal/repository/linkqu"
	mdtrns "furtuna-be/internal/repository/midtrans"
)

type PaymentGatewayRepo struct {
	midtransService *mdtrns.ClientService
	linkquService   *linkqu.LinkQuService
}

func NewPaymentGatewayRepo(midtransConfig mdtrns.MidtransConfig, linkquConfig linkqu.LinkQuConfig) *PaymentGatewayRepo {
	return &PaymentGatewayRepo{
		midtransService: mdtrns.New(midtransConfig),
		linkquService:   linkqu.NewLinkQuService(linkquConfig),
	}
}

func (repo *PaymentGatewayRepo) CreatePayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	return repo.createMidtransPayment(request)
}

func (repo *PaymentGatewayRepo) CreateQRISPayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	switch request.Provider {
	case "MIDTRANS":
		return repo.createMidtransQRISPayment(request)
	case "LINKQU":
		return repo.createLinkQuQRISPayment(request)
	default:
		return nil, fmt.Errorf("unsupported payment method for QRIS: %s", request.Provider)
	}
}

func (repo *PaymentGatewayRepo) CreatePaymentVA(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	resp, err := repo.linkquService.CreatePaymentVA(entity.LinkQuRequest{
		TotalAmount:        request.TotalAmount,
		PaymentReferenceID: request.PaymentReferenceID,
		CustomerID:         request.CustomerID,
		CustomerName:       request.CustomerName,
		CustomerEmail:      request.CustomerEmail,
		BankCode:           request.BankCode,
	})

	if err != nil {
		return nil, err
	}

	return &entity.PaymentResponse{
		VirtualAccountNumber: resp.VirtualAccount,
		BankName:             resp.BankName,
		BankCode:             resp.BankCode,
	}, nil
}

func (repo *PaymentGatewayRepo) createMidtransPayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	midtransReq := entity.MidtransRequest{
		PaymentReferenceID: request.PaymentReferenceID,
		PaymentMethod:      request.Provider,
		TotalAmount:        request.TotalAmount,
	}

	resp, err := repo.midtransService.CreatePayment(midtransReq)
	if err != nil {
		return nil, err
	}

	return &entity.PaymentResponse{
		Token:       resp.Token,
		RedirectURL: resp.RedirectURL,
	}, nil
}

func (repo *PaymentGatewayRepo) createLinkQuPayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	linkquReq := entity.LinkQuRequest{
		PaymentReferenceID: request.PaymentReferenceID,
		TotalAmount:        request.TotalAmount,
		CustomerID:         request.CustomerID,
		CustomerName:       request.CustomerName,
		CustomerPhone:      request.CustomerPhone,
		CustomerEmail:      request.CustomerEmail,
	}

	resp, err := repo.linkquService.CreateQrisPayment(linkquReq)
	if err != nil {
		return nil, err
	}

	return &entity.PaymentResponse{
		Token:       resp.PartnerReff2,
		RedirectURL: resp.ImageQRIS,
	}, nil
}

func (repo *PaymentGatewayRepo) createMidtransQRISPayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	midtransReq := entity.MidtransRequest{
		PaymentReferenceID: request.PaymentReferenceID,
		PaymentMethod:      "QRIS",
		TotalAmount:        request.TotalAmount,
	}

	resp, err := repo.midtransService.CreateQrisPayment(midtransReq)
	if err != nil {
		return nil, err
	}

	return &entity.PaymentResponse{
		QRCodeURL: resp.QrCodeUrl,
		OrderID:   resp.OrderID,
		Amount:    resp.Amount,
	}, nil
}

func (repo *PaymentGatewayRepo) createLinkQuQRISPayment(request entity.PaymentRequest) (*entity.PaymentResponse, error) {
	linkquReq := entity.LinkQuRequest{
		PaymentReferenceID: request.PaymentReferenceID,
		TotalAmount:        request.TotalAmount,
		CustomerID:         request.CustomerID,
		CustomerName:       request.CustomerName,
		CustomerPhone:      request.CustomerPhone,
		CustomerEmail:      request.CustomerEmail,
	}

	resp, err := repo.linkquService.CreateQrisPayment(linkquReq)
	if err != nil {
		return nil, err
	}

	return &entity.PaymentResponse{
		QRCodeURL: resp.ImageQRIS,
		OrderID:   resp.PartnerReff,
		Amount:    resp.Amount,
	}, nil
}