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 raffle store
func NewRaffleStore(s *Store) ports.RaffleStore { return s }

func (s *Store) CreateRaffle(ctx context.Context, raffle domain.CreateRaffle) (domain.Raffle, error) {
	raffleRes, err := s.queries.CreateRaffle(ctx, domain.ConvertCreateRaffle(raffle))
	if err != nil {
		return domain.Raffle{}, err
	}

	return domain.ConvertRaffleOutcome(raffleRes), nil
}

func (s *Store) DeleteRaffle(ctx context.Context, raffleID int32) (domain.Raffle, error) {
	raffleRes, err := s.queries.DeleteRaffle(ctx, raffleID)
	if err != nil {
		return domain.Raffle{}, err
	}

	return domain.ConvertRaffleOutcome(raffleRes), nil
}

func (s *Store) GetRafflesOfCompany(ctx context.Context, companyID int32) ([]dbgen.Raffle, error) {
	raffles, err := s.queries.GetRafflesOfCompany(ctx, companyID)
	if err != nil {
		return nil, err
	}

	return raffles, nil
}

func (s *Store) CreateRaffleTicket(ctx context.Context, raffleTicketParams domain.CreateRaffleTicket) (domain.RaffleTicket, error) {
	raffleTicket, err := s.queries.CreateRaffleTicket(ctx, dbgen.CreateRaffleTicketParams{
		RaffleID: raffleTicketParams.RaffleID,
		UserID:   raffleTicketParams.UserID,
	})
	if err != nil {
		return domain.RaffleTicket{}, err
	}

	return domain.ConvertRaffleTicketOutcome(raffleTicket), nil
}

func (s *Store) GetUserRaffleTickets(ctx context.Context, userID int32) ([]domain.RaffleTicketRes, error) {
	raffleTickets, err := s.queries.GetUserRaffleTickets(ctx, userID)
	if err != nil {
		return nil, err
	}

	res := []domain.RaffleTicketRes{}
	for _, raffle := range raffleTickets {
		res = append(res, domain.ConvertJoinedRaffleTicketOutcome(raffle))
	}

	return res, nil
}

func (s *Store) SuspendRaffleTicket(ctx context.Context, raffleTicketID int32) error {
	return s.queries.UpdateRaffleTicketStatus(ctx, dbgen.UpdateRaffleTicketStatusParams{
		ID: raffleTicketID,
		IsActive: pgtype.Bool{
			Bool:  false,
			Valid: true,
		},
	})
}

func (s *Store) UnSuspendRaffleTicket(ctx context.Context, raffleID int32) error {
	return s.queries.UpdateRaffleTicketStatus(ctx, dbgen.UpdateRaffleTicketStatusParams{
		ID: raffleID,
		IsActive: pgtype.Bool{
			Bool:  true,
			Valid: true,
		},
	})
}

// TODO: could also add -> suspend a specific user's raffle tickets

func (s *Store) GetRaffleStanding(ctx context.Context, raffleID, limit int32) ([]domain.RaffleStanding, error) {
	raffleStanding, err := s.queries.GetRaffleStanding(ctx, dbgen.GetRaffleStandingParams{
		RaffleID: raffleID,
		Limit:    limit,
	})
	if err != nil {
		return nil, err
	}

	res := []domain.RaffleStanding{}
	for _, standing := range raffleStanding {
		res = append(res, domain.ConvertRaffleStanding(standing))
	}

	return res, nil
}

func (s *Store) CreateRaffleWinner(ctx context.Context, raffleWinnerParams domain.RaffleWinnerParams) error {
	_, err := s.queries.CreateRaffleWinner(ctx, dbgen.CreateRaffleWinnerParams{
		RaffleID: raffleWinnerParams.RaffleID,
		UserID:   raffleWinnerParams.UserID,
		Rank:     raffleWinnerParams.Rank,
	})

	return err
}

func (s *Store) SetRaffleComplete(ctx context.Context, raffleID int32) error {
	return s.queries.SetRaffleComplete(ctx, raffleID)
}

func (s *Store) AddSportRaffleFilter(ctx context.Context, raffleID int32, sportID, leagueID int64) error {
	_, err := s.queries.AddSportRaffleFilter(ctx, dbgen.AddSportRaffleFilterParams{
		RaffleID: raffleID,
		SportID:  sportID,
		LeagueID: leagueID,
	})
	return err
}

func (s *Store) CheckValidSportRaffleFilter(ctx context.Context, raffleID int32, sportID, leagueID int64) (bool, error) {
	res, err := s.queries.CheckValidSportRaffleFilter(ctx, dbgen.CheckValidSportRaffleFilterParams{
		RaffleID: raffleID,
		SportID:  sportID,
		LeagueID: leagueID,
	})
	if err != nil {
		return false, err
	}

	return res, nil
}

func (s *Store) GetRaffleTicketLimit(ctx context.Context, raffleID int32) (int32, error) {
	return s.queries.GetRaffleTicketLimit(ctx, raffleID)
}

func (s *Store) GetRaffleTicketCount(ctx context.Context, raffleID, userID int32) (int64, error) {
	return s.queries.GetRaffleTicketCount(ctx, dbgen.GetRaffleTicketCountParams{
		RaffleID: raffleID,
		UserID:   userID,
	})
}

func (s *Store) CheckSportRaffleHasFilter(ctx context.Context, raffleID int32) (bool, error) {
	return s.queries.CheckSportRaffleHasFilter(ctx, raffleID)
}