// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: events.sql

package dbgen

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const GetAllUpcomingEvents = `-- name: GetAllUpcomingEvents :many
SELECT 
    id,
    sport_id,
    match_name,
    home_team,
    away_team,
    home_team_id,
    away_team_id,
    home_kit_image,
    away_kit_image,
    league_id,
    league_name,
    league_cc,
    start_time,
    is_live,
    status,
    fetched_at
FROM events
WHERE is_live = false
  AND status = 'upcoming'
ORDER BY start_time ASC
`

type GetAllUpcomingEventsRow struct {
	ID           string
	SportID      pgtype.Text
	MatchName    pgtype.Text
	HomeTeam     pgtype.Text
	AwayTeam     pgtype.Text
	HomeTeamID   pgtype.Text
	AwayTeamID   pgtype.Text
	HomeKitImage pgtype.Text
	AwayKitImage pgtype.Text
	LeagueID     pgtype.Text
	LeagueName   pgtype.Text
	LeagueCc     pgtype.Text
	StartTime    pgtype.Timestamp
	IsLive       pgtype.Bool
	Status       pgtype.Text
	FetchedAt    pgtype.Timestamp
}

func (q *Queries) GetAllUpcomingEvents(ctx context.Context) ([]GetAllUpcomingEventsRow, error) {
	rows, err := q.db.Query(ctx, GetAllUpcomingEvents)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllUpcomingEventsRow
	for rows.Next() {
		var i GetAllUpcomingEventsRow
		if err := rows.Scan(
			&i.ID,
			&i.SportID,
			&i.MatchName,
			&i.HomeTeam,
			&i.AwayTeam,
			&i.HomeTeamID,
			&i.AwayTeamID,
			&i.HomeKitImage,
			&i.AwayKitImage,
			&i.LeagueID,
			&i.LeagueName,
			&i.LeagueCc,
			&i.StartTime,
			&i.IsLive,
			&i.Status,
			&i.FetchedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetUpcomingByID = `-- name: GetUpcomingByID :one
SELECT 
    id,
    sport_id,
    match_name,
    home_team,
    away_team,
    home_team_id,
    away_team_id,
    home_kit_image,
    away_kit_image,
    league_id,
    league_name,
    league_cc,
    start_time,
    is_live,
    status,
    fetched_at
FROM events
WHERE id = $1
  AND is_live = false
  AND status = 'upcoming'
LIMIT 1
`

type GetUpcomingByIDRow struct {
	ID           string
	SportID      pgtype.Text
	MatchName    pgtype.Text
	HomeTeam     pgtype.Text
	AwayTeam     pgtype.Text
	HomeTeamID   pgtype.Text
	AwayTeamID   pgtype.Text
	HomeKitImage pgtype.Text
	AwayKitImage pgtype.Text
	LeagueID     pgtype.Text
	LeagueName   pgtype.Text
	LeagueCc     pgtype.Text
	StartTime    pgtype.Timestamp
	IsLive       pgtype.Bool
	Status       pgtype.Text
	FetchedAt    pgtype.Timestamp
}

func (q *Queries) GetUpcomingByID(ctx context.Context, id string) (GetUpcomingByIDRow, error) {
	row := q.db.QueryRow(ctx, GetUpcomingByID, id)
	var i GetUpcomingByIDRow
	err := row.Scan(
		&i.ID,
		&i.SportID,
		&i.MatchName,
		&i.HomeTeam,
		&i.AwayTeam,
		&i.HomeTeamID,
		&i.AwayTeamID,
		&i.HomeKitImage,
		&i.AwayKitImage,
		&i.LeagueID,
		&i.LeagueName,
		&i.LeagueCc,
		&i.StartTime,
		&i.IsLive,
		&i.Status,
		&i.FetchedAt,
	)
	return i, err
}

const InsertEvent = `-- name: InsertEvent :exec
INSERT INTO events (
    id, sport_id, match_name, home_team, away_team,
    home_team_id, away_team_id, home_kit_image, away_kit_image,
    league_id, league_name, league_cc, start_time, score,
    match_minute, timer_status, added_time, match_period,
    is_live, status
) VALUES (
    $1, $2, $3, $4, $5,
    $6, $7, $8, $9,
    $10, $11, $12, $13, $14,
    $15, $16, $17, $18,
    $19, $20
)
ON CONFLICT (id) DO UPDATE SET
    sport_id = EXCLUDED.sport_id,
    match_name = EXCLUDED.match_name,
    home_team = EXCLUDED.home_team,
    away_team = EXCLUDED.away_team,
    home_team_id = EXCLUDED.home_team_id,
    away_team_id = EXCLUDED.away_team_id,
    home_kit_image = EXCLUDED.home_kit_image,
    away_kit_image = EXCLUDED.away_kit_image,
    league_id = EXCLUDED.league_id,
    league_name = EXCLUDED.league_name,
    league_cc = EXCLUDED.league_cc,
    start_time = EXCLUDED.start_time,
    score = EXCLUDED.score,
    match_minute = EXCLUDED.match_minute,
    timer_status = EXCLUDED.timer_status,
    added_time = EXCLUDED.added_time,
    match_period = EXCLUDED.match_period,
    is_live = EXCLUDED.is_live,
    status = EXCLUDED.status,
    fetched_at = now()
`

type InsertEventParams struct {
	ID           string
	SportID      pgtype.Text
	MatchName    pgtype.Text
	HomeTeam     pgtype.Text
	AwayTeam     pgtype.Text
	HomeTeamID   pgtype.Text
	AwayTeamID   pgtype.Text
	HomeKitImage pgtype.Text
	AwayKitImage pgtype.Text
	LeagueID     pgtype.Text
	LeagueName   pgtype.Text
	LeagueCc     pgtype.Text
	StartTime    pgtype.Timestamp
	Score        pgtype.Text
	MatchMinute  pgtype.Int4
	TimerStatus  pgtype.Text
	AddedTime    pgtype.Int4
	MatchPeriod  pgtype.Int4
	IsLive       pgtype.Bool
	Status       pgtype.Text
}

func (q *Queries) InsertEvent(ctx context.Context, arg InsertEventParams) error {
	_, err := q.db.Exec(ctx, InsertEvent,
		arg.ID,
		arg.SportID,
		arg.MatchName,
		arg.HomeTeam,
		arg.AwayTeam,
		arg.HomeTeamID,
		arg.AwayTeamID,
		arg.HomeKitImage,
		arg.AwayKitImage,
		arg.LeagueID,
		arg.LeagueName,
		arg.LeagueCc,
		arg.StartTime,
		arg.Score,
		arg.MatchMinute,
		arg.TimerStatus,
		arg.AddedTime,
		arg.MatchPeriod,
		arg.IsLive,
		arg.Status,
	)
	return err
}

const InsertUpcomingEvent = `-- name: InsertUpcomingEvent :exec
INSERT INTO events (
    id, sport_id, match_name, home_team, away_team,
    home_team_id, away_team_id, home_kit_image, away_kit_image,
    league_id, league_name, league_cc, start_time,
    is_live, status
) VALUES (
    $1, $2, $3, $4, $5,
    $6, $7, $8, $9,
    $10, $11, $12, $13,
    false, 'upcoming'
)
ON CONFLICT (id) DO UPDATE SET
    sport_id = EXCLUDED.sport_id,
    match_name = EXCLUDED.match_name,
    home_team = EXCLUDED.home_team,
    away_team = EXCLUDED.away_team,
    home_team_id = EXCLUDED.home_team_id,
    away_team_id = EXCLUDED.away_team_id,
    home_kit_image = EXCLUDED.home_kit_image,
    away_kit_image = EXCLUDED.away_kit_image,
    league_id = EXCLUDED.league_id,
    league_name = EXCLUDED.league_name,
    league_cc = EXCLUDED.league_cc,
    start_time = EXCLUDED.start_time,
    is_live = false,
    status = 'upcoming',
    fetched_at = now()
`

type InsertUpcomingEventParams struct {
	ID           string
	SportID      pgtype.Text
	MatchName    pgtype.Text
	HomeTeam     pgtype.Text
	AwayTeam     pgtype.Text
	HomeTeamID   pgtype.Text
	AwayTeamID   pgtype.Text
	HomeKitImage pgtype.Text
	AwayKitImage pgtype.Text
	LeagueID     pgtype.Text
	LeagueName   pgtype.Text
	LeagueCc     pgtype.Text
	StartTime    pgtype.Timestamp
}

func (q *Queries) InsertUpcomingEvent(ctx context.Context, arg InsertUpcomingEventParams) error {
	_, err := q.db.Exec(ctx, InsertUpcomingEvent,
		arg.ID,
		arg.SportID,
		arg.MatchName,
		arg.HomeTeam,
		arg.AwayTeam,
		arg.HomeTeamID,
		arg.AwayTeamID,
		arg.HomeKitImage,
		arg.AwayKitImage,
		arg.LeagueID,
		arg.LeagueName,
		arg.LeagueCc,
		arg.StartTime,
	)
	return err
}

const ListLiveEvents = `-- name: ListLiveEvents :many
SELECT id FROM events WHERE is_live = true
`

func (q *Queries) ListLiveEvents(ctx context.Context) ([]string, error) {
	rows, err := q.db.Query(ctx, ListLiveEvents)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var id string
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}