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

package db

import (
	"context"

	"github.com/google/uuid"
)

const childResourceByName = `-- name: ChildResourceByName :one
SELECT id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions FROM resources WHERE parent = $1::uuid AND name = $2::text AND deleted IS NULL
`

type ChildResourceByNameParams struct {
	Parent uuid.UUID
	Name   string
}

func (q *Queries) ChildResourceByName(ctx context.Context, arg ChildResourceByNameParams) (Resource, error) {
	row := q.db.QueryRow(ctx, childResourceByName, arg.Parent, arg.Name)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Name,
		&i.Dir,
		&i.Created,
		&i.Modified,
		&i.Deleted,
		&i.ContentSize,
		&i.ContentType,
		&i.ContentSha256,
		&i.Permissions,
	)
	return i, err
}

const createResource = `-- name: CreateResource :one
INSERT INTO resources(
    id, parent, name, dir, content_type, content_sha256
) VALUES (
    $1::uuid, $2::uuid, $3::text, $4::boolean,
      CASE $4 WHEN TRUE THEN '' ELSE 'text/plain' END,
      CASE $4 WhEN TRUE THEN '' ELSE 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' END
) RETURNING id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions
`

type CreateResourceParams struct {
	ID     uuid.UUID
	Parent *uuid.UUID
	Name   string
	Dir    bool
}

func (q *Queries) CreateResource(ctx context.Context, arg CreateResourceParams) (Resource, error) {
	row := q.db.QueryRow(ctx, createResource,
		arg.ID,
		arg.Parent,
		arg.Name,
		arg.Dir,
	)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Name,
		&i.Dir,
		&i.Created,
		&i.Modified,
		&i.Deleted,
		&i.ContentSize,
		&i.ContentType,
		&i.ContentSha256,
		&i.Permissions,
	)
	return i, err
}

const deleteRecursive = `-- name: DeleteRecursive :many
WITH RECURSIVE nodes(id, parent) AS (
    SELECT r.id, r.parent
    FROM resources r WHERE r.id = $1::uuid
  UNION ALL
    SELECT r.id, r.parent
    FROM resources r JOIN nodes n on r.parent = n.id
    WHERE deleted IS NULL
)
UPDATE resources
SET modified = NOW(), deleted = NOW()
WHERE id in (SELECT id FROM nodes)
RETURNING id
`

func (q *Queries) DeleteRecursive(ctx context.Context, id uuid.UUID) ([]uuid.UUID, error) {
	rows, err := q.db.Query(ctx, deleteRecursive, id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []uuid.UUID
	for rows.Next() {
		var id uuid.UUID
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const diskUsage = `-- name: DiskUsage :one
WITH RECURSIVE nodes(id, parent, content_size, dir) AS (
    SELECT r.id, r.parent, r.content_size, r.dir
    FROM resources r WHERE r.id = $1::uuid
  UNION ALL
    SELECT r.id, r.parent, r.content_size, r.dir
    FROM resources r JOIN nodes n on r.parent = n.id
    WHERE deleted IS NULL
)
SELECT
  SUM(content_size) AS size,
  COUNT(*) AS entities,
  COUNT(CASE dir WHEN true THEN 1 ELSE NULL END) AS dirs,
  COUNT(CASE dir WHEN false THEN 1 ELSE NULL END) AS files
FROM nodes
`

type DiskUsageRow struct {
	Size     int64
	Entities int64
	Dirs     int64
	Files    int64
}

func (q *Queries) DiskUsage(ctx context.Context, id uuid.UUID) (DiskUsageRow, error) {
	row := q.db.QueryRow(ctx, diskUsage, id)
	var i DiskUsageRow
	err := row.Scan(
		&i.Size,
		&i.Entities,
		&i.Dirs,
		&i.Files,
	)
	return i, err
}

const hardDeleteRecursive = `-- name: HardDeleteRecursive :many
WITH RECURSIVE nodes(id, parent) AS (
    SELECT r.id, r.parent
    FROM resources r WHERE r.id = $1::uuid
  UNION ALL
    SELECT r.id, r.parent
    FROM resources r JOIN nodes n on r.parent = n.id
    WHERE deleted IS NULL
)
DELETE FROM resources
WHERE id in (SELECT id FROM nodes)
RETURNING id
`

func (q *Queries) HardDeleteRecursive(ctx context.Context, id uuid.UUID) ([]uuid.UUID, error) {
	rows, err := q.db.Query(ctx, hardDeleteRecursive, id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []uuid.UUID
	for rows.Next() {
		var id uuid.UUID
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const sharedResources = `-- name: SharedResources :many
SELECT id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions FROM resources WHERE permissions ? $1::text AND id <> $2::uuid AND deleted IS NULL
`

type SharedResourcesParams struct {
	Username string
	UserHome uuid.UUID
}

func (q *Queries) SharedResources(ctx context.Context, arg SharedResourcesParams) ([]Resource, error) {
	rows, err := q.db.Query(ctx, sharedResources, arg.Username, arg.UserHome)
	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.Parent,
			&i.Name,
			&i.Dir,
			&i.Created,
			&i.Modified,
			&i.Deleted,
			&i.ContentSize,
			&i.ContentType,
			&i.ContentSha256,
			&i.Permissions,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateResourceContents = `-- name: UpdateResourceContents :exec
UPDATE resources
SET
    content_size = $1,
    content_type = $2, 
    content_sha256 = $3,
    modified = NOW()
WHERE id = $4
`

type UpdateResourceContentsParams struct {
	ContentSize   int64
	ContentType   string
	ContentSha256 string
	ID            uuid.UUID
}

func (q *Queries) UpdateResourceContents(ctx context.Context, arg UpdateResourceContentsParams) error {
	_, err := q.db.Exec(ctx, updateResourceContents,
		arg.ContentSize,
		arg.ContentType,
		arg.ContentSha256,
		arg.ID,
	)
	return err
}

const updateResourceModified = `-- name: UpdateResourceModified :exec
UPDATE resources
SET
    modified = NOW()
WHERE id = $1
`

func (q *Queries) UpdateResourceModified(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, updateResourceModified, id)
	return err
}

const updateResourceName = `-- name: UpdateResourceName :one
UPDATE resources
SET
    name = CASE WHEN ($1::text = '') THEN name ELSE $1::text END,
    modified = NOW()
WHERE id = $2::uuid
RETURNING id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions
`

type UpdateResourceNameParams struct {
	Name string
	ID   uuid.UUID
}

func (q *Queries) UpdateResourceName(ctx context.Context, arg UpdateResourceNameParams) (Resource, error) {
	row := q.db.QueryRow(ctx, updateResourceName, arg.Name, arg.ID)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Name,
		&i.Dir,
		&i.Created,
		&i.Modified,
		&i.Deleted,
		&i.ContentSize,
		&i.ContentType,
		&i.ContentSha256,
		&i.Permissions,
	)
	return i, err
}

const updateResourceNameParent = `-- name: UpdateResourceNameParent :one
UPDATE resources
SET
    name = CASE WHEN ($1::text = '') THEN name ELSE $1::text END,
    parent = $2::uuid,
    modified = NOW()
WHERE id = $3::uuid
RETURNING id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions
`

type UpdateResourceNameParentParams struct {
	Name   string
	Parent uuid.UUID
	ID     uuid.UUID
}

func (q *Queries) UpdateResourceNameParent(ctx context.Context, arg UpdateResourceNameParentParams) (Resource, error) {
	row := q.db.QueryRow(ctx, updateResourceNameParent, arg.Name, arg.Parent, arg.ID)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Name,
		&i.Dir,
		&i.Created,
		&i.Modified,
		&i.Deleted,
		&i.ContentSize,
		&i.ContentType,
		&i.ContentSha256,
		&i.Permissions,
	)
	return i, err
}

const updateResourceParent = `-- name: UpdateResourceParent :one
UPDATE resources
SET
    parent = $1::uuid,
    modified = NOW()
WHERE id = $2::uuid
RETURNING id, parent, name, dir, created, modified, deleted, content_size, content_type, content_sha256, permissions
`

type UpdateResourceParentParams struct {
	Parent uuid.UUID
	ID     uuid.UUID
}

func (q *Queries) UpdateResourceParent(ctx context.Context, arg UpdateResourceParentParams) (Resource, error) {
	row := q.db.QueryRow(ctx, updateResourceParent, arg.Parent, arg.ID)
	var i Resource
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Name,
		&i.Dir,
		&i.Created,
		&i.Modified,
		&i.Deleted,
		&i.ContentSize,
		&i.ContentType,
		&i.ContentSha256,
		&i.Permissions,
	)
	return i, err
}