package repository

import (
	"context"

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

// Interface for creating new transfer store
func NewTransferStore(s *Store) ports.TransferStore { return s }

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

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

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

func (s *Store) GetTransfersByWallet(ctx context.Context, walletID int64) ([]domain.TransferDetail, error) {
	transfers, err := s.queries.GetTransfersByWallet(ctx, pgtype.Int8{Int64: walletID, Valid: true})
	if err != nil {
		return nil, err
	}

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

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

func (s *Store) GetTransferByReference(ctx context.Context, reference string) (domain.TransferDetail, error) {
	transfer, err := s.queries.GetTransferByReference(ctx, reference)
	if err != nil {
		return domain.TransferDetail{}, nil
	}
	return domain.ConvertDBTransferDetail(transfer), nil
}

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

func (s *Store) GetTransferStats(ctx context.Context, walletID int64) (domain.TransferStats, error) {
	stats, err := s.queries.GetTransferStats(ctx, pgtype.Int8{
		Int64: walletID,
		Valid: true,
	})

	if err != nil {
		return domain.TransferStats{}, err
	}

	return domain.TransferStats{
		TotalTransfer:       stats.TotalTransfers,
		TotalDeposits:       stats.TotalDeposits,
		TotalWithdraws:      stats.TotalWithdraw,
		TotalWalletToWallet: stats.TotalWalletToWallet,
	}, nil
}

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

	return err
}

func (s *Store) UpdateTransferStatus(ctx context.Context, id int64, status string) error {
	err := s.queries.UpdateTransferStatus(ctx, dbgen.UpdateTransferStatusParams{
		ID:     id,
		Status: pgtype.Text{String: status, Valid: true},
	})

	return err
}

func ApproveTransfer(ctx context.Context, approval domain.ApprovalRequest) error {
	return nil
}