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

package repository

import (
	"context"
)

const addHashToSong = `-- name: AddHashToSong :exec
UPDATE song SET hash=$1 where path=$2
`

type AddHashToSongParams struct {
	Hash string `json:"hash"`
	Path string `json:"path"`
}

func (q *Queries) AddHashToSong(ctx context.Context, arg AddHashToSongParams) error {
	_, err := q.db.Exec(ctx, addHashToSong, arg.Hash, arg.Path)
	return err
}

const addSong = `-- name: AddSong :exec
INSERT INTO song(game_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5)
`

type AddSongParams struct {
	GameID   int32   `json:"game_id"`
	SongName string  `json:"song_name"`
	Path     string  `json:"path"`
	FileName *string `json:"file_name"`
	Hash     string  `json:"hash"`
}

func (q *Queries) AddSong(ctx context.Context, arg AddSongParams) error {
	_, err := q.db.Exec(ctx, addSong,
		arg.GameID,
		arg.SongName,
		arg.Path,
		arg.FileName,
		arg.Hash,
	)
	return err
}

const addSongPlayed = `-- name: AddSongPlayed :exec
UPDATE song SET times_played = times_played + 1
WHERE game_id = $1 AND song_name = $2
`

type AddSongPlayedParams struct {
	GameID   int32  `json:"game_id"`
	SongName string `json:"song_name"`
}

func (q *Queries) AddSongPlayed(ctx context.Context, arg AddSongPlayedParams) error {
	_, err := q.db.Exec(ctx, addSongPlayed, arg.GameID, arg.SongName)
	return err
}

const checkSong = `-- name: CheckSong :one
SELECT COUNT(*) FROM song WHERE path = $1
`

func (q *Queries) CheckSong(ctx context.Context, path string) (int64, error) {
	row := q.db.QueryRow(ctx, checkSong, path)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const checkSongWithHash = `-- name: CheckSongWithHash :one
SELECT COUNT(*) FROM song WHERE hash = $1
`

func (q *Queries) CheckSongWithHash(ctx context.Context, hash string) (int64, error) {
	row := q.db.QueryRow(ctx, checkSongWithHash, hash)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const clearSongs = `-- name: ClearSongs :exec
DELETE FROM song
`

func (q *Queries) ClearSongs(ctx context.Context) error {
	_, err := q.db.Exec(ctx, clearSongs)
	return err
}

const clearSongsByGameId = `-- name: ClearSongsByGameId :exec
DELETE FROM song WHERE game_id = $1
`

func (q *Queries) ClearSongsByGameId(ctx context.Context, gameID int32) error {
	_, err := q.db.Exec(ctx, clearSongsByGameId, gameID)
	return err
}

const fetchAllSongs = `-- name: FetchAllSongs :many
SELECT game_id, song_name, path, times_played, hash, file_name FROM song
`

func (q *Queries) FetchAllSongs(ctx context.Context) ([]Song, error) {
	rows, err := q.db.Query(ctx, fetchAllSongs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Song
	for rows.Next() {
		var i Song
		if err := rows.Scan(
			&i.GameID,
			&i.SongName,
			&i.Path,
			&i.TimesPlayed,
			&i.Hash,
			&i.FileName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const findSongsFromGame = `-- name: FindSongsFromGame :many
SELECT game_id, song_name, path, times_played, hash, file_name
FROM song
WHERE game_id = $1
`

func (q *Queries) FindSongsFromGame(ctx context.Context, gameID int32) ([]Song, error) {
	rows, err := q.db.Query(ctx, findSongsFromGame, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Song
	for rows.Next() {
		var i Song
		if err := rows.Scan(
			&i.GameID,
			&i.SongName,
			&i.Path,
			&i.TimesPlayed,
			&i.Hash,
			&i.FileName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSongWithHash = `-- name: GetSongWithHash :one
SELECT game_id, song_name, path, times_played, hash, file_name FROM song WHERE hash = $1
`

func (q *Queries) GetSongWithHash(ctx context.Context, hash string) (Song, error) {
	row := q.db.QueryRow(ctx, getSongWithHash, hash)
	var i Song
	err := row.Scan(
		&i.GameID,
		&i.SongName,
		&i.Path,
		&i.TimesPlayed,
		&i.Hash,
		&i.FileName,
	)
	return i, err
}

const removeBrokenSong = `-- name: RemoveBrokenSong :exec
DELETE FROM song WHERE path = $1
`

func (q *Queries) RemoveBrokenSong(ctx context.Context, path string) error {
	_, err := q.db.Exec(ctx, removeBrokenSong, path)
	return err
}

const removeBrokenSongs = `-- name: RemoveBrokenSongs :exec
DELETE FROM song where path = any ($1)
`

func (q *Queries) RemoveBrokenSongs(ctx context.Context, paths []string) error {
	_, err := q.db.Exec(ctx, removeBrokenSongs, paths)
	return err
}

const updateSong = `-- name: UpdateSong :exec
UPDATE song SET song_name=$1, file_name=$2, path=$3 where hash=$4
`

type UpdateSongParams struct {
	SongName string  `json:"song_name"`
	FileName *string `json:"file_name"`
	Path     string  `json:"path"`
	Hash     string  `json:"hash"`
}

func (q *Queries) UpdateSong(ctx context.Context, arg UpdateSongParams) error {
	_, err := q.db.Exec(ctx, updateSong,
		arg.SongName,
		arg.FileName,
		arg.Path,
		arg.Hash,
	)
	return err
}