package repository

import (
	"context"
	"math/big"
	"time"

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

func convertDBDirectDeposit(deposit dbgen.DirectDeposit) domain.DirectDeposit {
	return domain.DirectDeposit{
		ID:                deposit.ID,
		CustomerID:        deposit.CustomerID,
		WalletID:          deposit.WalletID,
		Amount:            domain.Currency(deposit.Amount.Int.Int64()),
		BankReference:     deposit.BankReference,
		SenderAccount:     deposit.SenderAccount,
		Status:            domain.DirectDepositStatus(deposit.Status),
		CreatedAt:         deposit.CreatedAt.Time,
		VerifiedBy:        convertPgInt64ToPtr(deposit.VerifiedBy),
		VerificationNotes: deposit.VerificationNotes.String,
		VerifiedAt:        convertPgTimeToPtr(deposit.VerifiedAt),
	}
}

func convertCreateDirectDeposit(deposit domain.CreateDirectDeposit) dbgen.CreateDirectDepositParams {
	return dbgen.CreateDirectDepositParams{
		CustomerID:    deposit.CustomerID,
		WalletID:      deposit.WalletID,
		Amount:        pgtype.Numeric{Int: big.NewInt(int64(deposit.Amount)), Valid: true},
		BankReference: deposit.BankReference,
		SenderAccount: deposit.SenderAccount,
		Status:        string(deposit.Status),
	}
}

func convertUpdateDirectDeposit(deposit domain.UpdateDirectDeposit) dbgen.UpdateDirectDepositParams {
	return dbgen.UpdateDirectDepositParams{
		ID:                deposit.ID,
		Status:            string(deposit.Status),
		VerifiedBy:        pgtype.Int8{Int64: deposit.VerifiedBy, Valid: true},
		VerificationNotes: pgtype.Text{String: deposit.VerificationNotes, Valid: deposit.VerificationNotes != ""},
		VerifiedAt:        pgtype.Timestamp{Time: deposit.VerifiedAt, Valid: true},
	}
}

func convertPgInt64ToPtr(i pgtype.Int8) *int64 {
	if i.Valid {
		return &i.Int64
	}
	return nil
}

func convertPgTimeToPtr(t pgtype.Timestamp) *time.Time {
	if t.Valid {
		return &t.Time
	}
	return nil
}

func (s *Store) CreateDirectDeposit(ctx context.Context, deposit domain.CreateDirectDeposit) (domain.DirectDeposit, error) {
	newDeposit, err := s.queries.CreateDirectDeposit(ctx, convertCreateDirectDeposit(deposit))
	if err != nil {
		return domain.DirectDeposit{}, err
	}
	return convertDBDirectDeposit(newDeposit), nil
}

func (s *Store) GetDirectDeposit(ctx context.Context, id int64) (domain.DirectDeposit, error) {
	deposit, err := s.queries.GetDirectDeposit(ctx, id)
	if err != nil {
		return domain.DirectDeposit{}, err
	}
	return convertDBDirectDeposit(deposit), nil
}

func (s *Store) UpdateDirectDeposit(ctx context.Context, deposit domain.UpdateDirectDeposit) (domain.DirectDeposit, error) {
	updatedDeposit, err := s.queries.UpdateDirectDeposit(ctx, convertUpdateDirectDeposit(deposit))
	if err != nil {
		return domain.DirectDeposit{}, err
	}
	return convertDBDirectDeposit(updatedDeposit), nil
}

func (s *Store) GetDirectDepositsByStatus(ctx context.Context, status domain.DirectDepositStatus) ([]domain.DirectDeposit, error) {
	deposits, err := s.queries.GetDirectDepositsByStatus(ctx, string(status))
	if err != nil {
		return nil, err
	}

	result := make([]domain.DirectDeposit, 0, len(deposits))
	for _, deposit := range deposits {
		result = append(result, convertDBDirectDeposit(deposit))
	}
	return result, nil
}

func (s *Store) GetCustomerDirectDeposits(ctx context.Context, customerID int64) ([]domain.DirectDeposit, error) {
	deposits, err := s.queries.GetCustomerDirectDeposits(ctx, customerID)
	if err != nil {
		return nil, err
	}

	result := make([]domain.DirectDeposit, 0, len(deposits))
	for _, deposit := range deposits {
		result = append(result, convertDBDirectDeposit(deposit))
	}
	return result, nil
}