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

package sqlcgen

import (
	"context"
)

const addPlaylistTrack = `-- name: AddPlaylistTrack :one
INSERT INTO playlist_tracks (playlist_id, audio_file_id, position) VALUES (?, ?, ?)
RETURNING id, playlist_id, audio_file_id, position
`

type AddPlaylistTrackParams struct {
	PlaylistID  int64
	AudioFileID int64
	Position    int64
}

func (q *Queries) AddPlaylistTrack(ctx context.Context, arg AddPlaylistTrackParams) (PlaylistTrack, error) {
	row := q.db.QueryRowContext(ctx, addPlaylistTrack, arg.PlaylistID, arg.AudioFileID, arg.Position)
	var i PlaylistTrack
	err := row.Scan(
		&i.ID,
		&i.PlaylistID,
		&i.AudioFileID,
		&i.Position,
	)
	return i, err
}

const clearPlaylistTracks = `-- name: ClearPlaylistTracks :exec
DELETE FROM playlist_tracks WHERE playlist_id = ?
`

func (q *Queries) ClearPlaylistTracks(ctx context.Context, playlistID int64) error {
	_, err := q.db.ExecContext(ctx, clearPlaylistTracks, playlistID)
	return err
}

const createPlaylist = `-- name: CreatePlaylist :one
INSERT INTO playlists (name) VALUES (?)
RETURNING id, name, created_at, updated_at
`

func (q *Queries) CreatePlaylist(ctx context.Context, name string) (Playlist, error) {
	row := q.db.QueryRowContext(ctx, createPlaylist, name)
	var i Playlist
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteAllPlaylistTracks = `-- name: DeleteAllPlaylistTracks :exec
DELETE FROM playlist_tracks
`

func (q *Queries) DeleteAllPlaylistTracks(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, deleteAllPlaylistTracks)
	return err
}

const deletePlaylist = `-- name: DeletePlaylist :exec
DELETE FROM playlists WHERE id = ?
`

func (q *Queries) DeletePlaylist(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deletePlaylist, id)
	return err
}

const getAllPlaylistTracksWithMetadata = `-- name: GetAllPlaylistTracksWithMetadata :many
SELECT
    pt.id,
    pt.playlist_id,
    pt.audio_file_id,
    pt.position,
    af.file_path,
    af.length_milliseconds,
    COALESCE(r.name, '') AS title,
    COALESCE(ac.text, '') AS artist,
    COALESCE(rg.name, '') AS album,
    COALESCE(ca.file_path, '') AS cover_art_path
FROM playlist_tracks pt
JOIN audio_files af ON pt.audio_file_id = af.id
LEFT JOIN recordings r ON af.recording_id = r.id
LEFT JOIN artist_credit ac ON r.artist_credit_id = ac.id
LEFT JOIN (
    SELECT recording_id, MIN(release_group_id) AS release_group_id
    FROM release_group_recordings
    GROUP BY recording_id
) rgr ON r.id = rgr.recording_id
LEFT JOIN release_groups rg ON rgr.release_group_id = rg.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
ORDER BY pt.playlist_id, pt.position
`

type GetAllPlaylistTracksWithMetadataRow struct {
	ID                 int64
	PlaylistID         int64
	AudioFileID        int64
	Position           int64
	FilePath           string
	LengthMilliseconds int64
	Title              string
	Artist             string
	Album              string
	CoverArtPath       string
}

func (q *Queries) GetAllPlaylistTracksWithMetadata(ctx context.Context) ([]GetAllPlaylistTracksWithMetadataRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllPlaylistTracksWithMetadata)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllPlaylistTracksWithMetadataRow
	for rows.Next() {
		var i GetAllPlaylistTracksWithMetadataRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.LengthMilliseconds,
			&i.Title,
			&i.Artist,
			&i.Album,
			&i.CoverArtPath,
		); 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 getAllPlaylists = `-- name: GetAllPlaylists :many
SELECT id, name, created_at, updated_at FROM playlists ORDER BY updated_at DESC
`

func (q *Queries) GetAllPlaylists(ctx context.Context) ([]Playlist, error) {
	rows, err := q.db.QueryContext(ctx, getAllPlaylists)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Playlist
	for rows.Next() {
		var i Playlist
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.CreatedAt,
			&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 getNextPlaylistTrackPosition = `-- name: GetNextPlaylistTrackPosition :one
SELECT COALESCE(MAX(position), -1) + 1 AS next_position
FROM playlist_tracks WHERE playlist_id = ?
`

func (q *Queries) GetNextPlaylistTrackPosition(ctx context.Context, playlistID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, getNextPlaylistTrackPosition, playlistID)
	var next_position int64
	err := row.Scan(&next_position)
	return next_position, err
}

const getPlaylist = `-- name: GetPlaylist :one
SELECT id, name, created_at, updated_at FROM playlists WHERE id = ? LIMIT 1
`

func (q *Queries) GetPlaylist(ctx context.Context, id int64) (Playlist, error) {
	row := q.db.QueryRowContext(ctx, getPlaylist, id)
	var i Playlist
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPlaylistTrackFilePaths = `-- name: GetPlaylistTrackFilePaths :many
SELECT af.file_path
FROM playlist_tracks pt
JOIN audio_files af ON pt.audio_file_id = af.id
WHERE pt.playlist_id = ?
ORDER BY pt.position
`

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

const getPlaylistTracks = `-- name: GetPlaylistTracks :many
SELECT pt.id, pt.playlist_id, pt.audio_file_id, pt.position, af.file_path
FROM playlist_tracks pt
JOIN audio_files af ON pt.audio_file_id = af.id
WHERE pt.playlist_id = ?
ORDER BY pt.position
`

type GetPlaylistTracksRow struct {
	ID          int64
	PlaylistID  int64
	AudioFileID int64
	Position    int64
	FilePath    string
}

func (q *Queries) GetPlaylistTracks(ctx context.Context, playlistID int64) ([]GetPlaylistTracksRow, error) {
	rows, err := q.db.QueryContext(ctx, getPlaylistTracks, playlistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPlaylistTracksRow
	for rows.Next() {
		var i GetPlaylistTracksRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
		); 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 getPlaylistTracksWithMetadata = `-- name: GetPlaylistTracksWithMetadata :many
SELECT
    pt.id,
    pt.playlist_id,
    pt.audio_file_id,
    pt.position,
    af.file_path,
    af.length_milliseconds,
    COALESCE(r.name, '') AS title,
    COALESCE(ac.text, '') AS artist,
    COALESCE(rg.name, '') AS album,
    COALESCE(ca.file_path, '') AS cover_art_path
FROM playlist_tracks pt
JOIN audio_files af ON pt.audio_file_id = af.id
LEFT JOIN recordings r ON af.recording_id = r.id
LEFT JOIN artist_credit ac ON r.artist_credit_id = ac.id
LEFT JOIN (
    SELECT recording_id, MIN(release_group_id) AS release_group_id
    FROM release_group_recordings
    GROUP BY recording_id
) rgr ON r.id = rgr.recording_id
LEFT JOIN release_groups rg ON rgr.release_group_id = rg.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
WHERE pt.playlist_id = ?
ORDER BY pt.position
`

type GetPlaylistTracksWithMetadataRow struct {
	ID                 int64
	PlaylistID         int64
	AudioFileID        int64
	Position           int64
	FilePath           string
	LengthMilliseconds int64
	Title              string
	Artist             string
	Album              string
	CoverArtPath       string
}

func (q *Queries) GetPlaylistTracksWithMetadata(ctx context.Context, playlistID int64) ([]GetPlaylistTracksWithMetadataRow, error) {
	rows, err := q.db.QueryContext(ctx, getPlaylistTracksWithMetadata, playlistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPlaylistTracksWithMetadataRow
	for rows.Next() {
		var i GetPlaylistTracksWithMetadataRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.LengthMilliseconds,
			&i.Title,
			&i.Artist,
			&i.Album,
			&i.CoverArtPath,
		); 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 isTrackInPlaylist = `-- name: IsTrackInPlaylist :one
SELECT EXISTS(
    SELECT 1 FROM playlist_tracks pt
    JOIN audio_files af ON pt.audio_file_id = af.id
    WHERE pt.playlist_id = ? AND af.file_path = ?
) AS in_playlist
`

type IsTrackInPlaylistParams struct {
	PlaylistID int64
	FilePath   string
}

func (q *Queries) IsTrackInPlaylist(ctx context.Context, arg IsTrackInPlaylistParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, isTrackInPlaylist, arg.PlaylistID, arg.FilePath)
	var in_playlist int64
	err := row.Scan(&in_playlist)
	return in_playlist, err
}

const removePlaylistTrack = `-- name: RemovePlaylistTrack :exec
DELETE FROM playlist_tracks WHERE id = ?
`

func (q *Queries) RemovePlaylistTrack(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, removePlaylistTrack, id)
	return err
}

const removePlaylistTrackByPath = `-- name: RemovePlaylistTrackByPath :exec
DELETE FROM playlist_tracks
WHERE playlist_id = ? AND audio_file_id = (
    SELECT id FROM audio_files WHERE file_path = ?
)
`

type RemovePlaylistTrackByPathParams struct {
	PlaylistID int64
	FilePath   string
}

func (q *Queries) RemovePlaylistTrackByPath(ctx context.Context, arg RemovePlaylistTrackByPathParams) error {
	_, err := q.db.ExecContext(ctx, removePlaylistTrackByPath, arg.PlaylistID, arg.FilePath)
	return err
}

const updatePlaylistName = `-- name: UpdatePlaylistName :exec
UPDATE playlists SET name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
`

type UpdatePlaylistNameParams struct {
	Name string
	ID   int64
}

func (q *Queries) UpdatePlaylistName(ctx context.Context, arg UpdatePlaylistNameParams) error {
	_, err := q.db.ExecContext(ctx, updatePlaylistName, arg.Name, arg.ID)
	return err
}