Yimaru-BackEnd/internal/repository/event.go

package repository

import (
	"context"
	"fmt"

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

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

// Interface for creating new event store
func NewEventStore(s *Store) ports.EventStore { return s }

func (s *Store) SaveEvent(ctx context.Context, e domain.CreateEvent) error {
	return s.queries.InsertEvent(ctx, domain.ConvertCreateEvent(e))
}

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

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

	events, err := s.queries.GetAllEvents(ctx, dbgen.GetAllEventsParams{
		LeagueID: filter.LeagueID.ToPG(),
		SportID:  filter.SportID.ToPG(),
		Query:    filter.Query.ToPG(),
		Limit:    filter.Limit.ToPG(),
		Offset: pgtype.Int4{
			Int32: int32(filter.Offset.Value * filter.Limit.Value),
			Valid: filter.Offset.Valid,
		},

		FirstStartTime: filter.FirstStartTime.ToPG(),
		LastStartTime:  filter.LastStartTime.ToPG(),
		CountryCode:    filter.CountryCode.ToPG(),
		IsLive:         filter.IsLive.ToPG(),
		Status:         filter.Status.ToPG(),
		Source:         filter.Source.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(),
		IsLive:         filter.IsLive.ToPG(),
		Status:         filter.Status.ToPG(),
		Source:         filter.Source.ToPG(),
	})
	if err != nil {
		return nil, 0, err
	}

	return domain.ConvertDBEvents(events), totalCount, nil
}

func (s *Store) GetEventByID(ctx context.Context, ID int64) (domain.BaseEvent, error) {
	event, err := s.queries.GetEventByID(ctx, ID)
	if err != nil {
		return domain.BaseEvent{}, err
	}

	return domain.ConvertDBEvent(event), nil
}
func (s *Store) GetEventBySourceID(ctx context.Context, id string, source domain.EventSource) (domain.BaseEvent, error) {
	event, err := s.queries.GetEventBySourceID(ctx, dbgen.GetEventBySourceIDParams{
		SourceEventID: id,
		Source:        string(source),
	})
	if err != nil {
		return domain.BaseEvent{}, err
	}

	return domain.ConvertDBEvent(event), nil
}
func (s *Store) UpdateFinalScore(ctx context.Context, eventID int64, 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 %v: %w", eventID, err)
	}

	return nil
}

func (s *Store) UpdateEventStatus(ctx context.Context, eventID int64, 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 int64) (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 int64, IsMonitored bool) error {
	return s.queries.UpdateEventMonitored(ctx, dbgen.UpdateEventMonitoredParams{
		ID:          eventID,
		IsMonitored: IsMonitored,
	})
}


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

func (s *Store) GetSportAndLeagueIDs(ctx context.Context, eventID int64) ([]int64, error) {
	sportAndLeagueIDs, err := s.queries.GetSportAndLeagueIDs(ctx, eventID)
	if err != nil {
		return nil, err
	}

	res := []int64{int64(sportAndLeagueIDs.SportID), sportAndLeagueIDs.LeagueID}
	return res, err
}