-- name: StartTimeTracking :one
INSERT INTO time_entries (task_id, start_at) VALUES (?, ?)
RETURNING *;
-- name: StopTimeTracking :exec
UPDATE time_entries SET end_at = ? WHERE end_at IS NULL;
-- name: GetRunningTimer :one
SELECT start_at, task_id FROM time_entries WHERE end_at IS NULL;
-- name: EnterTimeEntry :one
INSERT INTO time_entries (task_id, start_at, end_at) VALUES (?, ?, ?)
RETURNING *;
-- name: UpdateTimeEntry :one
UPDATE time_entries SET task_id = ?, start_at = ?, end_at = ? WHERE id = ?
RETURNING *;
-- name: ListTimeEntries :many
SELECT start_at, end_at, task_id FROM time_entries WHERE ? BETWEEN start_at AND due_at;
-- name: TimeByTask :many
SELECT start_at, end_at FROM time_entries WHERE task_id = ?;

-- name: ScheduledTasks :many
WITH RECURSIVE rec_project_name(id, name, level) AS (
  SELECT id, name, 1 AS level FROM projects WHERE parent_id IS NULL
  UNION ALL
  SELECT
    projects.id,
    rec_project_name.name||' > '||projects.name,
    rec_project_name.level + 1
  FROM projects
  JOIN rec_project_name ON projects.parent_id = rec_project_name.id
)
SELECT tasks.id, tasks.name, project_id, planned_for, start_at, due_at, rec_project_name.name AS project_name, rec_project_name.level AS project_level
FROM tasks
JOIN rec_project_name ON tasks.project_id = rec_project_name.id
WHERE planned_for <= DATE() AND completed_at IS NULL ORDER BY planned_for, start_at NULLS LAST, due_at NULLS LAST;
-- name: StartTask :exec
UPDATE tasks SET start_at = IIF(start_at IS NULL, DATE(), start_at) WHERE id = ?;
-- name: GetTask :one
SELECT * FROM tasks WHERE id = ?;

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: time_entry.sql
package database
import (
	"context"
	"database/sql"
	"time"
)
const enterTimeEntry = `-- name: EnterTimeEntry :one
INSERT INTO time_entries (task_id, start_at, end_at) VALUES (?, ?, ?)
RETURNING id, start_at, end_at, task_id, created_at, updated_at, deleted_at
`
type EnterTimeEntryParams struct {
	TaskID  int64
	StartAt time.Time
	EndAt   sql.NullTime
}
func (q *Queries) EnterTimeEntry(ctx context.Context, arg EnterTimeEntryParams) (TimeEntry, error) {
	row := q.db.QueryRowContext(ctx, enterTimeEntry, arg.TaskID, arg.StartAt, arg.EndAt)
	var i TimeEntry
	err := row.Scan(
		&i.ID,
		&i.StartAt,
		&i.EndAt,
		&i.TaskID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}
const getRunningTimer = `-- name: GetRunningTimer :one
SELECT start_at, task_id FROM time_entries WHERE end_at IS NULL
`
type GetRunningTimerRow struct {
	StartAt time.Time
	TaskID  int64
}
func (q *Queries) GetRunningTimer(ctx context.Context) (GetRunningTimerRow, error) {
	row := q.db.QueryRowContext(ctx, getRunningTimer)
	var i GetRunningTimerRow
	err := row.Scan(&i.StartAt, &i.TaskID)
	return i, err
}
const listTimeEntries = `-- name: ListTimeEntries :many
SELECT start_at, end_at, task_id FROM time_entries WHERE ? BETWEEN start_at AND due_at
`
type ListTimeEntriesRow struct {
	StartAt time.Time
	EndAt   sql.NullTime
	TaskID  int64
}
func (q *Queries) ListTimeEntries(ctx context.Context) ([]ListTimeEntriesRow, error) {
	rows, err := q.db.QueryContext(ctx, listTimeEntries)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListTimeEntriesRow
	for rows.Next() {
		var i ListTimeEntriesRow
		if err := rows.Scan(&i.StartAt, &i.EndAt, &i.TaskID); 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 startTimeTracking = `-- name: StartTimeTracking :one
INSERT INTO time_entries (task_id, start_at) VALUES (?, ?)
RETURNING id, start_at, end_at, task_id, created_at, updated_at, deleted_at
`
type StartTimeTrackingParams struct {
	TaskID  int64
	StartAt time.Time
}
func (q *Queries) StartTimeTracking(ctx context.Context, arg StartTimeTrackingParams) (TimeEntry, error) {
	row := q.db.QueryRowContext(ctx, startTimeTracking, arg.TaskID, arg.StartAt)
	var i TimeEntry
	err := row.Scan(
		&i.ID,
		&i.StartAt,
		&i.EndAt,
		&i.TaskID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}
const stopTimeTracking = `-- name: StopTimeTracking :exec
UPDATE time_entries SET end_at = ? WHERE end_at IS NULL
`
func (q *Queries) StopTimeTracking(ctx context.Context, endAt sql.NullTime) error {
	_, err := q.db.ExecContext(ctx, stopTimeTracking, endAt)
	return err
}
const timeByTask = `-- name: TimeByTask :many
SELECT start_at, end_at FROM time_entries WHERE task_id = ?
`
type TimeByTaskRow struct {
	StartAt time.Time
	EndAt   sql.NullTime
}
func (q *Queries) TimeByTask(ctx context.Context, taskID int64) ([]TimeByTaskRow, error) {
	rows, err := q.db.QueryContext(ctx, timeByTask, taskID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []TimeByTaskRow
	for rows.Next() {
		var i TimeByTaskRow
		if err := rows.Scan(&i.StartAt, &i.EndAt); 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 updateTimeEntry = `-- name: UpdateTimeEntry :one
UPDATE time_entries SET task_id = ?, start_at = ?, end_at = ? WHERE id = ?
RETURNING id, start_at, end_at, task_id, created_at, updated_at, deleted_at
`
type UpdateTimeEntryParams struct {
	TaskID  int64
	StartAt time.Time
	EndAt   sql.NullTime
	ID      int64
}
func (q *Queries) UpdateTimeEntry(ctx context.Context, arg UpdateTimeEntryParams) (TimeEntry, error) {
	row := q.db.QueryRowContext(ctx, updateTimeEntry,
		arg.TaskID,
		arg.StartAt,
		arg.EndAt,
		arg.ID,
	)
	var i TimeEntry
	err := row.Scan(
		&i.ID,
		&i.StartAt,
		&i.EndAt,
		&i.TaskID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: tasks.sql
package database
import (
	"context"
	"database/sql"
)
const getTask = `-- name: GetTask :one
SELECT id, name, description, planned_for, start_at, due_at, completed_at, project_id, created_at, updated_at FROM tasks WHERE id = ?
`
func (q *Queries) GetTask(ctx context.Context, id int64) (Task, error) {
	row := q.db.QueryRowContext(ctx, getTask, id)
	var i Task
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.PlannedFor,
		&i.StartAt,
		&i.DueAt,
		&i.CompletedAt,
		&i.ProjectID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}
const scheduledTasks = `-- name: ScheduledTasks :many
WITH RECURSIVE rec_project_name(id, name, level) AS (
  SELECT id, name, 1 AS level FROM projects WHERE parent_id IS NULL
  UNION ALL
  SELECT
    projects.id,
    rec_project_name.name||' > '||projects.name,
    rec_project_name.level + 1
  FROM projects
  JOIN rec_project_name ON projects.parent_id = rec_project_name.id
)
SELECT tasks.id, tasks.name, project_id, planned_for, start_at, due_at, rec_project_name.name AS project_name, rec_project_name.level AS project_level
FROM tasks
JOIN rec_project_name ON tasks.project_id = rec_project_name.id
WHERE planned_for <= DATE() AND completed_at IS NULL ORDER BY planned_for, start_at NULLS LAST, due_at NULLS LAST
`
type ScheduledTasksRow struct {
	ID           int64
	Name         string
	ProjectID    int64
	PlannedFor   sql.NullTime
	StartAt      sql.NullTime
	DueAt        sql.NullTime
	ProjectName  string
	ProjectLevel int64
}
func (q *Queries) ScheduledTasks(ctx context.Context) ([]ScheduledTasksRow, error) {
	rows, err := q.db.QueryContext(ctx, scheduledTasks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ScheduledTasksRow
	for rows.Next() {
		var i ScheduledTasksRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.ProjectID,
			&i.PlannedFor,
			&i.StartAt,
			&i.DueAt,
			&i.ProjectName,
			&i.ProjectLevel,
		); 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 startTask = `-- name: StartTask :exec
UPDATE tasks SET start_at = IIF(start_at IS NULL, DATE(), start_at) WHERE id = ?
`
func (q *Queries) StartTask(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, startTask, id)
	return err
}