Yimaru-BackEnd/internal/repository/event.go

package repository

import (
	"context"
	"fmt"
	"math"
	"time"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"

	// "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
	"github.com/jackc/pgx/v5/pgtype"
)

func (s *Store) SaveEvent(ctx context.Context, e domain.Event) error {
	parsedTime, err := time.Parse(time.RFC3339, e.StartTime)
	if err != nil {
		return err
	}

	return s.queries.InsertEvent(ctx, dbgen.InsertEventParams{
		ID:           e.ID,
		SportID:      pgtype.Text{String: e.SportID, Valid: true},
		MatchName:    pgtype.Text{String: e.MatchName, Valid: true},
		HomeTeam:     pgtype.Text{String: e.HomeTeam, Valid: true},
		AwayTeam:     pgtype.Text{String: e.AwayTeam, Valid: true},
		HomeTeamID:   pgtype.Text{String: e.HomeTeamID, Valid: true},
		AwayTeamID:   pgtype.Text{String: e.AwayTeamID, Valid: true},
		HomeKitImage: pgtype.Text{String: e.HomeKitImage, Valid: true},
		AwayKitImage: pgtype.Text{String: e.AwayKitImage, Valid: true},
		LeagueID:     pgtype.Text{String: e.LeagueID, Valid: true},
		LeagueName:   pgtype.Text{String: e.LeagueName, Valid: true},
		LeagueCc:     pgtype.Text{String: e.LeagueCC, Valid: true},
		StartTime:    pgtype.Timestamp{Time: parsedTime, Valid: true},
		Score:        pgtype.Text{String: e.Score, Valid: true},
		MatchMinute:  pgtype.Int4{Int32: int32(e.MatchMinute), Valid: true},
		TimerStatus:  pgtype.Text{String: e.TimerStatus, Valid: true},
		AddedTime:    pgtype.Int4{Int32: int32(e.AddedTime), Valid: true},
		MatchPeriod:  pgtype.Int4{Int32: int32(e.MatchPeriod), Valid: true},
		IsLive:       pgtype.Bool{Bool: e.IsLive, Valid: true},
		Status:       pgtype.Text{String: e.Status, Valid: true},
	})
}
func (s *Store) SaveUpcomingEvent(ctx context.Context, e domain.UpcomingEvent) error {
	return s.queries.InsertUpcomingEvent(ctx, dbgen.InsertUpcomingEventParams{
		ID:           e.ID,
		SportID:      pgtype.Text{String: e.SportID, Valid: true},
		MatchName:    pgtype.Text{String: e.MatchName, Valid: true},
		HomeTeam:     pgtype.Text{String: e.HomeTeam, Valid: true},
		AwayTeam:     pgtype.Text{String: e.AwayTeam, Valid: true},
		HomeTeamID:   pgtype.Text{String: e.HomeTeamID, Valid: true},
		AwayTeamID:   pgtype.Text{String: e.AwayTeamID, Valid: true},
		HomeKitImage: pgtype.Text{String: e.HomeKitImage, Valid: true},
		AwayKitImage: pgtype.Text{String: e.AwayKitImage, Valid: true},
		LeagueID:     pgtype.Text{String: e.LeagueID, Valid: true},
		LeagueName:   pgtype.Text{String: e.LeagueName, Valid: true},
		LeagueCc:     pgtype.Text{String: e.LeagueCC, Valid: true},
		StartTime:    pgtype.Timestamp{Time: e.StartTime, Valid: true},
	})
}

func (s *Store) GetLiveEventIDs(ctx context.Context) ([]string, error) {
	return s.queries.ListLiveEvents(ctx)
}
func (s *Store) GetAllUpcomingEvents(ctx context.Context) ([]domain.UpcomingEvent, error) {
	events, err := s.queries.GetAllUpcomingEvents(ctx)
	if err != nil {
		return nil, err
	}

	upcomingEvents := make([]domain.UpcomingEvent, len(events))
	for i, e := range events {
		upcomingEvents[i] = domain.UpcomingEvent{
			ID:           e.ID,
			SportID:      e.SportID.String,
			MatchName:    e.MatchName.String,
			HomeTeam:     e.HomeTeam.String,
			AwayTeam:     e.AwayTeam.String,
			HomeTeamID:   e.HomeTeamID.String,
			AwayTeamID:   e.AwayTeamID.String,
			HomeKitImage: e.HomeKitImage.String,
			AwayKitImage: e.AwayKitImage.String,
			LeagueID:     e.LeagueID.String,
			LeagueName:   e.LeagueName.String,
			LeagueCC:     e.LeagueCc.String,
			StartTime:    e.StartTime.Time.UTC(),
		}
	}
	return upcomingEvents, nil
}
func (s *Store) GetPaginatedUpcomingEvents(ctx context.Context, limit int32, offset int32, leagueID domain.ValidString, sportID domain.ValidString) ([]domain.UpcomingEvent, int64, error) {
	events, err := s.queries.GetPaginatedUpcomingEvents(ctx, dbgen.GetPaginatedUpcomingEventsParams{
		LeagueID: pgtype.Text{
			String: leagueID.Value,
			Valid:  leagueID.Valid,
		},
		SportID: pgtype.Text{
			String: sportID.Value,
			Valid:  sportID.Valid,
		},
		Limit:  limit,
		Offset: offset * limit,
	})

	if err != nil {
		return nil, 0, err
	}

	upcomingEvents := make([]domain.UpcomingEvent, len(events))
	for i, e := range events {
		upcomingEvents[i] = domain.UpcomingEvent{
			ID:           e.ID,
			SportID:      e.SportID.String,
			MatchName:    e.MatchName.String,
			HomeTeam:     e.HomeTeam.String,
			AwayTeam:     e.AwayTeam.String,
			HomeTeamID:   e.HomeTeamID.String,
			AwayTeamID:   e.AwayTeamID.String,
			HomeKitImage: e.HomeKitImage.String,
			AwayKitImage: e.AwayKitImage.String,
			LeagueID:     e.LeagueID.String,
			LeagueName:   e.LeagueName.String,
			LeagueCC:     e.LeagueCc.String,
			StartTime:    e.StartTime.Time.UTC(),
		}
	}
	totalCount, err := s.queries.GetTotalEvents(ctx, dbgen.GetTotalEventsParams{
		LeagueID: pgtype.Text{
			String: leagueID.Value,
			Valid:  leagueID.Valid,
		},
		SportID: pgtype.Text{
			String: sportID.Value,
			Valid:  sportID.Valid,
		},
	})
	if err != nil {
		return nil, 0, err
	}

	numberOfPages := math.Ceil(float64(totalCount) / float64(limit))
	return upcomingEvents, int64(numberOfPages), nil
}
func (s *Store) GetUpcomingEventByID(ctx context.Context, ID string) (domain.UpcomingEvent, error) {
	event, err := s.queries.GetUpcomingByID(ctx, ID)
	if err != nil {
		return domain.UpcomingEvent{}, err
	}

	return domain.UpcomingEvent{
		ID:           event.ID,
		SportID:      event.SportID.String,
		MatchName:    event.MatchName.String,
		HomeTeam:     event.HomeTeam.String,
		AwayTeam:     event.AwayTeam.String,
		HomeTeamID:   event.HomeTeamID.String,
		AwayTeamID:   event.AwayTeamID.String,
		HomeKitImage: event.HomeKitImage.String,
		AwayKitImage: event.AwayKitImage.String,
		LeagueID:     event.LeagueID.String,
		LeagueName:   event.LeagueName.String,
		LeagueCC:     event.LeagueCc.String,
		StartTime:    event.StartTime.Time.UTC(),
	}, nil
}
func (s *Store) UpdateFinalScore(ctx context.Context, eventID, fullScore, status string) error {
    params := dbgen.UpdateMatchResultParams{
        Score:  pgtype.Text{String: fullScore, Valid: true},
        Status: pgtype.Text{String: status, Valid: true},
        ID:     eventID,
    }

    err := s.queries.UpdateMatchResult(ctx, params)
    if err != nil {
        return fmt.Errorf("failed to update final score for event %s: %w", eventID, err)
    }

    return nil
}