package repository

import (
	"context"
	"fmt"
	"math"
	"strconv"

	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) 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:         filter.Offset.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
	}

	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
	}

	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(),
		IsFeatured:     filter.Featured.ToPG(),
		IsActive:       filter.Active.ToPG(),
		IsLive:         filter.IsLive.ToPG(),
		Status:         filter.Status.ToPG(),
		Source:         filter.Source.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(),
		IsFeatured:     filter.Featured.ToPG(),
		IsActive:       filter.Active.ToPG(),
		IsLive:         filter.IsLive.ToPG(),
		Status:         filter.Status.ToPG(),
		Source:         filter.Source.ToPG(),
	})
	if err != nil {
		return nil, 0, err
	}

	numberOfPages := math.Ceil(float64(totalCount) / float64(filter.Limit.Value))

	result := make([]domain.EventWithSettings, len(events))

	for i, event := range events {
		result[i] = domain.EventWithSettings{
			ID:            event.ID,
			SportID:       event.SportID,
			MatchName:     event.MatchName,
			HomeTeam:      event.HomeTeam,
			AwayTeam:      event.AwayTeam,
			HomeTeamID:    event.HomeTeamID,
			AwayTeamID:    event.AwayTeamID,
			HomeTeamImage: event.HomeKitImage,
			AwayTeamImage: event.AwayKitImage,
			LeagueID:      event.LeagueID,
			LeagueName:    event.LeagueName,
			LeagueCC: domain.ValidString{
				Value: event.LeagueCc.String,
				Valid: event.LeagueCc.Valid,
			},
			StartTime:                event.StartTime.Time.UTC(),
			Source:                   domain.EventSource(event.Source),
			Status:                   domain.EventStatus(event.Status),
			IsFeatured:               event.IsFeatured,
			IsMonitored:              event.IsMonitored,
			IsActive:                 event.IsActive,
			DefaultIsFeatured:        event.DefaultIsFeatured,
			DefaultIsActive:          event.DefaultIsActive,
			DefaultWinningUpperLimit: event.DefaultWinningUpperLimit,
			Score: domain.ValidString{
				Value: event.Score.String,
				Valid: event.Score.Valid,
			},
			MatchMinute: domain.ValidInt{
				Value: int(event.MatchMinute.Int32),
				Valid: event.MatchMinute.Valid,
			},
			TimerStatus: domain.ValidString{
				Value: event.TimerStatus.String,
				Valid: event.TimerStatus.Valid,
			},
			AddedTime: domain.ValidInt{
				Value: int(event.AddedTime.Int32),
				Valid: event.AddedTime.Valid,
			},
			MatchPeriod: domain.ValidInt{
				Value: int(event.MatchPeriod.Int32),
				Valid: event.MatchPeriod.Valid,
			},
			IsLive:    event.IsLive,
			UpdatedAt: event.UpdatedAt.Time,
			FetchedAt: event.FetchedAt.Time,
		}
	}

	return result, int64(numberOfPages), 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) GetEventWithSettingByID(ctx context.Context, ID int64, companyID int64) (domain.EventWithSettings, error) {
	event, err := s.queries.GetEventWithSettingByID(ctx, dbgen.GetEventWithSettingByIDParams{
		ID:        ID,
		CompanyID: companyID,
	})
	if err != nil {
		return domain.EventWithSettings{}, err
	}

	res := domain.EventWithSettings{
		ID:            event.ID,
		SportID:       event.SportID,
		MatchName:     event.MatchName,
		HomeTeam:      event.HomeTeam,
		AwayTeam:      event.AwayTeam,
		HomeTeamID:    event.HomeTeamID,
		AwayTeamID:    event.AwayTeamID,
		HomeTeamImage: event.HomeKitImage,
		AwayTeamImage: event.AwayKitImage,
		LeagueID:      event.LeagueID,
		LeagueName:    event.LeagueName,
		LeagueCC: domain.ValidString{
			Value: event.LeagueCc.String,
			Valid: event.LeagueCc.Valid,
		},
		StartTime:                event.StartTime.Time.UTC(),
		Source:                   domain.EventSource(event.Source),
		Status:                   domain.EventStatus(event.Status),
		IsFeatured:               event.IsFeatured,
		IsMonitored:              event.IsMonitored,
		IsActive:                 event.IsActive,
		DefaultIsFeatured:        event.DefaultIsFeatured,
		DefaultIsActive:          event.DefaultIsActive,
		DefaultWinningUpperLimit: event.DefaultWinningUpperLimit,
		Score: domain.ValidString{
			Value: event.Score.String,
			Valid: event.Score.Valid,
		},
		MatchMinute: domain.ValidInt{
			Value: int(event.MatchMinute.Int32),
			Valid: event.MatchMinute.Valid,
		},
		TimerStatus: domain.ValidString{
			Value: event.TimerStatus.String,
			Valid: event.TimerStatus.Valid,
		},
		AddedTime: domain.ValidInt{
			Value: int(event.AddedTime.Int32),
			Valid: event.AddedTime.Valid,
		},
		MatchPeriod: domain.ValidInt{
			Value: int(event.MatchPeriod.Int32),
			Valid: event.MatchPeriod.Valid,
		},
		IsLive:    event.IsLive,
		UpdatedAt: event.UpdatedAt.Time,
		FetchedAt: event.FetchedAt.Time,
	}
	return res, 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) UpdateEventSettings(ctx context.Context, event domain.CreateEventSettings) error {
	return s.queries.SaveEventSettings(ctx, domain.ConvertUpdateEventSettings(event))
}

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 string) ([]int64, error) {
	id, err := strconv.ParseInt(eventID, 10, 64)
	if err != nil {
		return nil, fmt.Errorf("invalid eventID: %v", err)
	}
	sportAndLeagueIDs, err := s.queries.GetSportAndLeagueIDs(ctx, id)
	if err != nil {
		return nil, err
	}

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