package repository

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

	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
}

// Store.go
func (s *Store) CreateEnetpulseTournament(
	ctx context.Context,
	tournament domain.CreateEnetpulseTournament,
) (domain.EnetpulseTournament, error) {
	// Convert domain model to DB model if needed
	dbTournament, err := s.queries.CreateEnetpulseTournament(
		ctx,
		ConvertCreateEnetpulseTournament(tournament),
	)
	if err != nil {
		return domain.EnetpulseTournament{}, err
	}
	return ConvertDBEnetpulseTournament(dbTournament), nil
}

// store.go
func (s *Store) GetAllEnetpulseTournaments(ctx context.Context) ([]domain.EnetpulseTournament, error) {
	dbTournaments, err := s.queries.GetAllEnetpulseTournaments(ctx)
	if err != nil {
		return nil, err
	}

	var tournaments []domain.EnetpulseTournament
	for _, dbT := range dbTournaments {
		tournaments = append(tournaments, ConvertDBEnetpulseTournament(dbT))
	}

	return tournaments, nil
}

func (s *Store) CreateEnetpulseTournamentStage(
	ctx context.Context,
	stage domain.CreateEnetpulseTournamentStage,
) (domain.EnetpulseTournamentStage, error) {
	// Convert domain model to DB model if needed
	dbStage, err := s.queries.CreateEnetpulseTournamentStage(
		ctx,
		ConvertCreateEnetpulseTournamentStage(stage),
	)
	if err != nil {
		return domain.EnetpulseTournamentStage{}, err
	}
	return ConvertDBEnetpulseTournamentStage(dbStage), nil
}

// Fetch all tournament stages
func (s *Store) GetAllEnetpulseTournamentStages(ctx context.Context) ([]domain.EnetpulseTournamentStage, error) {
	dbStages, err := s.queries.GetAllEnetpulseTournamentStages(ctx)
	if err != nil {
		return nil, err
	}

	var stages []domain.EnetpulseTournamentStage
	for _, dbStage := range dbStages {
		stages = append(stages, ConvertDBEnetpulseTournamentStage(dbStage))
	}

	return stages, nil
}

// Optional: Fetch stages by TournamentFK
func (s *Store) GetTournamentStagesByTournamentFK(ctx context.Context, tournamentFK string) ([]domain.EnetpulseTournamentStage, error) {
	dbStages, err := s.queries.GetTournamentStagesByTournamentFK(ctx, tournamentFK)
	if err != nil {
		return nil, err
	}

	var stages []domain.EnetpulseTournamentStage
	for _, dbStage := range dbStages {
		stages = append(stages, ConvertDBEnetpulseTournamentStage(dbStage))
	}

	return stages, nil
}

// Create a new fixture
func (s *Store) CreateEnetpulseFixture(
	ctx context.Context,
	fixture domain.CreateEnetpulseFixture,
) (domain.EnetpulseFixture, error) {
	// Convert domain model to DB params (sqlc-generated struct or parameters)
	dbFixture, err := s.queries.CreateEnetpulseFixture(
		ctx,
		ConvertCreateEnetpulseFixture(fixture), // your converter
	)
	if err != nil {
		return domain.EnetpulseFixture{}, err
	}
	return ConvertDBEnetpulseFixture(dbFixture), nil // convert DB row to domain
}

// Fetch all fixtures
func (s *Store) GetAllEnetpulseFixtures(ctx context.Context) ([]domain.EnetpulseFixture, error) {
	dbFixtures, err := s.queries.GetAllEnetpulseFixtures(ctx)
	if err != nil {
		return nil, err
	}

	var fixtures []domain.EnetpulseFixture
	for _, dbFixture := range dbFixtures {
		fixtures = append(fixtures, ConvertDBEnetpulseFixture(dbFixture))
	}

	return fixtures, nil
}

func (s *Store) CreateEnetpulseResult(
	ctx context.Context,
	result domain.CreateEnetpulseResult,
) (domain.EnetpulseResult, error) {
	dbResult, err := s.queries.CreateEnetpulseResult(
		ctx,
		ConvertCreateEnetpulseResult(result),
	)
	if err != nil {
		return domain.EnetpulseResult{}, err
	}

	return ConvertDBEnetpulseResult(dbResult), nil
}

// GetAllEnetpulseResults retrieves all Enetpulse results.
func (s *Store) GetAllEnetpulseResults(ctx context.Context) ([]domain.EnetpulseResult, error) {
	dbResults, err := s.queries.GetAllEnetpulseResults(ctx)
	if err != nil {
		return nil, err
	}

	results := make([]domain.EnetpulseResult, 0, len(dbResults))
	for _, dbR := range dbResults {
		results = append(results, ConvertDBEnetpulseResult(dbR))
	}

	return results, nil
}

// CreateEnetpulseOutcomeType inserts or updates an EnetPulse outcome type record.
func (s *Store) CreateEnetpulseOutcomeType(
	ctx context.Context,
	outcomeType domain.CreateEnetpulseOutcomeType,
) (domain.EnetpulseOutcomeType, error) {
	dbOutcome, err := s.queries.CreateEnetpulseOutcomeType(
		ctx,
		ConvertCreateEnetpulseOutcomeType(outcomeType),
	)
	if err != nil {
		return domain.EnetpulseOutcomeType{}, err
	}

	return ConvertDBEnetpulseOutcomeType(dbOutcome), nil
}

// GetAllEnetpulseOutcomeTypes retrieves all outcome types.
func (s *Store) GetAllEnetpulseOutcomeTypes(ctx context.Context) ([]domain.EnetpulseOutcomeType, error) {
	dbOutcomes, err := s.queries.GetAllEnetpulseOutcomeTypes(ctx)
	if err != nil {
		return nil, err
	}

	outcomes := make([]domain.EnetpulseOutcomeType, 0, len(dbOutcomes))
	for _, dbO := range dbOutcomes {
		outcomes = append(outcomes, ConvertDBEnetpulseOutcomeType(dbO))
	}

	return outcomes, nil
}

// CreateEnetpulsePreodds inserts or updates a preodds record.
func (s *Store) CreateEnetpulsePreodds(
	ctx context.Context,
	preodds domain.CreateEnetpulsePreodds,
) (domain.EnetpulsePreodds, error) {

	// Convert domain to DB params
	params, err := ConvertCreateEnetpulsePreodds(preodds)
	if err != nil {
		return domain.EnetpulsePreodds{}, err
	}

	// Insert into DB
	dbPreodds, err := s.queries.CreateEnetpulsePreodds(ctx, params)
	if err != nil {
		return domain.EnetpulsePreodds{}, err
	}

	return ConvertDBEnetpulsePreodds(dbPreodds), nil
}

// GetAllEnetpulsePreodds retrieves all preodds records.
func (s *Store) GetAllEnetpulsePreodds(ctx context.Context) ([]domain.EnetpulsePreodds, error) {
	dbPreodds, err := s.queries.GetAllEnetpulsePreodds(ctx)
	if err != nil {
		return nil, err
	}

	preodds := make([]domain.EnetpulsePreodds, 0, len(dbPreodds))
	for _, dbP := range dbPreodds {
		preodds = append(preodds, ConvertDBEnetpulsePreodds(dbP))
	}

	return preodds, nil
}

// CreateEnetpulsePreoddsBettingOffer inserts or updates a betting offer
func (s *Store) CreateEnetpulsePreoddsBettingOffer(
	ctx context.Context,
	bettingOffer domain.CreateEnetpulsePreoddsBettingOffer,
) (domain.EnetpulsePreoddsBettingOffer, error) {

	params := ConvertCreateEnetpulsePreoddsBettingOffer(bettingOffer)

	dbOffer, err := s.queries.CreateEnetpulsePreoddsBettingOffer(ctx, params)
	if err != nil {
		return domain.EnetpulsePreoddsBettingOffer{}, err
	}

	return ConvertDBEnetpulsePreoddsBettingOffer(dbOffer), nil
}

// GetAllEnetpulsePreoddsBettingOffers retrieves all betting offers
func (s *Store) GetAllEnetpulsePreoddsBettingOffers(ctx context.Context) ([]domain.EnetpulsePreoddsBettingOffer, error) {
	dbOffers, err := s.queries.GetAllEnetpulsePreoddsBettingOffers(ctx)
	if err != nil {
		return nil, err
	}

	offers := make([]domain.EnetpulsePreoddsBettingOffer, 0, len(dbOffers))
	for _, dbO := range dbOffers {
		offers = append(offers, ConvertDBEnetpulsePreoddsBettingOffer(dbO))
	}

	return offers, nil
}

// func ConvertCreateEnetpulseTournamentStage(stage domain.CreateEnetpulseTournamentStage) dbgen.EnetpulseTournamentStage {
// 	return dbgen.EnetpulseTournamentStage{
// 		StageID:       stage.StageID,
// 		Name:          stage.Name,
// 		TournamentFK:  stage.TournamentFK,
// 		Gender:        stage.Gender,
// 		CountryFK:     stage.CountryFK,
// 		StartDate:     stage.StartDate,
// 		EndDate:       stage.EndDate,
// 		UpdatesCount:  int32(stage.UpdatesCount),
// 		LastUpdatedAt: stage.LastUpdatedAt,
// 		CountryName:   stage.CountryName,
// 		Status:        int32(stage.Status),
// 		UpdatedAt:     time.Now(),
// 	}
// }

// ConvertCreateEnetpulseFixture converts the domain model to the SQLC params struct.
func ConvertCreateEnetpulseFixture(f domain.CreateEnetpulseFixture) dbgen.CreateEnetpulseFixtureParams {
	return dbgen.CreateEnetpulseFixtureParams{
		FixtureID:              f.FixtureID,
		Name:                   f.Name,
		SportFk:                f.SportFK,
		TournamentFk:           pgtype.Text{String: f.TournamentFK, Valid: f.TournamentFK != ""},
		TournamentTemplateFk:   pgtype.Text{String: f.TournamentTemplateFK, Valid: f.TournamentTemplateFK != ""},
		TournamentStageFk:      pgtype.Text{String: f.TournamentStageFK, Valid: f.TournamentStageFK != ""},
		TournamentStageName:    pgtype.Text{String: f.TournamentStageName, Valid: f.TournamentStageName != ""},
		TournamentName:         pgtype.Text{String: f.TournamentName, Valid: f.TournamentName != ""},
		TournamentTemplateName: pgtype.Text{String: f.TournamentTemplateName, Valid: f.TournamentTemplateName != ""},
		SportName:              pgtype.Text{String: f.SportName, Valid: f.SportName != ""},
		Gender:                 pgtype.Text{String: f.Gender, Valid: f.Gender != ""},
		StartDate:              pgtype.Timestamptz{Time: f.StartDate, Valid: !f.StartDate.IsZero()},
		StatusType:             pgtype.Text{String: f.StatusType, Valid: f.StatusType != ""},
		StatusDescFk:           pgtype.Text{String: f.StatusDescFK, Valid: f.StatusDescFK != ""},
		RoundTypeFk:            pgtype.Text{String: f.RoundTypeFK, Valid: f.RoundTypeFK != ""},
		UpdatesCount:           pgtype.Int4{Int32: int32(f.UpdatesCount), Valid: true},
		LastUpdatedAt:          pgtype.Timestamptz{Time: f.LastUpdatedAt, Valid: !f.LastUpdatedAt.IsZero()},
	}
}

// ConvertDBEnetpulseFixture converts the DB row to the domain model.
func ConvertDBEnetpulseFixture(dbF dbgen.EnetpulseFixture) domain.EnetpulseFixture {
	return domain.EnetpulseFixture{
		FixtureID:              dbF.FixtureID,
		Name:                   dbF.Name,
		SportFK:                dbF.SportFk,
		TournamentFK:           dbF.TournamentFk.String,
		TournamentTemplateFK:   dbF.TournamentTemplateFk.String,
		TournamentStageFK:      dbF.TournamentStageFk.String,
		TournamentStageName:    dbF.TournamentStageName.String,
		TournamentName:         dbF.TournamentName.String,
		TournamentTemplateName: dbF.TournamentTemplateName.String,
		SportName:              dbF.SportName.String,
		Gender:                 dbF.Gender.String,
		StartDate:              dbF.StartDate.Time,
		StatusType:             dbF.StatusType.String,
		StatusDescFK:           dbF.StatusDescFk.String,
		RoundTypeFK:            dbF.RoundTypeFk.String,
		UpdatesCount:           int(dbF.UpdatesCount.Int32),
		LastUpdatedAt:          dbF.LastUpdatedAt.Time,
		CreatedAt:              dbF.CreatedAt.Time,
		UpdatedAt:              dbF.UpdatedAt.Time,
	}
}

func ConvertCreateEnetpulseTournamentStage(stage domain.CreateEnetpulseTournamentStage) dbgen.CreateEnetpulseTournamentStageParams {
	return dbgen.CreateEnetpulseTournamentStageParams{
		StageID:       stage.StageID,
		Name:          stage.Name,
		TournamentFk:  stage.TournamentFK,
		Gender:        pgtype.Text{String: stage.Gender, Valid: stage.Gender != ""},
		CountryFk:     pgtype.Text{String: stage.CountryFK, Valid: stage.CountryFK != ""},
		StartDate:     pgtype.Timestamptz{Time: stage.StartDate, Valid: !stage.StartDate.IsZero()},
		EndDate:       pgtype.Timestamptz{Time: stage.EndDate, Valid: !stage.EndDate.IsZero()},
		UpdatesCount:  pgtype.Int4{Int32: int32(stage.UpdatesCount), Valid: true},
		LastUpdatedAt: pgtype.Timestamptz{Time: stage.LastUpdatedAt, Valid: !stage.LastUpdatedAt.IsZero()},
		CountryName:   pgtype.Text{String: stage.CountryName, Valid: stage.CountryFK != ""},
		Status:        pgtype.Int4{Int32: int32(stage.Status), Valid: true},
		// Las:     pgtype.Timestamptz{Time: time.Now(), Valid: true},
	}
}

func ConvertDBEnetpulseTournamentStage(db dbgen.EnetpulseTournamentStage) domain.EnetpulseTournamentStage {
	return domain.EnetpulseTournamentStage{
		ID:           db.ID,
		StageID:      db.StageID,
		Name:         db.Name,
		TournamentFK: db.TournamentFk,
		Gender:       db.Gender.String,
		CountryFK:    db.CountryFk.String,
		StartDate:    db.StartDate.Time,
		EndDate:      db.EndDate.Time,
		UpdatesCount: func() int {
			if db.UpdatesCount.Valid {
				return int(db.UpdatesCount.Int32)
			}
			return 0
		}(),
		LastUpdatedAt: db.LastUpdatedAt.Time,
		CountryName:   db.CountryName.String,
		Status: func() int {
			if db.Status.Valid {
				return int(db.Status.Int32)
			}
			return 0
		}(),
		CreatedAt: db.CreatedAt.Time,
		UpdatedAt: db.UpdatedAt.Time,
	}
}

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},
	}
}

// Convert domain to DB insert struct for sqlc
func ConvertCreateEnetpulseTournament(t domain.CreateEnetpulseTournament) dbgen.CreateEnetpulseTournamentParams {
	return dbgen.CreateEnetpulseTournamentParams{
		TournamentID:         t.TournamentID,
		Name:                 t.Name,
		TournamentTemplateFk: t.TournamentTemplateFK,
		UpdatesCount:         pgtype.Int4{Int32: int32(t.UpdatesCount), Valid: true},
		LastUpdatedAt:        pgtype.Timestamptz{Time: t.LastUpdatedAt, Valid: !t.LastUpdatedAt.IsZero()},
		Status:               pgtype.Int4{Int32: int32(t.Status), Valid: true},
	}
}

// Convert DB row to domain model
func ConvertDBEnetpulseTournament(dbT dbgen.EnetpulseTournament) domain.EnetpulseTournament {
	return domain.EnetpulseTournament{
		ID:                   dbT.ID,
		TournamentID:         dbT.TournamentID,
		Name:                 dbT.Name,
		TournamentTemplateFK: dbT.TournamentTemplateFk,
		UpdatesCount: func() int {
			if dbT.UpdatesCount.Valid {
				return int(dbT.UpdatesCount.Int32)
			}
			return 0
		}(),
		LastUpdatedAt: dbT.LastUpdatedAt.Time,
		Status: func() int {
			if dbT.Status.Valid {
				return int(dbT.Status.Int32)
			}
			return 0
		}(),
		CreatedAt: dbT.CreatedAt.Time,
		UpdatedAt: func() *time.Time {
			if dbT.UpdatedAt.Valid {
				return &dbT.UpdatedAt.Time
			}
			return nil
		}(),
	}
}

func ConvertCreateEnetpulseResult(input domain.CreateEnetpulseResult) dbgen.CreateEnetpulseResultParams {
	return dbgen.CreateEnetpulseResultParams{
		ResultID:               input.ResultID,
		Name:                   input.Name,
		SportFk:                input.SportFK,
		TournamentFk:           pgtype.Text{String: input.TournamentFK, Valid: input.TournamentFK != ""},
		TournamentTemplateFk:   pgtype.Text{String: input.TournamentTemplateFK, Valid: input.TournamentTemplateFK != ""},
		TournamentStageFk:      pgtype.Text{String: input.TournamentStageFK, Valid: input.TournamentStageFK != ""},
		TournamentStageName:    pgtype.Text{String: input.TournamentStageName, Valid: input.TournamentStageName != ""},
		TournamentName:         pgtype.Text{String: input.TournamentName, Valid: input.TournamentName != ""},
		TournamentTemplateName: pgtype.Text{String: input.TournamentTemplateName, Valid: input.TournamentTemplateName != ""},
		SportName:              pgtype.Text{String: input.SportName, Valid: input.SportName != ""},
		StartDate:              pgtype.Timestamptz{Time: input.StartDate, Valid: !input.StartDate.IsZero()},
		StatusType:             pgtype.Text{String: input.StatusType, Valid: input.StatusType != ""},
		StatusDescFk:           pgtype.Text{String: input.StatusDescFK, Valid: input.StatusDescFK != ""},
		RoundTypeFk:            pgtype.Text{String: input.RoundTypeFK, Valid: input.RoundTypeFK != ""},
		UpdatesCount:           pgtype.Int4{Int32: int32(input.UpdatesCount), Valid: true},
		LastUpdatedAt:          pgtype.Timestamptz{Time: input.LastUpdatedAt, Valid: !input.LastUpdatedAt.IsZero()},
		Round:                  pgtype.Text{String: input.Round, Valid: input.Round != ""},
		Live:                   pgtype.Text{String: input.Live, Valid: input.Live != ""},
		VenueName:              pgtype.Text{String: input.VenueName, Valid: input.VenueName != ""},
		LivestatsPlus:          pgtype.Text{String: input.LivestatsPlus, Valid: input.LivestatsPlus != ""},
		LivestatsType:          pgtype.Text{String: input.LivestatsType, Valid: input.LivestatsType != ""},
		Commentary:             pgtype.Text{String: input.Commentary, Valid: input.Commentary != ""},
		LineupConfirmed:        pgtype.Bool{Bool: input.LineupConfirmed, Valid: true},
		Verified:               pgtype.Bool{Bool: input.Verified, Valid: true},
		Spectators:             pgtype.Int4{Int32: int32(input.Spectators), Valid: true},
		GameStarted:            pgtype.Timestamptz{Time: *input.GameStarted, Valid: !input.GameStarted.IsZero()},
		FirstHalfEnded:         pgtype.Timestamptz{Time: *input.FirstHalfEnded, Valid: !input.FirstHalfEnded.IsZero()},
		SecondHalfStarted:      pgtype.Timestamptz{Time: *input.SecondHalfStarted, Valid: !input.SecondHalfStarted.IsZero()},
		SecondHalfEnded:        pgtype.Timestamptz{Time: *input.SecondHalfEnded, Valid: !input.SecondHalfEnded.IsZero()},
		GameEnded:              pgtype.Timestamptz{Time: *input.GameEnded, Valid: !input.GameEnded.IsZero()},
	}
}

// ConvertDBEnetpulseResult maps SQLC result → domain model
func ConvertDBEnetpulseResult(db dbgen.EnetpulseResult) domain.EnetpulseResult {
	return domain.EnetpulseResult{
		ID:                     db.ID,
		ResultID:               db.ResultID,
		Name:                   db.Name,
		SportFK:                db.SportFk,
		TournamentFK:           db.TournamentFk.String,
		TournamentTemplateFK:   db.TournamentTemplateFk.String,
		TournamentStageFK:      db.TournamentStageFk.String,
		TournamentStageName:    db.TournamentStageName.String,
		TournamentName:         db.TournamentName.String,
		TournamentTemplateName: db.TournamentTemplateName.String,
		SportName:              db.SportName.String,
		StartDate:              db.StartDate.Time,
		StatusType:             db.StatusType.String,
		StatusDescFK:           db.StatusDescFk.String,
		RoundTypeFK:            db.RoundTypeFk.String,
		UpdatesCount:           db.UpdatesCount.Int32,
		LastUpdatedAt:          &db.LastUpdatedAt.Time,
		Round:                  db.Round.String,
		Live:                   db.Live.String,
		VenueName:              db.VenueName.String,
		LivestatsPlus:          db.LivestatsPlus.String,
		LivestatsType:          db.LivestatsType.String,
		Commentary:             db.Commentary.String,
		LineupConfirmed:        db.LineupConfirmed.Bool,
		Verified:               db.Verified.Bool,
		Spectators:             db.Spectators.Int32,
		GameStarted:            &db.GameStarted.Time,
		FirstHalfEnded:         &db.FirstHalfEnded.Time,
		SecondHalfStarted:      &db.SecondHalfStarted.Time,
		SecondHalfEnded:        &db.SecondHalfEnded.Time,
		GameEnded:              &db.GameEnded.Time,
		CreatedAt:              db.CreatedAt.Time,
		UpdatedAt:              &db.UpdatedAt.Time,
	}
}

// ConvertCreateEnetpulseOutcomeType converts the domain struct to SQLC params.
func ConvertCreateEnetpulseOutcomeType(o domain.CreateEnetpulseOutcomeType) dbgen.CreateEnetpulseOutcomeTypeParams {
	return dbgen.CreateEnetpulseOutcomeTypeParams{
		OutcomeTypeID: o.OutcomeTypeID,
		Name:          o.Name,
		Description:   pgtype.Text{String: o.Description, Valid: o.Description != ""}, // TODO: thiso.Description,
		UpdatesCount:  pgtype.Int4{Int32: int32(o.UpdatesCount), Valid: true},
		LastUpdatedAt: pgtype.Timestamptz{Time: o.LastUpdatedAt, Valid: !o.LastUpdatedAt.IsZero()},
	}
}

// ConvertDBEnetpulseOutcomeType converts SQLC DB model to domain model.
func ConvertDBEnetpulseOutcomeType(dbO dbgen.EnetpulseOutcomeType) domain.EnetpulseOutcomeType {
	return domain.EnetpulseOutcomeType{
		ID:            dbO.ID,
		OutcomeTypeID: dbO.OutcomeTypeID,
		Name:          dbO.Name,
		Description:   dbO.Description.String,
		UpdatesCount:  dbO.UpdatesCount.Int32,
		LastUpdatedAt: dbO.LastUpdatedAt.Time,
		CreatedAt:     dbO.CreatedAt.Time,
		UpdatedAt:     dbO.UpdatedAt.Time,
	}
}

func ConvertCreateEnetpulsePreodds(p domain.CreateEnetpulsePreodds) (dbgen.CreateEnetpulsePreoddsParams, error) {
	eventFK, err := strconv.ParseInt(p.EventFK, 10, 64)
	if err != nil {
		return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid EventFK: %w", err)
	}

	outcomeTypeFK, err := strconv.ParseInt(p.OutcomeTypeFK, 10, 32)
	if err != nil {
		return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeTypeFK: %w", err)
	}

	outcomeScopeFK, err := strconv.ParseInt(p.OutcomeScopeFK, 10, 32)
	if err != nil {
		return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeScopeFK: %w", err)
	}

	outcomeSubtypeFK, err := strconv.ParseInt(p.OutcomeSubtypeFK, 10, 32)
	if err != nil {
		return dbgen.CreateEnetpulsePreoddsParams{}, fmt.Errorf("invalid OutcomeSubtypeFK: %w", err)
	}

	return dbgen.CreateEnetpulsePreoddsParams{
		PreoddsID:              p.PreoddsID,
		EventFk:                eventFK,
		OutcomeTypeFk:          pgtype.Int4{Int32: int32(outcomeTypeFK), Valid: true},
		OutcomeScopeFk:         pgtype.Int4{Int32: int32(outcomeScopeFK), Valid: true},
		OutcomeSubtypeFk:       pgtype.Int4{Int32: int32(outcomeSubtypeFK), Valid: true},
		EventParticipantNumber: pgtype.Int4{Int32: int32(p.EventParticipantNumber), Valid: true},
		Iparam:                 pgtype.Text{String: p.IParam, Valid: p.IParam != ""},
		Iparam2:                pgtype.Text{String: p.IParam2, Valid: p.IParam2 != ""},
		Dparam:                 pgtype.Text{String: p.DParam, Valid: p.DParam != ""},
		Dparam2:                pgtype.Text{String: p.DParam2, Valid: p.DParam2 != ""},
		Sparam:                 pgtype.Text{String: p.SParam, Valid: p.SParam != ""},
		UpdatesCount:           pgtype.Int4{Int32: int32(p.UpdatesCount), Valid: true},
		LastUpdatedAt:          pgtype.Timestamptz{Time: p.LastUpdatedAt, Valid: !p.LastUpdatedAt.IsZero()},
	}, nil
}

func ConvertDBEnetpulsePreodds(dbP dbgen.EnetpulsePreodd) domain.EnetpulsePreodds {
	return domain.EnetpulsePreodds{
		PreoddsID:              dbP.PreoddsID,
		EventFK:                fmt.Sprintf("%v", dbP.EventFk),
		OutcomeTypeFK:          fmt.Sprintf("%v", dbP.OutcomeTypeFk),
		OutcomeScopeFK:         fmt.Sprintf("%v", dbP.OutcomeScopeFk),
		OutcomeSubtypeFK:       fmt.Sprintf("%v", dbP.OutcomeSubtypeFk),
		EventParticipantNumber: int(dbP.EventParticipantNumber.Int32),
		IParam:                 dbP.Iparam.String,
		IParam2:                dbP.Iparam2.String,
		DParam:                 dbP.Dparam.String,
		DParam2:                dbP.Dparam2.String,
		SParam:                 dbP.Sparam.String,
		UpdatesCount:           int(dbP.UpdatesCount.Int32),
		LastUpdatedAt:          dbP.LastUpdatedAt.Time,
		CreatedAt:              dbP.CreatedAt.Time,
		UpdatedAt:              dbP.UpdatedAt.Time,
	}
}

func ConvertCreateEnetpulsePreoddsBettingOffer(o domain.CreateEnetpulsePreoddsBettingOffer) dbgen.CreateEnetpulsePreoddsBettingOfferParams {
	// Convert float64 to int64 with scale 2
	oddsInt := big.NewInt(int64(math.Round(o.Odds * 100)))
	oddsOldInt := big.NewInt(int64(math.Round(o.OddsOld * 100)))

	return dbgen.CreateEnetpulsePreoddsBettingOfferParams{
		BettingofferID:       o.BettingOfferID,
		PreoddsFk:            o.PreoddsFK,
		BettingofferStatusFk: pgtype.Int4{Int32: o.BettingOfferStatusFK, Valid: true},
		OddsProviderFk:       pgtype.Int4{Int32: o.OddsProviderFK, Valid: true},
		Odds: pgtype.Numeric{
			Int:   oddsInt,
			Exp:   -2, // scale 2 decimal places
			Valid: true,
		},
		OddsOld: pgtype.Numeric{
			Int:   oddsOldInt,
			Exp:   -2,
			Valid: true,
		},
		Active: pgtype.Bool{Bool: o.Active == "yes", Valid: true},
		CouponKey: pgtype.Text{
			String: o.CouponKey,
			Valid:  o.CouponKey != "",
		},
		UpdatesCount:  pgtype.Int4{Int32: int32(o.UpdatesCount), Valid: true},
		LastUpdatedAt: pgtype.Timestamptz{Time: o.LastUpdatedAt, Valid: !o.LastUpdatedAt.IsZero()},
	}
}

// Convert DB result to domain struct
func ConvertDBEnetpulsePreoddsBettingOffer(o dbgen.EnetpulsePreoddsBettingoffer) domain.EnetpulsePreoddsBettingOffer {
	var odds, oddsOld float64
	if o.Odds.Valid {
		odds, _ = o.Odds.Int.Float64() // Convert pgtype.Numeric to float64
	}
	if o.OddsOld.Valid {
		oddsOld, _ = o.OddsOld.Int.Float64()
	}

	active := "no"
	if o.Active.Valid && o.Active.Bool {
		active = "yes"
	}

	return domain.EnetpulsePreoddsBettingOffer{
		ID:                   o.ID,
		BettingOfferID:       o.BettingofferID,
		PreoddsFK:            o.PreoddsFk,
		BettingOfferStatusFK: o.BettingofferStatusFk.Int32,
		OddsProviderFK:       o.OddsProviderFk.Int32,
		Odds:                 odds,
		OddsOld:              oddsOld,
		Active:               active,
		CouponKey:            o.CouponKey.String,
		UpdatesCount:         int(o.UpdatesCount.Int32),
		LastUpdatedAt:        o.LastUpdatedAt.Time,
		CreatedAt:            o.CreatedAt.Time,
		UpdatedAt:            o.UpdatedAt.Time,
	}
}