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

package db

import (
	"context"

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

const archiveAllInbox = `-- name: ArchiveAllInbox :execrows
UPDATE inbox_item SET archived = true
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND archived = false
`

type ArchiveAllInboxParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	RecipientID pgtype.UUID `json:"recipient_id"`
}

func (q *Queries) ArchiveAllInbox(ctx context.Context, arg ArchiveAllInboxParams) (int64, error) {
	result, err := q.db.Exec(ctx, archiveAllInbox, arg.WorkspaceID, arg.RecipientID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const archiveAllReadInbox = `-- name: ArchiveAllReadInbox :execrows
UPDATE inbox_item SET archived = true
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND read = true AND archived = false
`

type ArchiveAllReadInboxParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	RecipientID pgtype.UUID `json:"recipient_id"`
}

func (q *Queries) ArchiveAllReadInbox(ctx context.Context, arg ArchiveAllReadInboxParams) (int64, error) {
	result, err := q.db.Exec(ctx, archiveAllReadInbox, arg.WorkspaceID, arg.RecipientID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const archiveCompletedInbox = `-- name: ArchiveCompletedInbox :execrows
UPDATE inbox_item i SET archived = true
WHERE i.workspace_id = $1 AND i.recipient_type = 'member' AND i.recipient_id = $2 AND i.archived = false
  AND i.issue_id IN (SELECT id FROM issue WHERE status IN ('done', 'cancelled'))
`

type ArchiveCompletedInboxParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	RecipientID pgtype.UUID `json:"recipient_id"`
}

func (q *Queries) ArchiveCompletedInbox(ctx context.Context, arg ArchiveCompletedInboxParams) (int64, error) {
	result, err := q.db.Exec(ctx, archiveCompletedInbox, arg.WorkspaceID, arg.RecipientID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const archiveInboxItem = `-- name: ArchiveInboxItem :one
UPDATE inbox_item SET archived = true
WHERE id = $1
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
`

func (q *Queries) ArchiveInboxItem(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
	row := q.db.QueryRow(ctx, archiveInboxItem, id)
	var i InboxItem
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.RecipientType,
		&i.RecipientID,
		&i.Type,
		&i.Severity,
		&i.IssueID,
		&i.Title,
		&i.Body,
		&i.Read,
		&i.Archived,
		&i.CreatedAt,
		&i.ActorType,
		&i.ActorID,
		&i.Details,
	)
	return i, err
}

const countUnreadInbox = `-- name: CountUnreadInbox :one
SELECT count(*) FROM inbox_item
WHERE workspace_id = $1 AND recipient_type = $2 AND recipient_id = $3 AND read = false AND archived = false
`

type CountUnreadInboxParams struct {
	WorkspaceID   pgtype.UUID `json:"workspace_id"`
	RecipientType string      `json:"recipient_type"`
	RecipientID   pgtype.UUID `json:"recipient_id"`
}

func (q *Queries) CountUnreadInbox(ctx context.Context, arg CountUnreadInboxParams) (int64, error) {
	row := q.db.QueryRow(ctx, countUnreadInbox, arg.WorkspaceID, arg.RecipientType, arg.RecipientID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createInboxItem = `-- name: CreateInboxItem :one
INSERT INTO inbox_item (
    workspace_id, recipient_type, recipient_id,
    type, severity, issue_id, title, body,
    actor_type, actor_id, details
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
`

type CreateInboxItemParams struct {
	WorkspaceID   pgtype.UUID `json:"workspace_id"`
	RecipientType string      `json:"recipient_type"`
	RecipientID   pgtype.UUID `json:"recipient_id"`
	Type          string      `json:"type"`
	Severity      string      `json:"severity"`
	IssueID       pgtype.UUID `json:"issue_id"`
	Title         string      `json:"title"`
	Body          pgtype.Text `json:"body"`
	ActorType     pgtype.Text `json:"actor_type"`
	ActorID       pgtype.UUID `json:"actor_id"`
	Details       []byte      `json:"details"`
}

func (q *Queries) CreateInboxItem(ctx context.Context, arg CreateInboxItemParams) (InboxItem, error) {
	row := q.db.QueryRow(ctx, createInboxItem,
		arg.WorkspaceID,
		arg.RecipientType,
		arg.RecipientID,
		arg.Type,
		arg.Severity,
		arg.IssueID,
		arg.Title,
		arg.Body,
		arg.ActorType,
		arg.ActorID,
		arg.Details,
	)
	var i InboxItem
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.RecipientType,
		&i.RecipientID,
		&i.Type,
		&i.Severity,
		&i.IssueID,
		&i.Title,
		&i.Body,
		&i.Read,
		&i.Archived,
		&i.CreatedAt,
		&i.ActorType,
		&i.ActorID,
		&i.Details,
	)
	return i, err
}

const getInboxItem = `-- name: GetInboxItem :one
SELECT id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details FROM inbox_item
WHERE id = $1
`

func (q *Queries) GetInboxItem(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
	row := q.db.QueryRow(ctx, getInboxItem, id)
	var i InboxItem
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.RecipientType,
		&i.RecipientID,
		&i.Type,
		&i.Severity,
		&i.IssueID,
		&i.Title,
		&i.Body,
		&i.Read,
		&i.Archived,
		&i.CreatedAt,
		&i.ActorType,
		&i.ActorID,
		&i.Details,
	)
	return i, err
}

const getInboxItemInWorkspace = `-- name: GetInboxItemInWorkspace :one
SELECT id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details FROM inbox_item
WHERE id = $1 AND workspace_id = $2
`

type GetInboxItemInWorkspaceParams struct {
	ID          pgtype.UUID `json:"id"`
	WorkspaceID pgtype.UUID `json:"workspace_id"`
}

func (q *Queries) GetInboxItemInWorkspace(ctx context.Context, arg GetInboxItemInWorkspaceParams) (InboxItem, error) {
	row := q.db.QueryRow(ctx, getInboxItemInWorkspace, arg.ID, arg.WorkspaceID)
	var i InboxItem
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.RecipientType,
		&i.RecipientID,
		&i.Type,
		&i.Severity,
		&i.IssueID,
		&i.Title,
		&i.Body,
		&i.Read,
		&i.Archived,
		&i.CreatedAt,
		&i.ActorType,
		&i.ActorID,
		&i.Details,
	)
	return i, err
}

const listInboxItems = `-- name: ListInboxItems :many
SELECT i.id, i.workspace_id, i.recipient_type, i.recipient_id, i.type, i.severity, i.issue_id, i.title, i.body, i.read, i.archived, i.created_at, i.actor_type, i.actor_id, i.details,
       iss.status as issue_status
FROM inbox_item i
LEFT JOIN issue iss ON iss.id = i.issue_id
WHERE i.workspace_id = $1 AND i.recipient_type = $2 AND i.recipient_id = $3 AND i.archived = false
ORDER BY i.created_at DESC
LIMIT $4 OFFSET $5
`

type ListInboxItemsParams struct {
	WorkspaceID   pgtype.UUID `json:"workspace_id"`
	RecipientType string      `json:"recipient_type"`
	RecipientID   pgtype.UUID `json:"recipient_id"`
	Limit         int32       `json:"limit"`
	Offset        int32       `json:"offset"`
}

type ListInboxItemsRow struct {
	ID            pgtype.UUID        `json:"id"`
	WorkspaceID   pgtype.UUID        `json:"workspace_id"`
	RecipientType string             `json:"recipient_type"`
	RecipientID   pgtype.UUID        `json:"recipient_id"`
	Type          string             `json:"type"`
	Severity      string             `json:"severity"`
	IssueID       pgtype.UUID        `json:"issue_id"`
	Title         string             `json:"title"`
	Body          pgtype.Text        `json:"body"`
	Read          bool               `json:"read"`
	Archived      bool               `json:"archived"`
	CreatedAt     pgtype.Timestamptz `json:"created_at"`
	ActorType     pgtype.Text        `json:"actor_type"`
	ActorID       pgtype.UUID        `json:"actor_id"`
	Details       []byte             `json:"details"`
	IssueStatus   pgtype.Text        `json:"issue_status"`
}

func (q *Queries) ListInboxItems(ctx context.Context, arg ListInboxItemsParams) ([]ListInboxItemsRow, error) {
	rows, err := q.db.Query(ctx, listInboxItems,
		arg.WorkspaceID,
		arg.RecipientType,
		arg.RecipientID,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListInboxItemsRow{}
	for rows.Next() {
		var i ListInboxItemsRow
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.RecipientType,
			&i.RecipientID,
			&i.Type,
			&i.Severity,
			&i.IssueID,
			&i.Title,
			&i.Body,
			&i.Read,
			&i.Archived,
			&i.CreatedAt,
			&i.ActorType,
			&i.ActorID,
			&i.Details,
			&i.IssueStatus,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const markAllInboxRead = `-- name: MarkAllInboxRead :execrows
UPDATE inbox_item SET read = true
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND archived = false AND read = false
`

type MarkAllInboxReadParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	RecipientID pgtype.UUID `json:"recipient_id"`
}

func (q *Queries) MarkAllInboxRead(ctx context.Context, arg MarkAllInboxReadParams) (int64, error) {
	result, err := q.db.Exec(ctx, markAllInboxRead, arg.WorkspaceID, arg.RecipientID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const markInboxRead = `-- name: MarkInboxRead :one
UPDATE inbox_item SET read = true
WHERE id = $1
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
`

func (q *Queries) MarkInboxRead(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
	row := q.db.QueryRow(ctx, markInboxRead, id)
	var i InboxItem
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.RecipientType,
		&i.RecipientID,
		&i.Type,
		&i.Severity,
		&i.IssueID,
		&i.Title,
		&i.Body,
		&i.Read,
		&i.Archived,
		&i.CreatedAt,
		&i.ActorType,
		&i.ActorID,
		&i.Details,
	)
	return i, err
}