package repository

import (
	"context"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
)

func convertDBTransaction(transaction dbgen.Transaction) domain.Transaction {
	return domain.Transaction{
		ID:       transaction.ID,
		Amount:   domain.Currency(transaction.Amount),
		Type:     domain.TransactionType(transaction.TransactionType),
		Verified: transaction.Verified,
		WalletID: transaction.WalletID,
	}
}

func convertCreateTransaction(transaction domain.CreateTransaction) dbgen.CreateTransactionParams {
	return dbgen.CreateTransactionParams{
		Amount:          int64(transaction.Amount),
		TransactionType: string(transaction.Type),
		WalletID:        transaction.WalletID,
	}
}

func (s *Store) CreateTransaction(ctx context.Context, transaction domain.CreateTransaction) (domain.Transaction, error) {
	newTransaction, err := s.queries.CreateTransaction(ctx, convertCreateTransaction(transaction))
	if err != nil {
		return domain.Transaction{}, err
	}
	return convertDBTransaction(newTransaction), nil
}

func (s *Store) GetAllTransactions(ctx context.Context) ([]domain.Transaction, error) {
	transactions, err := s.queries.GetAllTransactions(ctx)
	if err != nil {
		return nil, err
	}
	var result []domain.Transaction
	for _, transaction := range transactions {
		result = append(result, convertDBTransaction(transaction))
	}
	return result, nil
}
func (s *Store) GetTransactionsByWallet(ctx context.Context, walletID int64) ([]domain.Transaction, error) {
	transactions, err := s.queries.GetTransactionsByWallet(ctx, walletID)
	if err != nil {
		return nil, err
	}

	var result []domain.Transaction
	for _, transaction := range transactions {
		result = append(result, convertDBTransaction(transaction))
	}
	return result, nil
}


func (s *Store) GetTransactionByID(ctx context.Context, id int64) (domain.Transaction, error){
	transaction, err := s.queries.GetTransactionByID(ctx, id);
	if err != nil {
		return domain.Transaction{}, nil
	}
	return convertDBTransaction(transaction), 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
}