// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: snake_games.sql

package repository

import (
	"context"
	"time"
)

const createSnakePlayer = `-- name: CreateSnakePlayer :exec
INSERT INTO game_players (game_id, user_id, guest_player_id, nickname, color, slot)
VALUES (?, ?, ?, ?, ?, ?)
`

type CreateSnakePlayerParams struct {
	GameID        string  `db:"game_id" json:"game_id"`
	UserID        *string `db:"user_id" json:"user_id"`
	GuestPlayerID *string `db:"guest_player_id" json:"guest_player_id"`
	Nickname      string  `db:"nickname" json:"nickname"`
	Color         int64   `db:"color" json:"color"`
	Slot          int64   `db:"slot" json:"slot"`
}

func (q *Queries) CreateSnakePlayer(ctx context.Context, arg CreateSnakePlayerParams) error {
	_, err := q.db.ExecContext(ctx, createSnakePlayer,
		arg.GameID,
		arg.UserID,
		arg.GuestPlayerID,
		arg.Nickname,
		arg.Color,
		arg.Slot,
	)
	return err
}

const deleteSnakeGame = `-- name: DeleteSnakeGame :exec
DELETE FROM games WHERE id = ? AND game_type = 'snake'
`

func (q *Queries) DeleteSnakeGame(ctx context.Context, id string) error {
	_, err := q.db.ExecContext(ctx, deleteSnakeGame, id)
	return err
}

const getActiveSnakeGames = `-- name: GetActiveSnakeGames :many
SELECT id, board, current_turn, status, winner_user_id, winning_cells, created_at, updated_at, rematch_game_id, game_type, grid_width, grid_height, max_players, game_mode, score, snake_speed FROM games WHERE game_type = 'snake' AND status < 2 AND game_mode = 0
`

func (q *Queries) GetActiveSnakeGames(ctx context.Context) ([]*Game, error) {
	rows, err := q.db.QueryContext(ctx, getActiveSnakeGames)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*Game
	for rows.Next() {
		var i Game
		if err := rows.Scan(
			&i.ID,
			&i.Board,
			&i.CurrentTurn,
			&i.Status,
			&i.WinnerUserID,
			&i.WinningCells,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.RematchGameID,
			&i.GameType,
			&i.GridWidth,
			&i.GridHeight,
			&i.MaxPlayers,
			&i.GameMode,
			&i.Score,
			&i.SnakeSpeed,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSnakeGame = `-- name: GetSnakeGame :one
SELECT id, board, current_turn, status, winner_user_id, winning_cells, created_at, updated_at, rematch_game_id, game_type, grid_width, grid_height, max_players, game_mode, score, snake_speed FROM games WHERE id = ? AND game_type = 'snake'
`

func (q *Queries) GetSnakeGame(ctx context.Context, id string) (*Game, error) {
	row := q.db.QueryRowContext(ctx, getSnakeGame, id)
	var i Game
	err := row.Scan(
		&i.ID,
		&i.Board,
		&i.CurrentTurn,
		&i.Status,
		&i.WinnerUserID,
		&i.WinningCells,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.RematchGameID,
		&i.GameType,
		&i.GridWidth,
		&i.GridHeight,
		&i.MaxPlayers,
		&i.GameMode,
		&i.Score,
		&i.SnakeSpeed,
	)
	return &i, err
}

const getSnakePlayers = `-- name: GetSnakePlayers :many
SELECT game_id, user_id, guest_player_id, nickname, color, slot, created_at FROM game_players WHERE game_id = ? ORDER BY slot
`

func (q *Queries) GetSnakePlayers(ctx context.Context, gameID string) ([]*GamePlayer, error) {
	rows, err := q.db.QueryContext(ctx, getSnakePlayers, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*GamePlayer
	for rows.Next() {
		var i GamePlayer
		if err := rows.Scan(
			&i.GameID,
			&i.UserID,
			&i.GuestPlayerID,
			&i.Nickname,
			&i.Color,
			&i.Slot,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserActiveSnakeGames = `-- name: GetUserActiveSnakeGames :many
SELECT
    g.id,
    g.status,
    g.grid_width,
    g.grid_height,
    g.updated_at
FROM games g
JOIN game_players gp_user ON g.id = gp_user.game_id AND gp_user.user_id = ?
WHERE g.game_type = 'snake' AND g.status < 3
ORDER BY g.updated_at DESC
`

type GetUserActiveSnakeGamesRow struct {
	ID         string     `db:"id" json:"id"`
	Status     int64      `db:"status" json:"status"`
	GridWidth  *int64     `db:"grid_width" json:"grid_width"`
	GridHeight *int64     `db:"grid_height" json:"grid_height"`
	UpdatedAt  *time.Time `db:"updated_at" json:"updated_at"`
}

func (q *Queries) GetUserActiveSnakeGames(ctx context.Context, userID *string) ([]*GetUserActiveSnakeGamesRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserActiveSnakeGames, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*GetUserActiveSnakeGamesRow
	for rows.Next() {
		var i GetUserActiveSnakeGamesRow
		if err := rows.Scan(
			&i.ID,
			&i.Status,
			&i.GridWidth,
			&i.GridHeight,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const upsertSnakeGame = `-- name: UpsertSnakeGame :exec
INSERT INTO games (id, board, current_turn, status, game_type, grid_width, grid_height, max_players, game_mode, snake_speed, winner_user_id, rematch_game_id, score)
VALUES (?, ?, 0, ?, 'snake', ?, ?, 8, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
    board = excluded.board,
    status = excluded.status,
    winner_user_id = excluded.winner_user_id,
    rematch_game_id = excluded.rematch_game_id,
    score = excluded.score,
    updated_at = CURRENT_TIMESTAMP
`

type UpsertSnakeGameParams struct {
	ID            string  `db:"id" json:"id"`
	Board         string  `db:"board" json:"board"`
	Status        int64   `db:"status" json:"status"`
	GridWidth     *int64  `db:"grid_width" json:"grid_width"`
	GridHeight    *int64  `db:"grid_height" json:"grid_height"`
	GameMode      int64   `db:"game_mode" json:"game_mode"`
	SnakeSpeed    int64   `db:"snake_speed" json:"snake_speed"`
	WinnerUserID  *string `db:"winner_user_id" json:"winner_user_id"`
	RematchGameID *string `db:"rematch_game_id" json:"rematch_game_id"`
	Score         int64   `db:"score" json:"score"`
}

func (q *Queries) UpsertSnakeGame(ctx context.Context, arg UpsertSnakeGameParams) error {
	_, err := q.db.ExecContext(ctx, upsertSnakeGame,
		arg.ID,
		arg.Board,
		arg.Status,
		arg.GridWidth,
		arg.GridHeight,
		arg.GameMode,
		arg.SnakeSpeed,
		arg.WinnerUserID,
		arg.RematchGameID,
		arg.Score,
	)
	return err
}