// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: resources.sql

package db

import (
	"context"
	"time"

	"github.com/google/uuid"
	"github.com/lib/pq"
)

const countResourcesByOwner = `-- name: CountResourcesByOwner :one
SELECT COUNT(*) FROM resources
WHERE owner_id = $1 AND parent_resource_id IS NULL
`

func (q *Queries) CountResourcesByOwner(ctx context.Context, ownerID uuid.UUID) (int64, error) {
	row := q.db.QueryRowContext(ctx, countResourcesByOwner, ownerID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countResourcesByParentAndOwner = `-- name: CountResourcesByParentAndOwner :one
SELECT COUNT(*) FROM resources
WHERE parent_resource_id = $1 AND owner_id = $2
`

type CountResourcesByParentAndOwnerParams struct {
	ParentResourceID uuid.NullUUID `json:"parent_resource_id"`
	OwnerID          uuid.UUID     `json:"owner_id"`
}

func (q *Queries) CountResourcesByParentAndOwner(ctx context.Context, arg CountResourcesByParentAndOwnerParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, countResourcesByParentAndOwner, arg.ParentResourceID, arg.OwnerID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createFolder = `-- name: CreateFolder :one
INSERT INTO resources (name, is_folder, owner_id, parent_resource_id, created_at, updated_at)
VALUES ($1, true, $2, $3, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
RETURNING id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at
`

type CreateFolderParams struct {
	Name             string          `json:"name"`
	OwnerID          uuid.UUID       `json:"owner_id"`
	ParentResourceID uuid.NullUUID   `json:"parent_resource_id"`
}

func (q *Queries) CreateFolder(ctx context.Context, arg CreateFolderParams) (Resource, error) {
	row := q.db.QueryRowContext(ctx, createFolder, arg.Name, arg.OwnerID, arg.ParentResourceID)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.MimeType,
		&i.Size,
		&i.Checksum,
		&i.OcrText,
		&i.IsFolder,
		&i.ParentResourceID,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const createResource = `-- name: CreateResource :one
INSERT INTO resources (name, mime_type, size, checksum, owner_id, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
RETURNING id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at
`

type CreateResourceParams struct {
	Name     string    `json:"name"`
	MimeType string    `json:"mime_type"`
	Size     int64     `json:"size"`
	Checksum string    `json:"checksum"`
	OwnerID  uuid.UUID `json:"owner_id"`
}

func (q *Queries) CreateResource(ctx context.Context, arg CreateResourceParams) (Resource, error) {
	row := q.db.QueryRowContext(ctx, createResource,
		arg.Name,
		arg.MimeType,
		arg.Size,
		arg.Checksum,
		arg.OwnerID,
	)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.MimeType,
		&i.Size,
		&i.Checksum,
		&i.OcrText,
		&i.IsFolder,
		&i.ParentResourceID,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteResource = `-- name: DeleteResource :exec
DELETE FROM resources
WHERE id = $1
`

func (q *Queries) DeleteResource(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteResource, id)
	return err
}

const findDuplicateByChecksum = `-- name: FindDuplicateByChecksum :one
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE checksum = $1 AND is_folder = false AND owner_id = $2
LIMIT 1
`

type FindDuplicateByChecksumParams struct {
	Checksum string    `json:"checksum"`
	OwnerID  uuid.UUID `json:"owner_id"`
}

func (q *Queries) FindDuplicateByChecksum(ctx context.Context, arg FindDuplicateByChecksumParams) (Resource, error) {
	row := q.db.QueryRowContext(ctx, findDuplicateByChecksum, arg.Checksum, arg.OwnerID)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.MimeType,
		&i.Size,
		&i.Checksum,
		&i.OcrText,
		&i.IsFolder,
		&i.ParentResourceID,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const findDuplicatesByNameSize = `-- name: FindDuplicatesByNameSize :many
SELECT id, name, mime_type, size, checksum, created_at FROM resources
WHERE name = $1 AND size = $2 AND is_folder = false
ORDER BY created_at DESC
`

type FindDuplicatesByNameSizeParams struct {
	Name string `json:"name"`
	Size int64  `json:"size"`
}

type FindDuplicatesByNameSizeRow struct {
	ID        uuid.UUID `json:"id"`
	Name      string    `json:"name"`
	MimeType  string    `json:"mime_type"`
	Size      int64     `json:"size"`
	Checksum  string    `json:"checksum"`
	CreatedAt time.Time `json:"created_at"`
}

func (q *Queries) FindDuplicatesByNameSize(ctx context.Context, arg FindDuplicatesByNameSizeParams) ([]FindDuplicatesByNameSizeRow, error) {
	rows, err := q.db.QueryContext(ctx, findDuplicatesByNameSize, arg.Name, arg.Size)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []FindDuplicatesByNameSizeRow
	for rows.Next() {
		var i FindDuplicatesByNameSizeRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&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 getResource = `-- name: GetResource :one
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE id = $1 LIMIT 1
`

func (q *Queries) GetResource(ctx context.Context, id uuid.UUID) (Resource, error) {
	row := q.db.QueryRowContext(ctx, getResource, id)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.MimeType,
		&i.Size,
		&i.Checksum,
		&i.OcrText,
		&i.IsFolder,
		&i.ParentResourceID,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listFolders = `-- name: ListFolders :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE is_folder = true
ORDER BY created_at DESC
`

func (q *Queries) ListFolders(ctx context.Context) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listFolders)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 listResources = `-- name: ListResources :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE parent_resource_id IS NULL
ORDER BY is_folder DESC, created_at DESC
`

func (q *Queries) ListResources(ctx context.Context) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listResources)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 listResourcesByID = `-- name: ListResourcesByID :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE id = ANY($1::uuid[])
ORDER BY created_at DESC
`

func (q *Queries) ListResourcesByID(ctx context.Context, dollar_1 []uuid.UUID) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listResourcesByID, pq.Array(dollar_1))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 listResourcesByOwner = `-- name: ListResourcesByOwner :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE owner_id = $1 AND parent_resource_id IS NULL
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type ListResourcesByOwnerParams struct {
	OwnerID uuid.UUID `json:"owner_id"`
	Limit   int32     `json:"limit"`
	Offset  int32     `json:"offset"`
}

func (q *Queries) ListResourcesByOwner(ctx context.Context, arg ListResourcesByOwnerParams) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listResourcesByOwner, arg.OwnerID, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 listResourcesByParentAndOwner = `-- name: ListResourcesByParentAndOwner :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE parent_resource_id = $1 AND owner_id = $2
ORDER BY is_folder DESC, created_at DESC
LIMIT $3 OFFSET $4
`

type ListResourcesByParentAndOwnerParams struct {
	ParentResourceID uuid.NullUUID `json:"parent_resource_id"`
	OwnerID          uuid.UUID     `json:"owner_id"`
	Limit            int32         `json:"limit"`
	Offset           int32         `json:"offset"`
}

func (q *Queries) ListResourcesByParentAndOwner(ctx context.Context, arg ListResourcesByParentAndOwnerParams) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listResourcesByParentAndOwner,
		arg.ParentResourceID,
		arg.OwnerID,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 listResourcesByParentID = `-- name: ListResourcesByParentID :many
SELECT id, name, mime_type, size, checksum, ocr_text, is_folder, parent_resource_id, owner_id, created_at, updated_at FROM resources
WHERE parent_resource_id = $1
ORDER BY is_folder DESC, created_at DESC
`

func (q *Queries) ListResourcesByParentID(ctx context.Context, parentResourceID uuid.NullUUID) ([]Resource, error) {
	rows, err := q.db.QueryContext(ctx, listResourcesByParentID, parentResourceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Resource
	for rows.Next() {
		var i Resource
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.MimeType,
			&i.Size,
			&i.Checksum,
			&i.OcrText,
			&i.IsFolder,
			&i.ParentResourceID,
			&i.OwnerID,
			&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 moveResources = `-- name: MoveResources :exec
UPDATE resources
SET parent_resource_id = $1, updated_at = CURRENT_TIMESTAMP
WHERE id = ANY($2::uuid[])
`

type MoveResourcesParams struct {
	ParentResourceID uuid.NullUUID `json:"parent_resource_id"`
	Column2          []uuid.UUID   `json:"column_2"`
}

func (q *Queries) MoveResources(ctx context.Context, arg MoveResourcesParams) error {
	_, err := q.db.ExecContext(ctx, moveResources, arg.ParentResourceID, pq.Array(arg.Column2))
	return err
}

const updateResource = `-- name: UpdateResource :exec
UPDATE resources
SET name = $1, mime_type = $2, ocr_text = $3, updated_at = CURRENT_TIMESTAMP
WHERE id = $4
`

type UpdateResourceParams struct {
	Name     string    `json:"name"`
	MimeType string    `json:"mime_type"`
	OcrText  string    `json:"ocr_text"`
	ID       uuid.UUID `json:"id"`
}

func (q *Queries) UpdateResource(ctx context.Context, arg UpdateResourceParams) error {
	_, err := q.db.ExecContext(ctx, updateResource,
		arg.Name,
		arg.MimeType,
		arg.OcrText,
		arg.ID,
	)
	return err
}