Yimaru-BackEnd/internal/repository/event.go

package repository

import (
	"context"
	"fmt"
	"math"

	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.CreateEvent) error {
	return s.queries.InsertEvent(ctx, domain.ConvertCreateEvent(e))
}

func (s *Store) InsertEventSettings(ctx context.Context, eventSetting domain.CreateEventSettings) error {
	return s.queries.InsertEventSettings(ctx, domain.ConvertCreateEventSettings(eventSetting))
}

func (s *Store) GetLiveEventIDs(ctx context.Context) ([]string, error) {
	return s.queries.ListLiveEvents(ctx)
}

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

	return domain.ConvertDBEvents(events), nil
}

func (s *Store) GetExpiredUpcomingEvents(ctx context.Context, filter domain.EventFilter) ([]domain.BaseEvent, error) {
	events, err := s.queries.GetExpiredEvents(ctx, pgtype.Text{
		String: filter.MatchStatus.Value,
		Valid:  filter.MatchStatus.Valid,
	})
	if err != nil {
		return nil, err
	}

	return domain.ConvertDBEvents(events), nil
}

func (s *Store) GetPaginatedUpcomingEvents(ctx context.Context, filter domain.EventFilter) ([]domain.BaseEvent, int64, error) {

	events, err := s.queries.GetPaginatedUpcomingEvents(ctx, dbgen.GetPaginatedUpcomingEventsParams{
		LeagueID:       filter.LeagueID.ToPG(),
		SportID:        filter.SportID.ToPG(),
		Query:          filter.Query.ToPG(),
		Limit:          filter.Limit.ToPG(),
		Offset:         filter.Offset.ToPG(),
		FirstStartTime: filter.FirstStartTime.ToPG(),
		LastStartTime:  filter.LastStartTime.ToPG(),
		CountryCode:    filter.CountryCode.ToPG(),
	})

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

	totalCount, err := s.queries.GetTotalEvents(ctx, dbgen.GetTotalEventsParams{
		LeagueID:       filter.LeagueID.ToPG(),
		SportID:        filter.SportID.ToPG(),
		Query:          filter.Query.ToPG(),
		FirstStartTime: filter.FirstStartTime.ToPG(),
		LastStartTime:  filter.LastStartTime.ToPG(),
		CountryCode:    filter.CountryCode.ToPG(),
	})
	if err != nil {
		return nil, 0, err
	}

	numberOfPages := math.Ceil(float64(totalCount) / float64(filter.Limit.Value))
	return domain.ConvertDBEvents(events), int64(numberOfPages), nil
}

func (s *Store) GetEventsWithSettings(ctx context.Context, companyID int64, filter domain.EventFilter) ([]domain.EventWithSettings, int64, error) {
	events, err := s.queries.GetEventsWithSettings(ctx, dbgen.GetEventsWithSettingsParams{
		CompanyID:      companyID,
		LeagueID:       filter.LeagueID.ToPG(),
		SportID:        filter.SportID.ToPG(),
		Query:          filter.Query.ToPG(),
		Limit:          filter.Limit.ToPG(),
		Offset:         filter.Offset.ToPG(),
		FirstStartTime: filter.FirstStartTime.ToPG(),
		LastStartTime:  filter.LastStartTime.ToPG(),
		CountryCode:    filter.CountryCode.ToPG(),
	})

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

	totalCount, err := s.queries.GetTotalCompanyEvents(ctx, dbgen.GetTotalCompanyEventsParams{
		CompanyID:      companyID,
		LeagueID:       filter.LeagueID.ToPG(),
		SportID:        filter.SportID.ToPG(),
		Query:          filter.Query.ToPG(),
		FirstStartTime: filter.FirstStartTime.ToPG(),
		LastStartTime:  filter.LastStartTime.ToPG(),
		CountryCode:    filter.CountryCode.ToPG(),
	})
	if err != nil {
		return nil, 0, err
	}

	numberOfPages := math.Ceil(float64(totalCount) / float64(filter.Limit.Value))
	return domain.ConvertDBEventWithSettings(events), int64(numberOfPages), nil
}
func (s *Store) GetUpcomingEventByID(ctx context.Context, ID string) (domain.BaseEvent, error) {
	event, err := s.queries.GetUpcomingByID(ctx, ID)
	if err != nil {
		return domain.BaseEvent{}, err
	}

	return domain.ConvertDBEvent(event), nil
}
func (s *Store) GetEventWithSettingByID(ctx context.Context, ID string, companyID int64) (domain.EventWithSettings, error) {
	event, err := s.queries.GetEventWithSettingByID(ctx, dbgen.GetEventWithSettingByIDParams{
		ID: ID,
		CompanyID: companyID,
	})
	if err != nil {
		return domain.EventWithSettings{}, err
	}

	return domain.ConvertDBEventWithSetting(event), nil
}
func (s *Store) UpdateFinalScore(ctx context.Context, eventID, fullScore string, status domain.EventStatus) error {
	params := dbgen.UpdateMatchResultParams{
		Score:  pgtype.Text{String: fullScore, Valid: true},
		Status: string(status),
		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
}

func (s *Store) UpdateEventStatus(ctx context.Context, eventID string, status domain.EventStatus) error {
	params := dbgen.UpdateMatchResultParams{
		Status: string(status),
		ID:     eventID,
	}

	err := s.queries.UpdateMatchResult(ctx, params)

	if err != nil {
		return err
	}
	return nil

}

func (s *Store) IsEventMonitored(ctx context.Context, eventID string) (bool, error) {
	isMonitored, err := s.queries.IsEventMonitored(ctx, eventID)

	if err != nil {
		return false, err
	}
	return isMonitored, err
}
func (s *Store) UpdateEventMonitored(ctx context.Context, eventID string, IsMonitored bool) error {
	return s.queries.UpdateEventMonitored(ctx, dbgen.UpdateEventMonitoredParams{
		ID:          eventID,
		IsMonitored: IsMonitored,
	})
}

func (s *Store) UpdateEventSettings(ctx context.Context, event domain.CreateEventSettings) error {
	return s.queries.UpdateEventSettings(ctx, domain.ConvertUpdateEventSettings(event))
}

func (s *Store) DeleteEvent(ctx context.Context, eventID string) error {
	err := s.queries.DeleteEvent(ctx, eventID)
	if err != nil {
		return err
	}
	return nil
}