// Code generated placeholder for sqlc-style queries. DO NOT EDIT lightly.
package db

import (
	"context"
	"encoding/json"
	"time"

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

type DBTX interface {
	Exec(context.Context, string, ...any) (pgconn.CommandTag, error)
	Query(context.Context, string, ...any) (pgx.Rows, error)
	QueryRow(context.Context, string, ...any) pgx.Row
}

type Queries struct {
	db DBTX
}

func New(db DBTX) *Queries {
	return &Queries{db: db}
}

type Task struct {
	ID        string          `json:"id"`
	Title     string          `json:"title"`
	Source    string          `json:"source"`
	Status    string          `json:"status"`
	Payload   json.RawMessage `json:"payload"`
	Result    json.RawMessage `json:"result"`
	Error     *string         `json:"error,omitempty"`
	CreatedAt time.Time       `json:"created_at"`
	UpdatedAt time.Time       `json:"updated_at"`
}

type CreateTaskParams struct {
	Title   string          `json:"title"`
	Source  string          `json:"source"`
	Payload json.RawMessage `json:"payload"`
}

type UpdateTaskStatusParams struct {
	ID     string `json:"id"`
	Status string `json:"status"`
}

type CompleteTaskParams struct {
	ID     string          `json:"id"`
	Result json.RawMessage `json:"result"`
}

type FailTaskParams struct {
	ID    string `json:"id"`
	Error string `json:"error"`
}

const taskColumns = `
	id::text,
	title,
	source,
	status,
	payload,
	result,
	error,
	created_at,
	updated_at
`

func (q *Queries) CreateTask(ctx context.Context, arg CreateTaskParams) (Task, error) {
	row := q.db.QueryRow(ctx, `
		INSERT INTO tasks (title, source, payload)
		VALUES ($1, $2, $3)
		RETURNING `+taskColumns, arg.Title, arg.Source, arg.Payload)
	return scanTask(row)
}

func (q *Queries) GetTask(ctx context.Context, id string) (Task, error) {
	row := q.db.QueryRow(ctx, `
		SELECT `+taskColumns+`
		FROM tasks
		WHERE id::text = $1
	`, id)
	return scanTask(row)
}

func (q *Queries) ListTasks(ctx context.Context, limit int32) ([]Task, error) {
	rows, err := q.db.Query(ctx, `
		SELECT `+taskColumns+`
		FROM tasks
		ORDER BY created_at DESC
		LIMIT $1
	`, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var tasks []Task
	for rows.Next() {
		task, err := scanTask(rows)
		if err != nil {
			return nil, err
		}
		tasks = append(tasks, task)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}

	return tasks, nil
}

func (q *Queries) UpdateTaskStatus(ctx context.Context, arg UpdateTaskStatusParams) (Task, error) {
	row := q.db.QueryRow(ctx, `
		UPDATE tasks
		SET status = $2, updated_at = now()
		WHERE id::text = $1
		RETURNING `+taskColumns, arg.ID, arg.Status)
	return scanTask(row)
}

func (q *Queries) CompleteTask(ctx context.Context, arg CompleteTaskParams) (Task, error) {
	row := q.db.QueryRow(ctx, `
		UPDATE tasks
		SET status = 'completed', result = $2, error = NULL, updated_at = now()
		WHERE id::text = $1
		RETURNING `+taskColumns, arg.ID, arg.Result)
	return scanTask(row)
}

func (q *Queries) FailTask(ctx context.Context, arg FailTaskParams) (Task, error) {
	row := q.db.QueryRow(ctx, `
		UPDATE tasks
		SET status = 'failed', error = $2, updated_at = now()
		WHERE id::text = $1
		RETURNING `+taskColumns, arg.ID, arg.Error)
	return scanTask(row)
}

type taskScanner interface {
	Scan(dest ...any) error
}

func scanTask(row taskScanner) (Task, error) {
	var task Task
	err := row.Scan(
		&task.ID,
		&task.Title,
		&task.Source,
		&task.Status,
		&task.Payload,
		&task.Result,
		&task.Error,
		&task.CreatedAt,
		&task.UpdatedAt,
	)
	if err != nil {
		return Task{}, err
	}
	return task, nil
}