package repository

import (
	"context"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/jackc/pgx/v5/pgtype"
)

func convertDBTransfer(transfer dbgen.WalletTransfer) domain.Transfer {
	return domain.Transfer{
		ID:               transfer.ID,
		Amount:           domain.Currency(transfer.Amount),
		Type:             domain.TransferType(transfer.Type),
		Verified:         transfer.Verified,
		ReceiverWalletID: transfer.ReceiverWalletID,
		SenderWalletID: domain.ValidInt64{
			Value: transfer.SenderWalletID.Int64,
			Valid: transfer.SenderWalletID.Valid,
		},
		CashierID: domain.ValidInt64{
			Value: transfer.CashierID.Int64,
			Valid: transfer.CashierID.Valid,
		},
		PaymentMethod: domain.PaymentMethod(transfer.PaymentMethod),
	}
}

func convertCreateTransfer(transfer domain.CreateTransfer) dbgen.CreateTransferParams {
	return dbgen.CreateTransferParams{
		Amount:           int64(transfer.Amount),
		Type:             string(transfer.Type),
		ReceiverWalletID: transfer.ReceiverWalletID,
		SenderWalletID: pgtype.Int8{
			Int64: transfer.SenderWalletID.Value,
			Valid: transfer.SenderWalletID.Valid,
		},
		CashierID: pgtype.Int8{
			Int64: transfer.CashierID.Value,
			Valid: transfer.CashierID.Valid,
		},
		PaymentMethod: string(transfer.PaymentMethod),
	}
}

func (s *Store) CreateTransfer(ctx context.Context, transfer domain.CreateTransfer) (domain.Transfer, error) {
	newTransfer, err := s.queries.CreateTransfer(ctx, convertCreateTransfer(transfer))
	if err != nil {
		return domain.Transfer{}, err
	}
	return convertDBTransfer(newTransfer), nil
}

func (s *Store) GetAllTransfers(ctx context.Context) ([]domain.Transfer, error) {
	transfers, err := s.queries.GetAllTransfers(ctx)
	if err != nil {
		return nil, err
	}
	var result []domain.Transfer = make([]domain.Transfer, len(transfers))

	for _, transfer := range transfers {
		result = append(result, convertDBTransfer(transfer))
	}
	return result, nil
}
func (s *Store) GetTransfersByWallet(ctx context.Context, walletID int64) ([]domain.Transfer, error) {
	transfers, err := s.queries.GetTransfersByWallet(ctx, walletID)
	if err != nil {
		return nil, err
	}

	var result []domain.Transfer = make([]domain.Transfer, len(transfers))

	for _, transfer := range transfers {
		result = append(result, convertDBTransfer(transfer))
	}
	return result, nil
}

func (s *Store) GetTransferByID(ctx context.Context, id int64) (domain.Transfer, error) {
	transfer, err := s.queries.GetTransferByID(ctx, id)
	if err != nil {
		return domain.Transfer{}, nil
	}
	return convertDBTransfer(transfer), nil
}

func (s *Store) UpdateTransferVerification(ctx context.Context, id int64, verified bool) error {
	err := s.queries.UpdateTransferVerification(ctx, dbgen.UpdateTransferVerificationParams{
		ID:       id,
		Verified: verified,
	})

	return err
}