/**
 * block-content — pure content-shape helpers for text blocks.
 *
 * The editor's blank-area flow (page-view) needs three answers about a
 * block, and all of them must be DOM-free + deterministic (unit-testable
 * without a browser, per AGENTS.md "prefer deterministic behavior"):
 *
 *   1. `isAutoCleanableType(type)` — which block types the empty-block
 *      cleanup may touch (text-editable types only).
 *   2. `isContentEmpty(content)` — is the stored content empty?
 *   3. `isEmptyTextBlock(block)` — the full guard: text-editable type,
 *      NOT the page title, and empty content.
 *
 * WHY THE STRICT CONTENT CHECK (never guess "empty"):
 *   Deleting a block is irreversible. The stored `content` has exactly two
 *   shapes in the wild (see `InlineEditor.toHtml`):
 *
 *   - `string` — web edits store Tiptap HTML. Empty ⇔ no tags AND no
 *     non-whitespace text (`""`, `"<p></p>"`, `"<p><br></p>"`).
 *   - `{}` — the API/Prisma default for a freshly-created block (nothing
 *     ever typed). Empty: an object with no keys provably carries no data,
 *     so deleting/reusing it can lose nothing.
 *   - `{ text?: string }` / `{ title?: string }` — the API/AI canonical
 *     envelope (page-title block, blocks created via API/import/AI).
 *     Empty ⇔ no displayable text.
 *
 *   Any OTHER unrecognized object shape (tables, arrays, nested docs,
 *   non-empty objects) is treated as NON-EMPTY. A false negative just
 *   leaves a block around; a false positive deletes user data.
 *
 * WHY `isTitle` IS PROTECTED:
 *   Every page is seeded with a title block (a top-level `paragraph` with
 *   `properties.isTitle: true`, see page.service.ts `create`). It shares the
 *   top-level list with content blocks, so the type check alone cannot
 *   distinguish it — the flag must. Deleting it would orphan the page's
 *   title; the header already edits the title via `PATCH /pages/:id`.
 */

/**
 * Block types edited through the inline text editor (Tiptap) that may be
 * auto-cleaned. These are exactly the types rendered via `InlineEditor`,
 * which is where the `onEmptyBlur` hook + the shared caret-mover
 * (`focusBlockEditable`) attach.
 *
 * Deliberately EXCLUDED:
 *   - `toggle` — a toggle with no title text can still own CHILD blocks (a
 *     container — deleting it cascade-deletes its children), and its child
 *     rows are nested rows outside the top-level blank-area scope.
 *   - `code` — edited by `CodeBlock`'s own `<textarea>`, NOT `InlineEditor`,
 *     so neither the blur hook nor the caret-mover reach it; an empty code
 *     box also reads as a deliberate (if empty) artifact, not a stray
 *     input field.
 * Everything else non-text (image / media / table / database / structural)
 * is likewise excluded.
 */
const TEXT_LIKE_BLOCK_TYPES: ReadonlySet<string> = new Set([
  "paragraph",
  "heading_1",
  "heading_2",
  "heading_3",
  "bulleted_list",
  "numbered_list",
  "quote",
  "callout",
  "todo",
]);

/** True for text-editable types (the ones the empty-block cleanup may touch). */
export function isAutoCleanableType(type: string | undefined | null): boolean {
  return type !== undefined && type !== null && TEXT_LIKE_BLOCK_TYPES.has(type);
}

/** Strip HTML tags so a stored Tiptap HTML string is judged by its DATA. */
function stripTags(html: string): string {
  return html.replace(/<[^>]*>/g, "");
}

/**
 * Is a stored block `content` empty?
 *
 *   - `null` / `undefined` → empty (nothing stored).
 *   - HTML string → empty when it has no tags AND no non-whitespace text.
 *   - `{}` → empty (the freshly-created default — no keys, nothing to lose).
 *   - `{ text: "  " }` / `{ title: "" }` envelope → empty (whitespace-only
 *     counts as empty — nothing a user "typed").
 *   - `{ text: 42 }`, `{ checked: true }`, arrays, unknown objects… →
 *     NON-empty (no displayable text, but not a recognized empty shape —
 *     never guess).
 */
export function isContentEmpty(content: unknown): boolean {
  if (content === null || content === undefined) return true;
  if (typeof content === "string") return stripTags(content).trim() === "";
  if (typeof content === "object") {
    if (Array.isArray(content)) return false; // arrays are not a text shape — never guess
    const c = content as Record<string, unknown>;
    const raw = typeof c.text === "string" ? c.text : typeof c.title === "string" ? c.title : undefined;
    if (raw !== undefined) return raw.trim() === "";
    // `{}` — the freshly-created default — is empty (no keys, nothing to lose).
    if (Object.keys(c).length === 0) return true;
    // A non-empty unknown object shape (table, nested doc, …) — never guess.
    return false;
  }
  // Numbers / booleans are not displayable text; nothing to lose.
  return false;
}

export interface BlockLikeForEmptiness {
  type: string;
  content: unknown;
  properties?: { isTitle?: boolean } | null;
}

/**
 * The full empty-text-block guard (the delete-on-blur + click-reuse target):
 * a text-editable type, not the page title, with empty content.
 */
export function isEmptyTextBlock(block: BlockLikeForEmptiness): boolean {
  if (block.properties?.isTitle === true) return false;
  if (!isAutoCleanableType(block.type)) return false;
  return isContentEmpty(block.content);
}