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 (s *Store) CreateEnetpulseSport(ctx context.Context, sport domain.CreateEnetpulseSport) (domain.EnetpulseSport, error) {
	// Convert domain model to DB model if needed
	dbSport, err := s.queries.CreateEnetpulseSport(ctx, ConvertCreateEnetpulseSport(sport))
	if err != nil {
		return domain.EnetpulseSport{}, err
	}
	return ConvertDBEnetpulseSport(dbSport), nil
}

// Fetch all sports
func (s *Store) GetAllEnetpulseSports(ctx context.Context) ([]domain.EnetpulseSport, error) {
	dbSports, err := s.queries.GetAllEnetpulseSports(ctx)
	if err != nil {
		return nil, err
	}

	var sports []domain.EnetpulseSport
	for _, dbSport := range dbSports {
		sports = append(sports, ConvertDBEnetpulseSport(dbSport))
	}

	return sports, nil
}

func (s *Store) CreateEnetpulseTournamentTemplate(
	ctx context.Context,
	template domain.CreateEnetpulseTournamentTemplate,
) (domain.EnetpulseTournamentTemplate, error) {
	// Convert domain model to DB model if needed
	dbTemplate, err := s.queries.CreateEnetpulseTournamentTemplate(
		ctx,
		ConvertCreateEnetpulseTournamentTemplate(template),
	)
	if err != nil {
		return domain.EnetpulseTournamentTemplate{}, err
	}
	return ConvertDBEnetpulseTournamentTemplate(dbTemplate), nil
}

// Fetch all tournament templates
func (s *Store) GetAllEnetpulseTournamentTemplates(ctx context.Context) ([]domain.EnetpulseTournamentTemplate, error) {
	dbTemplates, err := s.queries.GetAllEnetpulseTournamentTemplates(ctx)
	if err != nil {
		return nil, err
	}

	var templates []domain.EnetpulseTournamentTemplate
	for _, dbTemplate := range dbTemplates {
		templates = append(templates, ConvertDBEnetpulseTournamentTemplate(dbTemplate))
	}

	return templates, nil
}

func ConvertCreateEnetpulseSport(s domain.CreateEnetpulseSport) dbgen.CreateEnetpulseSportParams {
	return dbgen.CreateEnetpulseSportParams{
		SportID:       s.SportID,
		Name:          s.Name,
		UpdatesCount:  pgtype.Int4{Int32: int32(s.UpdatesCount), Valid: true}, // SQLC might use int32
		LastUpdatedAt: pgtype.Timestamptz{Time: s.LastUpdatedAt, Valid: true},
		Status:        pgtype.Int4{Int32: int32(s.Status), Valid: true},
		// UpdatedAt:     nil, // SQLC will default NOW() if nil
	}
}

func ConvertDBEnetpulseSport(db dbgen.EnetpulseSport) domain.EnetpulseSport {
	return domain.EnetpulseSport{
		ID:      db.ID,
		SportID: db.SportID,
		Name:    db.Name,
		UpdatesCount: func() int {
			if db.UpdatesCount.Valid {
				return int(db.UpdatesCount.Int32)
			}
			return 0 // or another default value if needed
		}(), // cast from int32
		LastUpdatedAt: db.LastUpdatedAt.Time,
		Status: func() int {
			if db.Status.Valid {
				return int(db.Status.Int32)
			}
			return 0 // or another default value if needed
		}(), // cast from int32
		CreatedAt: db.CreatedAt.Time,
		UpdatedAt: db.UpdatedAt.Time,
	}
}

func ConvertDBEnetpulseTournamentTemplate(db dbgen.EnetpulseTournamentTemplate) domain.EnetpulseTournamentTemplate {
	return domain.EnetpulseTournamentTemplate{
		ID:         db.ID,
		TemplateID: db.TemplateID,
		Name:       db.Name,
		SportFK:    db.SportFk,
		Gender: func() string {
			if db.Gender.Valid {
				return db.Gender.String
			}
			return ""
		}(),
		UpdatesCount: func() int {
			if db.UpdatesCount.Valid {
				return int(db.UpdatesCount.Int32)
			}
			return 0
		}(),
		LastUpdatedAt: db.LastUpdatedAt.Time,
		Status: func() int {
			if db.Status.Valid {
				return int(db.Status.Int32)
			}
			return 0
		}(),
		CreatedAt: db.CreatedAt.Time,
		UpdatedAt: db.UpdatedAt.Time,
	}
}

func ConvertCreateEnetpulseTournamentTemplate(
	t domain.CreateEnetpulseTournamentTemplate,
) dbgen.CreateEnetpulseTournamentTemplateParams {
	return dbgen.CreateEnetpulseTournamentTemplateParams{
		TemplateID:    t.TemplateID,
		SportFk:       fmt.Sprintf("%d", t.SportFK),
		Gender:        pgtype.Text{String: t.Gender, Valid: t.Gender != ""},
		UpdatesCount:  pgtype.Int4{Int32: int32(t.UpdatesCount), Valid: true},
		LastUpdatedAt: pgtype.Timestamptz{Time: t.LastUpdatedAt, Valid: true},
		Status:        pgtype.Int4{Int32: int32(t.Status), Valid: true},
	}
}