// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: enet_pulse.sql

package dbgen

import (
	"context"

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

const CreateEnetpulseSport = `-- name: CreateEnetpulseSport :one
INSERT INTO enetpulse_sports (
    sport_id,
    name,
    updates_count,
    last_updated_at,
    status,
    updated_at
) VALUES (
    $1, $2, $3, $4, $5, NOW()
)
ON CONFLICT (sport_id) DO UPDATE
SET
    name = EXCLUDED.name,
    updates_count = EXCLUDED.updates_count,
    last_updated_at = EXCLUDED.last_updated_at,
    status = EXCLUDED.status,
    updated_at = NOW()
RETURNING id, sport_id, name, updates_count, last_updated_at, status, created_at, updated_at
`

type CreateEnetpulseSportParams struct {
	SportID       string             `json:"sport_id"`
	Name          string             `json:"name"`
	UpdatesCount  pgtype.Int4        `json:"updates_count"`
	LastUpdatedAt pgtype.Timestamptz `json:"last_updated_at"`
	Status        pgtype.Int4        `json:"status"`
}

func (q *Queries) CreateEnetpulseSport(ctx context.Context, arg CreateEnetpulseSportParams) (EnetpulseSport, error) {
	row := q.db.QueryRow(ctx, CreateEnetpulseSport,
		arg.SportID,
		arg.Name,
		arg.UpdatesCount,
		arg.LastUpdatedAt,
		arg.Status,
	)
	var i EnetpulseSport
	err := row.Scan(
		&i.ID,
		&i.SportID,
		&i.Name,
		&i.UpdatesCount,
		&i.LastUpdatedAt,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEnetpulseTournament = `-- name: CreateEnetpulseTournament :one
INSERT INTO enetpulse_tournaments (
    tournament_id,
    name,
    tournament_template_fk,
    updates_count,
    last_updated_at,
    status
) VALUES ($1, $2, $3, $4, $5, $6)
ON CONFLICT (tournament_id) DO UPDATE
SET
    name = EXCLUDED.name,
    tournament_template_fk = EXCLUDED.tournament_template_fk,
    updates_count = EXCLUDED.updates_count,
    last_updated_at = EXCLUDED.last_updated_at,
    status = EXCLUDED.status
RETURNING id, tournament_id, name, tournament_template_fk, updates_count, last_updated_at, status, created_at, updated_at
`

type CreateEnetpulseTournamentParams struct {
	TournamentID         string             `json:"tournament_id"`
	Name                 string             `json:"name"`
	TournamentTemplateFk string             `json:"tournament_template_fk"`
	UpdatesCount         pgtype.Int4        `json:"updates_count"`
	LastUpdatedAt        pgtype.Timestamptz `json:"last_updated_at"`
	Status               pgtype.Int4        `json:"status"`
}

func (q *Queries) CreateEnetpulseTournament(ctx context.Context, arg CreateEnetpulseTournamentParams) (EnetpulseTournament, error) {
	row := q.db.QueryRow(ctx, CreateEnetpulseTournament,
		arg.TournamentID,
		arg.Name,
		arg.TournamentTemplateFk,
		arg.UpdatesCount,
		arg.LastUpdatedAt,
		arg.Status,
	)
	var i EnetpulseTournament
	err := row.Scan(
		&i.ID,
		&i.TournamentID,
		&i.Name,
		&i.TournamentTemplateFk,
		&i.UpdatesCount,
		&i.LastUpdatedAt,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEnetpulseTournamentStage = `-- name: CreateEnetpulseTournamentStage :one
INSERT INTO enetpulse_tournament_stages (
    stage_id,
    name,
    tournament_fk,
    gender,
    country_fk,
    country_name,
    start_date,
    end_date,
    updates_count,
    last_updated_at,
    status
) VALUES (
    $1,  -- stage_id
    $2,  -- name
    $3,  -- tournament_fk
    $4,  -- gender
    $5,  -- country_fk
    $6,  -- country_name
    $7,  -- start_date
    $8,  -- end_date
    $9,  -- updates_count
    $10, -- last_updated_at
    $11  -- status
)
RETURNING id, stage_id, name, tournament_fk, gender, country_fk, country_name, start_date, end_date, updates_count, last_updated_at, status, created_at, updated_at
`

type CreateEnetpulseTournamentStageParams struct {
	StageID       string             `json:"stage_id"`
	Name          string             `json:"name"`
	TournamentFk  string             `json:"tournament_fk"`
	Gender        pgtype.Text        `json:"gender"`
	CountryFk     pgtype.Text        `json:"country_fk"`
	CountryName   pgtype.Text        `json:"country_name"`
	StartDate     pgtype.Timestamptz `json:"start_date"`
	EndDate       pgtype.Timestamptz `json:"end_date"`
	UpdatesCount  pgtype.Int4        `json:"updates_count"`
	LastUpdatedAt pgtype.Timestamptz `json:"last_updated_at"`
	Status        pgtype.Int4        `json:"status"`
}

func (q *Queries) CreateEnetpulseTournamentStage(ctx context.Context, arg CreateEnetpulseTournamentStageParams) (EnetpulseTournamentStage, error) {
	row := q.db.QueryRow(ctx, CreateEnetpulseTournamentStage,
		arg.StageID,
		arg.Name,
		arg.TournamentFk,
		arg.Gender,
		arg.CountryFk,
		arg.CountryName,
		arg.StartDate,
		arg.EndDate,
		arg.UpdatesCount,
		arg.LastUpdatedAt,
		arg.Status,
	)
	var i EnetpulseTournamentStage
	err := row.Scan(
		&i.ID,
		&i.StageID,
		&i.Name,
		&i.TournamentFk,
		&i.Gender,
		&i.CountryFk,
		&i.CountryName,
		&i.StartDate,
		&i.EndDate,
		&i.UpdatesCount,
		&i.LastUpdatedAt,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateEnetpulseTournamentTemplate = `-- name: CreateEnetpulseTournamentTemplate :one
INSERT INTO enetpulse_tournament_templates (
    template_id,
    name,
    sport_fk,
    gender,
    updates_count,
    last_updated_at,
    status,
    updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
ON CONFLICT (template_id) DO UPDATE
SET
    name = EXCLUDED.name,
    sport_fk = EXCLUDED.sport_fk,
    gender = EXCLUDED.gender,
    updates_count = EXCLUDED.updates_count,
    last_updated_at = EXCLUDED.last_updated_at,
    status = EXCLUDED.status,
    updated_at = NOW()
RETURNING id, template_id, name, sport_fk, gender, updates_count, last_updated_at, status, created_at, updated_at
`

type CreateEnetpulseTournamentTemplateParams struct {
	TemplateID    string             `json:"template_id"`
	Name          string             `json:"name"`
	SportFk       string             `json:"sport_fk"`
	Gender        pgtype.Text        `json:"gender"`
	UpdatesCount  pgtype.Int4        `json:"updates_count"`
	LastUpdatedAt pgtype.Timestamptz `json:"last_updated_at"`
	Status        pgtype.Int4        `json:"status"`
}

func (q *Queries) CreateEnetpulseTournamentTemplate(ctx context.Context, arg CreateEnetpulseTournamentTemplateParams) (EnetpulseTournamentTemplate, error) {
	row := q.db.QueryRow(ctx, CreateEnetpulseTournamentTemplate,
		arg.TemplateID,
		arg.Name,
		arg.SportFk,
		arg.Gender,
		arg.UpdatesCount,
		arg.LastUpdatedAt,
		arg.Status,
	)
	var i EnetpulseTournamentTemplate
	err := row.Scan(
		&i.ID,
		&i.TemplateID,
		&i.Name,
		&i.SportFk,
		&i.Gender,
		&i.UpdatesCount,
		&i.LastUpdatedAt,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetAllEnetpulseSports = `-- name: GetAllEnetpulseSports :many
SELECT
    id,
    sport_id,
    name,
    updates_count,
    last_updated_at,
    status,
    created_at,
    updated_at
FROM enetpulse_sports
ORDER BY name
`

func (q *Queries) GetAllEnetpulseSports(ctx context.Context) ([]EnetpulseSport, error) {
	rows, err := q.db.Query(ctx, GetAllEnetpulseSports)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EnetpulseSport
	for rows.Next() {
		var i EnetpulseSport
		if err := rows.Scan(
			&i.ID,
			&i.SportID,
			&i.Name,
			&i.UpdatesCount,
			&i.LastUpdatedAt,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllEnetpulseTournamentStages = `-- name: GetAllEnetpulseTournamentStages :many
SELECT id, stage_id, name, tournament_fk, gender, country_fk, country_name, start_date, end_date, updates_count, last_updated_at, status, created_at, updated_at
FROM enetpulse_tournament_stages
ORDER BY created_at DESC
`

func (q *Queries) GetAllEnetpulseTournamentStages(ctx context.Context) ([]EnetpulseTournamentStage, error) {
	rows, err := q.db.Query(ctx, GetAllEnetpulseTournamentStages)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EnetpulseTournamentStage
	for rows.Next() {
		var i EnetpulseTournamentStage
		if err := rows.Scan(
			&i.ID,
			&i.StageID,
			&i.Name,
			&i.TournamentFk,
			&i.Gender,
			&i.CountryFk,
			&i.CountryName,
			&i.StartDate,
			&i.EndDate,
			&i.UpdatesCount,
			&i.LastUpdatedAt,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllEnetpulseTournamentTemplates = `-- name: GetAllEnetpulseTournamentTemplates :many
SELECT 
    id,
    template_id,
    name,
    sport_fk,
    gender,
    updates_count,
    last_updated_at,
    status,
    created_at,
    updated_at
FROM enetpulse_tournament_templates
ORDER BY name
`

func (q *Queries) GetAllEnetpulseTournamentTemplates(ctx context.Context) ([]EnetpulseTournamentTemplate, error) {
	rows, err := q.db.Query(ctx, GetAllEnetpulseTournamentTemplates)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EnetpulseTournamentTemplate
	for rows.Next() {
		var i EnetpulseTournamentTemplate
		if err := rows.Scan(
			&i.ID,
			&i.TemplateID,
			&i.Name,
			&i.SportFk,
			&i.Gender,
			&i.UpdatesCount,
			&i.LastUpdatedAt,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllEnetpulseTournaments = `-- name: GetAllEnetpulseTournaments :many
SELECT id, tournament_id, name, tournament_template_fk, updates_count, last_updated_at, status, created_at, updated_at
FROM enetpulse_tournaments
ORDER BY created_at DESC
`

func (q *Queries) GetAllEnetpulseTournaments(ctx context.Context) ([]EnetpulseTournament, error) {
	rows, err := q.db.Query(ctx, GetAllEnetpulseTournaments)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EnetpulseTournament
	for rows.Next() {
		var i EnetpulseTournament
		if err := rows.Scan(
			&i.ID,
			&i.TournamentID,
			&i.Name,
			&i.TournamentTemplateFk,
			&i.UpdatesCount,
			&i.LastUpdatedAt,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetTournamentStagesByTournamentFK = `-- name: GetTournamentStagesByTournamentFK :many
SELECT id, stage_id, name, tournament_fk, gender, country_fk, country_name, start_date, end_date, updates_count, last_updated_at, status, created_at, updated_at
FROM enetpulse_tournament_stages
WHERE tournament_fk = $1
ORDER BY created_at DESC
`

func (q *Queries) GetTournamentStagesByTournamentFK(ctx context.Context, tournamentFk string) ([]EnetpulseTournamentStage, error) {
	rows, err := q.db.Query(ctx, GetTournamentStagesByTournamentFK, tournamentFk)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EnetpulseTournamentStage
	for rows.Next() {
		var i EnetpulseTournamentStage
		if err := rows.Scan(
			&i.ID,
			&i.StageID,
			&i.Name,
			&i.TournamentFk,
			&i.Gender,
			&i.CountryFk,
			&i.CountryName,
			&i.StartDate,
			&i.EndDate,
			&i.UpdatesCount,
			&i.LastUpdatedAt,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}