package repository

import (
	"context"

	// "fmt"

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

func convertDBBet(bet dbgen.Bet) domain.Bet {
	return domain.Bet{
		ID:          bet.ID,
		Amount:      domain.Currency(bet.Amount),
		TotalOdds:   bet.TotalOdds,
		Status:      domain.OutcomeStatus(bet.Status),
		FullName:    bet.FullName,
		PhoneNumber: bet.PhoneNumber,
		BranchID: domain.ValidInt64{
			Value: bet.BranchID.Int64,
			Valid: bet.BranchID.Valid,
		},
		UserID: domain.ValidInt64{
			Value: bet.UserID.Int64,
			Valid: bet.UserID.Valid,
		},
		IsShopBet: bet.IsShopBet,
		CashedOut: bet.CashedOut,
		CashoutID: bet.CashoutID,
	}
}

func convertDBBetOutcomes(outcome dbgen.BetOutcome) domain.BetOutcome {
	return domain.BetOutcome{
		ID:           outcome.ID,
		BetID:        outcome.BetID,
		SportID:      outcome.SportID,
		EventID:      outcome.EventID,
		OddID:        outcome.OddID,
		HomeTeamName: outcome.HomeTeamName,
		AwayTeamName: outcome.AwayTeamName,
		MarketID:     outcome.MarketID,
		MarketName:   outcome.MarketName,
		Odd:          outcome.Odd,
		OddName:      outcome.OddName,
		OddHeader:    outcome.OddHeader,
		OddHandicap:  outcome.OddHandicap,
		Status:       domain.OutcomeStatus(outcome.Status),
		Expires:      outcome.Expires.Time,
	}
}

func convertDBBetWithOutcomes(bet dbgen.BetWithOutcome) domain.GetBet {
	var outcomes []domain.BetOutcome = make([]domain.BetOutcome, 0, len(bet.Outcomes))

	for _, outcome := range bet.Outcomes {
		outcomes = append(outcomes, convertDBBetOutcomes(outcome))
	}

	return domain.GetBet{
		ID:          bet.ID,
		Amount:      domain.Currency(bet.Amount),
		TotalOdds:   bet.TotalOdds,
		Status:      domain.OutcomeStatus(bet.Status),
		FullName:    bet.FullName,
		PhoneNumber: bet.PhoneNumber,
		BranchID: domain.ValidInt64{
			Value: bet.BranchID.Int64,
			Valid: bet.BranchID.Valid,
		},
		UserID: domain.ValidInt64{
			Value: bet.UserID.Int64,
			Valid: bet.UserID.Valid,
		},
		IsShopBet: bet.IsShopBet,
		CashedOut: bet.CashedOut,
		CashoutID: bet.CashoutID,
		Outcomes:  outcomes,
	}
}

func convertDBCreateBetOutcome(betOutcome domain.CreateBetOutcome) dbgen.CreateBetOutcomeParams {
	return dbgen.CreateBetOutcomeParams{
		BetID:        betOutcome.BetID,
		EventID:      betOutcome.EventID,
		SportID:      betOutcome.SportID,
		OddID:        betOutcome.OddID,
		HomeTeamName: betOutcome.HomeTeamName,
		AwayTeamName: betOutcome.AwayTeamName,
		MarketID:     betOutcome.MarketID,
		MarketName:   betOutcome.MarketName,
		Odd:          betOutcome.Odd,
		OddName:      betOutcome.OddName,
		OddHeader:    betOutcome.OddHeader,
		OddHandicap:  betOutcome.OddHandicap,
		Expires: pgtype.Timestamp{
			Time:  betOutcome.Expires,
			Valid: true,
		},
	}
}

func convertCreateBet(bet domain.CreateBet) dbgen.CreateBetParams {
	return dbgen.CreateBetParams{
		Amount:      int64(bet.Amount),
		TotalOdds:   bet.TotalOdds,
		Status:      int32(bet.Status),
		FullName:    bet.FullName,
		PhoneNumber: bet.PhoneNumber,
		BranchID: pgtype.Int8{
			Int64: bet.BranchID.Value,
			Valid: bet.BranchID.Valid,
		},
		UserID: pgtype.Int8{
			Int64: bet.UserID.Value,
			Valid: bet.UserID.Valid,
		},
		IsShopBet: bet.IsShopBet,
		CashoutID: bet.CashoutID,
	}
}

func (s *Store) CreateBet(ctx context.Context, bet domain.CreateBet) (domain.Bet, error) {
	newBet, err := s.queries.CreateBet(ctx, convertCreateBet(bet))
	if err != nil {
		return domain.Bet{}, err
	}
	return convertDBBet(newBet), err

}

func (s *Store) CreateBetOutcome(ctx context.Context, outcomes []domain.CreateBetOutcome) (int64, error) {
	var dbParams []dbgen.CreateBetOutcomeParams = make([]dbgen.CreateBetOutcomeParams, 0, len(outcomes))

	for _, outcome := range outcomes {
		dbParams = append(dbParams, convertDBCreateBetOutcome(outcome))
	}
	rows, err := s.queries.CreateBetOutcome(ctx, dbParams)

	if err != nil {
		return rows, err
	}

	return rows, nil
}

func (s *Store) GetBetByID(ctx context.Context, id int64) (domain.GetBet, error) {
	bet, err := s.queries.GetBetByID(ctx, id)

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

	return convertDBBetWithOutcomes(bet), nil
}

func (s *Store) GetBetByCashoutID(ctx context.Context, id string) (domain.GetBet, error) {
	bet, err := s.queries.GetBetByCashoutID(ctx, id)

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

	return convertDBBetWithOutcomes(bet), nil
}

func (s *Store) GetAllBets(ctx context.Context) ([]domain.GetBet, error) {
	bets, err := s.queries.GetAllBets(ctx)
	if err != nil {
		return nil, err
	}

	var result []domain.GetBet = make([]domain.GetBet, 0, len(bets))
	for _, bet := range bets {
		result = append(result, convertDBBetWithOutcomes(bet))
	}

	return result, nil
}

func (s *Store) GetBetByBranchID(ctx context.Context, BranchID int64) ([]domain.GetBet, error) {
	bets, err := s.queries.GetBetByBranchID(ctx, pgtype.Int8{
		Int64: BranchID,
		Valid: true,
	})

	if err != nil {
		return nil, err
	}

	var result []domain.GetBet = make([]domain.GetBet, 0, len(bets))
	for _, bet := range bets {
		result = append(result, convertDBBetWithOutcomes(bet))
	}

	return result, nil
}

func (s *Store) UpdateCashOut(ctx context.Context, id int64, cashedOut bool) error {
	err := s.queries.UpdateCashOut(ctx, dbgen.UpdateCashOutParams{
		ID:        id,
		CashedOut: cashedOut,
	})
	return err
}

func (s *Store) UpdateStatus(ctx context.Context, id int64, status domain.OutcomeStatus) error {
	err := s.queries.UpdateStatus(ctx, dbgen.UpdateStatusParams{
		ID:     id,
		Status: int32(status),
	})
	return err
}

func (s *Store) GetBetOutcomeByEventID(ctx context.Context, eventID int64) ([]domain.BetOutcome, error) {
	outcomes, err := s.queries.GetBetOutcomeByEventID(ctx, eventID)
	if err != nil {
		return nil, nil
	}
	var result []domain.BetOutcome = make([]domain.BetOutcome, 0, len(outcomes))

	for _, outcome := range outcomes {
		result = append(result, convertDBBetOutcomes(outcome))
	}
	return result, nil
}

func (s *Store) GetBetOutcomeByBetID(ctx context.Context, betID int64) ([]domain.BetOutcome, error) {
	outcomes, err := s.queries.GetBetOutcomeByBetID(ctx, betID)
	if err != nil {
		return nil, nil
	}
	var result []domain.BetOutcome = make([]domain.BetOutcome, 0, len(outcomes))

	for _, outcome := range outcomes {
		result = append(result, convertDBBetOutcomes(outcome))
	}
	return result, nil
}
func (s *Store) UpdateBetOutcomeStatus(ctx context.Context, id int64, status domain.OutcomeStatus) (domain.BetOutcome, error) {
	update, err := s.queries.UpdateBetOutcomeStatus(ctx, dbgen.UpdateBetOutcomeStatusParams{
		Status: int32(status),
		ID:     id,
	})
	res := convertDBBetOutcomes(update)
	return res, err
}

func (s *Store) DeleteBet(ctx context.Context, id int64) error {
	return s.queries.DeleteBet(ctx, id)
}