Yimaru-BackEnd/internal/repository/enet_pulse.go

package repository

import (
	"context"
	"fmt"
	"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
}

// 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(),
// 	}
// }

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