import { describe, it, expect } from 'vitest';
import { convertMarkdownToRequests } from './markdownToDocs.js';
import { docsJsonToMarkdown } from './docsToMarkdown.js';

// ============================================================
// Markdown -> Google Docs Requests
// ============================================================

describe('Markdown to Docs Conversion', () => {
  describe('Basic Text Formatting', () => {
    it('should convert bold text', () => {
      const requests = convertMarkdownToRequests('**bold text**', 1);

      const insertReq = requests.find((r) => r.insertText);
      expect(insertReq).toBeDefined();
      expect(insertReq!.insertText!.text).toBe('bold text');

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.textStyle!.bold).toBe(true);
    });

    it('should convert italic text', () => {
      const requests = convertMarkdownToRequests('*italic text*', 1);

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.textStyle!.italic).toBe(true);
    });

    it('should convert strikethrough text', () => {
      const requests = convertMarkdownToRequests('~~strikethrough text~~', 1);

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.textStyle!.strikethrough).toBe(true);
    });

    it('should convert nested bold and italic', () => {
      const requests = convertMarkdownToRequests('***bold italic***', 1);

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.textStyle!.bold).toBe(true);
      expect(styleReq!.updateTextStyle!.textStyle!.italic).toBe(true);
    });

    it('should style inline code as monospace', () => {
      const requests = convertMarkdownToRequests('Use `inline_code` here', 1);

      const styleReqs = requests.filter((r) => r.updateTextStyle);
      const codeStyleReq = styleReqs.find(
        (r) => r.updateTextStyle!.textStyle!.weightedFontFamily?.fontFamily === 'Roboto Mono'
      );
      expect(codeStyleReq).toBeDefined();
    });
  });

  describe('Links', () => {
    it('should convert basic links', () => {
      const requests = convertMarkdownToRequests('[link text](https://example.com)', 1);

      const insertReq = requests.find((r) => r.insertText);
      expect(insertReq).toBeDefined();
      expect(insertReq!.insertText!.text).toBe('link text');

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.textStyle!.link!.url).toBe('https://example.com');
    });
  });

  describe('Headings', () => {
    it('should convert H1', () => {
      const requests = convertMarkdownToRequests('# Heading 1', 1);

      const insertReq = requests.find((r) => r.insertText && r.insertText.text === 'Heading 1');
      expect(insertReq).toBeDefined();

      const paraReq = requests.find((r) => r.updateParagraphStyle);
      expect(paraReq).toBeDefined();
      expect(paraReq!.updateParagraphStyle!.paragraphStyle!.namedStyleType).toBe('HEADING_1');
    });

    it('should convert H2', () => {
      const requests = convertMarkdownToRequests('## Heading 2', 1);

      const paraReq = requests.find((r) => r.updateParagraphStyle);
      expect(paraReq).toBeDefined();
      expect(paraReq!.updateParagraphStyle!.paragraphStyle!.namedStyleType).toBe('HEADING_2');
    });

    it('should convert H3', () => {
      const requests = convertMarkdownToRequests('### Heading 3', 1);

      const paraReq = requests.find((r) => r.updateParagraphStyle);
      expect(paraReq).toBeDefined();
      expect(paraReq!.updateParagraphStyle!.paragraphStyle!.namedStyleType).toBe('HEADING_3');
    });
  });

  describe('firstHeadingAsTitle option', () => {
    it('should style the first H1 as TITLE when enabled', () => {
      const requests = convertMarkdownToRequests(
        '# My Document Title\n\nSome body text.',
        1,
        undefined,
        {
          firstHeadingAsTitle: true,
        }
      );

      const paraReqs = requests.filter((r) => r.updateParagraphStyle);
      const titleReq = paraReqs.find(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'TITLE'
      );
      expect(titleReq).toBeDefined();

      // Should NOT have a HEADING_1
      const h1Req = paraReqs.find(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'HEADING_1'
      );
      expect(h1Req).toBeUndefined();
    });

    it('should only convert the first H1 to TITLE, not subsequent H1s', () => {
      const markdown = '# Title\n\n# Second H1\n\nSome text.';
      const requests = convertMarkdownToRequests(markdown, 1, undefined, {
        firstHeadingAsTitle: true,
      });

      const paraReqs = requests.filter((r) => r.updateParagraphStyle);
      const titleReqs = paraReqs.filter(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'TITLE'
      );
      const h1Reqs = paraReqs.filter(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'HEADING_1'
      );

      expect(titleReqs).toHaveLength(1);
      expect(h1Reqs).toHaveLength(1);
    });

    it('should leave H1 as HEADING_1 when option is disabled (default)', () => {
      const requests = convertMarkdownToRequests('# Heading 1', 1);

      const paraReq = requests.find((r) => r.updateParagraphStyle);
      expect(paraReq).toBeDefined();
      expect(paraReq!.updateParagraphStyle!.paragraphStyle!.namedStyleType).toBe('HEADING_1');
    });

    it('should not affect H2+ headings when enabled', () => {
      const markdown = '## Section\n\n### Subsection';
      const requests = convertMarkdownToRequests(markdown, 1, undefined, {
        firstHeadingAsTitle: true,
      });

      const paraReqs = requests.filter((r) => r.updateParagraphStyle);
      const titleReqs = paraReqs.filter(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'TITLE'
      );
      expect(titleReqs).toHaveLength(0);

      const h2 = paraReqs.find(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'HEADING_2'
      );
      const h3 = paraReqs.find(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'HEADING_3'
      );
      expect(h2).toBeDefined();
      expect(h3).toBeDefined();
    });

    it('should handle a full document with title, headings, and lists', () => {
      const markdown = [
        '# Project Plan',
        '',
        '## Overview',
        '',
        'This is the overview.',
        '',
        '## Tasks',
        '',
        '- Task 1',
        '- Task 2',
      ].join('\n');

      const requests = convertMarkdownToRequests(markdown, 1, undefined, {
        firstHeadingAsTitle: true,
      });

      const paraReqs = requests.filter((r) => r.updateParagraphStyle);
      const titleReqs = paraReqs.filter(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'TITLE'
      );
      const h2Reqs = paraReqs.filter(
        (r) => r.updateParagraphStyle!.paragraphStyle!.namedStyleType === 'HEADING_2'
      );

      expect(titleReqs).toHaveLength(1);
      expect(h2Reqs).toHaveLength(2);
    });
  });

  describe('Lists', () => {
    it('should convert bullet lists', () => {
      const requests = convertMarkdownToRequests('- Item 1\n- Item 2\n- Item 3', 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      expect(bulletReqs).toHaveLength(1);
      expect(bulletReqs[0].createParagraphBullets!.bulletPreset).toBe('BULLET_DISC_CIRCLE_SQUARE');
    });

    it('should convert numbered lists', () => {
      const requests = convertMarkdownToRequests('1. Item 1\n2. Item 2\n3. Item 3', 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      expect(bulletReqs).toHaveLength(1);
      expect(bulletReqs[0].createParagraphBullets!.bulletPreset).toBe(
        'NUMBERED_DECIMAL_ALPHA_ROMAN'
      );
    });

    it('should preserve nested list levels with leading tabs', () => {
      const requests = convertMarkdownToRequests('- Parent\n  - Child', 1);

      const insertReqs = requests.filter((r) => r.insertText);
      expect(insertReqs.some((r) => r.insertText!.text!.includes('Parent'))).toBe(true);
      expect(insertReqs.some((r) => r.insertText!.text === '\t')).toBe(true);
      expect(insertReqs.some((r) => r.insertText!.text!.includes('Child'))).toBe(true);
    });

    it('should insert multiple tabs for deeply nested lists (3 levels)', () => {
      const markdown = '- Level 0\n  - Level 1\n    - Level 2';
      const requests = convertMarkdownToRequests(markdown, 1);

      const insertReqs = requests.filter((r) => r.insertText);
      // Level 0 has no tab, Level 1 has 1 tab, Level 2 has 2 tabs
      expect(insertReqs.some((r) => r.insertText!.text === '\t\t')).toBe(true);
      expect(insertReqs.some((r) => r.insertText!.text!.includes('Level 2'))).toBe(true);
    });

    it('should use ordered preset for nested ordered list inside bullets', () => {
      const markdown = '- Bullet parent\n  1. Ordered child 1\n  2. Ordered child 2';
      const requests = convertMarkdownToRequests(markdown, 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      const presets = bulletReqs.map((r) => r.createParagraphBullets!.bulletPreset);
      expect(presets).toContain('BULLET_DISC_CIRCLE_SQUARE');
      expect(presets).toContain('NUMBERED_DECIMAL_ALPHA_ROMAN');
    });

    it('should use bullet preset for nested bullets inside ordered list', () => {
      const markdown = '1. Ordered parent\n  - Bullet child 1\n  - Bullet child 2';
      const requests = convertMarkdownToRequests(markdown, 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      const presets = bulletReqs.map((r) => r.createParagraphBullets!.bulletPreset);
      expect(presets).toContain('NUMBERED_DECIMAL_ALPHA_ROMAN');
      expect(presets).toContain('BULLET_DISC_CIRCLE_SQUARE');
    });

    it('should produce separate bullet requests for mixed nested list types', () => {
      const markdown = '- Parent\n  1. Child\n- Parent 2';
      const requests = convertMarkdownToRequests(markdown, 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      // Bullet and ordered are different presets so they cannot merge
      expect(bulletReqs.length).toBeGreaterThanOrEqual(2);
    });

    it('should merge sibling items of the same type even around nested sub-lists', () => {
      // Both "Parent 1" and "Parent 2" are BULLET_DISC_CIRCLE_SQUARE at level 0.
      // The ordered sub-list between them is a different preset.
      const markdown = '- Parent 1\n  1. Ordered child\n- Parent 2';
      const requests = convertMarkdownToRequests(markdown, 1);

      const allText = requests
        .filter((r) => r.insertText)
        .map((r) => r.insertText!.text)
        .join('');
      expect(allText).toContain('Parent 1');
      expect(allText).toContain('Ordered child');
      expect(allText).toContain('Parent 2');
    });

    it('should convert markdown task lists to checkbox bullets', () => {
      const requests = convertMarkdownToRequests('- [x] done\n- [ ] todo', 1);

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      expect(bulletReqs).toHaveLength(1);
      expect(bulletReqs[0].createParagraphBullets!.bulletPreset).toBe('BULLET_CHECKBOX');

      const allInsertedText = requests
        .filter((r) => r.insertText)
        .map((r) => r.insertText!.text)
        .join('');
      expect(allInsertedText).not.toContain('[x]');
      expect(allInsertedText).not.toContain('[ ]');
    });

    it('should not let list bullet ranges bleed into following headings', () => {
      const requests = convertMarkdownToRequests('- Parent\n  1. Child\n\n## Next Heading', 1);

      const headingReq = requests.find(
        (r) => r.updateParagraphStyle?.paragraphStyle?.namedStyleType === 'HEADING_2'
      );
      expect(headingReq).toBeDefined();
      const headingStart = headingReq!.updateParagraphStyle!.range!.startIndex!;

      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      const overlappingBullet = bulletReqs.find((r) => {
        const { startIndex, endIndex } = r.createParagraphBullets!.range!;
        return headingStart >= startIndex! && headingStart < endIndex!;
      });
      expect(overlappingBullet).toBeUndefined();
    });

    it('should not merge separate bullet lists with content between them', () => {
      const markdown = [
        '**Part 1: The Question**',
        '- Item A',
        '- Item B',
        '',
        '**Part 2: The Results**',
        '- Item C',
        '- Item D',
      ].join('\n');

      const requests = convertMarkdownToRequests(markdown, 1);
      const bulletReqs = requests.filter((r) => r.createParagraphBullets);

      // Should produce two separate bullet ranges, not one merged range
      expect(bulletReqs).toHaveLength(2);

      // The paragraph "Part 2: The Results" must not fall inside any bullet range
      const insertReqs = requests.filter((r) => r.insertText);
      let part2Index: number | undefined;
      for (const r of insertReqs) {
        if (r.insertText!.text!.includes('Part 2')) {
          part2Index = r.insertText!.location!.index!;
          break;
        }
      }
      expect(part2Index).toBeDefined();

      for (const b of bulletReqs) {
        const { startIndex, endIndex } = b.createParagraphBullets!.range!;
        const inside = part2Index! >= startIndex! && part2Index! < endIndex!;
        expect(inside).toBe(false);
      }
    });

    it('should keep adjacent items in the same list merged', () => {
      const requests = convertMarkdownToRequests('- A\n- B\n- C', 1);
      const bulletReqs = requests.filter((r) => r.createParagraphBullets);
      expect(bulletReqs).toHaveLength(1);
    });
  });

  describe('Code Blocks', () => {
    it('should insert a 1x1 table for fenced code blocks', () => {
      const requests = convertMarkdownToRequests('```js\nconst x = 1;\nconsole.log(x);\n```', 1);

      // Should have an insertTable request
      const tableReqs = requests.filter((r) => r.insertTable);
      expect(tableReqs).toHaveLength(1);
      expect(tableReqs[0].insertTable!.rows).toBe(1);
      expect(tableReqs[0].insertTable!.columns).toBe(1);
    });

    it('should insert code text into the table cell', () => {
      const requests = convertMarkdownToRequests('```\nhello world\n```', 1);

      const insertReqs = requests.filter((r) => r.insertText);
      expect(insertReqs.some((r) => r.insertText!.text!.includes('hello world'))).toBe(true);
    });

    it('should style code block text as monospace', () => {
      const requests = convertMarkdownToRequests('```\nconst x = 1;\nconsole.log(x);\n```', 1);

      const styleReqs = requests.filter((r) => r.updateTextStyle);
      const monospaceReqs = styleReqs.filter(
        (r) => r.updateTextStyle!.textStyle!.weightedFontFamily?.fontFamily === 'Roboto Mono'
      );
      expect(monospaceReqs).toHaveLength(1);
    });

    it('should style the table cell with background color', () => {
      const requests = convertMarkdownToRequests('```\ncode\n```', 1);

      const cellStyleReqs = requests.filter((r) => r.updateTableCellStyle);
      expect(cellStyleReqs).toHaveLength(1);

      const cellStyle = cellStyleReqs[0].updateTableCellStyle!.tableCellStyle!;
      expect(cellStyle.backgroundColor).toBeDefined();
      expect(cellStyle.paddingTop).toBeDefined();
      expect(cellStyle.paddingBottom).toBeDefined();
      expect(cellStyle.paddingLeft).toBeDefined();
      expect(cellStyle.paddingRight).toBeDefined();
    });

    it('should reference the actual table start (insertTable index + 1) in updateTableCellStyle', () => {
      // insertTable auto-inserts a preceding newline at T, so the table element
      // starts at T+1. The updateTableCellStyle must reference T+1, not T.
      const requests = convertMarkdownToRequests('```\ncode\n```', 1);

      const tableReq = requests.find((r) => r.insertTable);
      const cellStyleReq = requests.find((r) => r.updateTableCellStyle);

      expect(tableReq).toBeDefined();
      expect(cellStyleReq).toBeDefined();

      const insertTableIndex = tableReq!.insertTable!.location!.index!;
      const tableStartLocationIndex =
        cellStyleReq!.updateTableCellStyle!.tableRange!.tableCellLocation!.tableStartLocation!
          .index!;

      // The actual table start is insertTable target + 1 (preceding newline shifts it)
      expect(tableStartLocationIndex).toBe(insertTableIndex + 1);
    });

    it('should insert code text at correct offset from table start', () => {
      const requests = convertMarkdownToRequests('```\nhello\n```', 1);

      const tableReq = requests.find((r) => r.insertTable);
      const codeInsertReq = requests.find((r) => r.insertText && r.insertText.text === 'hello');

      expect(tableReq).toBeDefined();
      expect(codeInsertReq).toBeDefined();

      const tableIndex = tableReq!.insertTable!.location!.index!;
      const textIndex = codeInsertReq!.insertText!.location!.index!;

      // Cell content should be at table start + 4 (CELL_CONTENT_OFFSET)
      expect(textIndex).toBe(tableIndex + 4);
    });

    it('should handle multi-line code blocks', () => {
      const requests = convertMarkdownToRequests('```\nline1\nline2\nline3\n```', 1);

      const insertReqs = requests.filter((r) => r.insertText);
      const codeContent = insertReqs.find((r) => r.insertText!.text === 'line1\nline2\nline3');
      expect(codeContent).toBeDefined();
    });

    it('should handle empty code blocks', () => {
      const requests = convertMarkdownToRequests('```\n```', 1);

      const tableReqs = requests.filter((r) => r.insertTable);
      expect(tableReqs).toHaveLength(1);

      // No code text insertion (empty block)
      const codeInsertReqs = requests.filter((r) => r.insertText && r.insertText.text !== '\n');
      expect(codeInsertReqs).toHaveLength(0);
    });

    it('should handle multiple code blocks in sequence', () => {
      const markdown = '```\ncode1\n```\n\n```\ncode2\n```';
      const requests = convertMarkdownToRequests(markdown, 1);

      const tableReqs = requests.filter((r) => r.insertTable);
      expect(tableReqs).toHaveLength(2);

      const cellStyleReqs = requests.filter((r) => r.updateTableCellStyle);
      expect(cellStyleReqs).toHaveLength(2);
    });

    it('should include tabId in table, text, and cell style requests when provided', () => {
      const requests = convertMarkdownToRequests('```\ncode\n```', 1, 'tab-code');

      const tableReq = requests.find((r) => r.insertTable);
      expect(tableReq!.insertTable!.location!.tabId).toBe('tab-code');

      const codeInsertReq = requests.find((r) => r.insertText && r.insertText.text === 'code');
      expect(codeInsertReq!.insertText!.location!.tabId).toBe('tab-code');

      const cellStyleReq = requests.find((r) => r.updateTableCellStyle);
      expect(
        cellStyleReq!.updateTableCellStyle!.tableRange!.tableCellLocation!.tableStartLocation!.tabId
      ).toBe('tab-code');
    });

    it('should not affect inline code styling', () => {
      const requests = convertMarkdownToRequests('Use `inline_code` here', 1);

      // Inline code should NOT create a table
      const tableReqs = requests.filter((r) => r.insertTable);
      expect(tableReqs).toHaveLength(0);

      // Inline code should still use text styling (monospace + green + background)
      const styleReqs = requests.filter((r) => r.updateTextStyle);
      const codeStyleReq = styleReqs.find(
        (r) => r.updateTextStyle!.textStyle!.weightedFontFamily?.fontFamily === 'Roboto Mono'
      );
      expect(codeStyleReq).toBeDefined();
    });

    it('should correctly track indices after a code block for following content', () => {
      const markdown = '```\ncode\n```\n\nFollowing text.';
      const requests = convertMarkdownToRequests(markdown, 1);

      // The following text should have valid insert locations
      const followingInsert = requests.find(
        (r) => r.insertText && r.insertText.text!.includes('Following text')
      );
      expect(followingInsert).toBeDefined();
      expect(followingInsert!.insertText!.location!.index).toBeGreaterThan(1);
    });
  });

  describe('Mixed Content', () => {
    it('should convert document with multiple elements', () => {
      const markdown = `# Title

This is **bold** and *italic* text with a [link](https://example.com).

- List item 1
- List item 2

## Heading 2

More content.`;

      const requests = convertMarkdownToRequests(markdown, 1);

      expect(requests.some((r) => r.insertText)).toBe(true);
      expect(requests.some((r) => r.updateTextStyle)).toBe(true);
      expect(requests.some((r) => r.updateParagraphStyle)).toBe(true);
      expect(requests.some((r) => r.createParagraphBullets)).toBe(true);

      expect(
        requests.find((r) => r.updateParagraphStyle?.paragraphStyle?.namedStyleType === 'HEADING_1')
      ).toBeDefined();

      expect(
        requests.find((r) => r.updateParagraphStyle?.paragraphStyle?.namedStyleType === 'HEADING_2')
      ).toBeDefined();
    });
  });

  describe('Index Tracking', () => {
    it('should use correct start index', () => {
      const requests = convertMarkdownToRequests('Test text', 100);

      const insertReq = requests.find((r) => r.insertText);
      expect(insertReq).toBeDefined();
      expect(insertReq!.insertText!.location!.index).toBe(100);
    });

    it('should track indices for sequential inserts', () => {
      const requests = convertMarkdownToRequests('First paragraph.\n\nSecond paragraph.', 1);

      const insertReqs = requests.filter((r) => r.insertText);
      expect(insertReqs.length).toBeGreaterThan(0);

      for (const req of insertReqs) {
        expect(req.insertText!.location).toBeDefined();
        expect(typeof req.insertText!.location!.index).toBe('number');
      }
    });
  });

  describe('Tab Support', () => {
    it('should include tabId in requests when provided', () => {
      const requests = convertMarkdownToRequests('**bold text**', 1, 'tab123');

      const insertReq = requests.find((r) => r.insertText);
      expect(insertReq).toBeDefined();
      expect(insertReq!.insertText!.location!.tabId).toBe('tab123');

      const styleReq = requests.find((r) => r.updateTextStyle);
      expect(styleReq).toBeDefined();
      expect(styleReq!.updateTextStyle!.range!.tabId).toBe('tab123');
    });
  });

  describe('Paragraph Spacing', () => {
    it('should apply spaceBelow to normal text paragraphs', () => {
      const requests = convertMarkdownToRequests('First paragraph.\n\nSecond paragraph.', 1);

      const spacingReqs = requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType &&
          !r.updateParagraphStyle?.paragraphStyle?.borderBottom
      );
      expect(spacingReqs).toHaveLength(2);

      for (const req of spacingReqs) {
        expect(req.updateParagraphStyle!.paragraphStyle!.spaceBelow!.magnitude).toBe(8);
        expect(req.updateParagraphStyle!.paragraphStyle!.spaceBelow!.unit).toBe('PT');
        expect(req.updateParagraphStyle!.fields).toBe('spaceBelow');
      }
    });

    it('should only apply spaceBelow to the last item of a list, not every item', () => {
      const requests = convertMarkdownToRequests('- Item 1\n- Item 2\n- Item 3', 1);

      const spacingReqs = requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType &&
          !r.updateParagraphStyle?.paragraphStyle?.borderBottom
      );
      // Only 1 spacing request: the trailing spacing on the last list item
      expect(spacingReqs).toHaveLength(1);
    });

    it('should not apply spaceBelow to headings (they have named styles)', () => {
      const requests = convertMarkdownToRequests('# Heading\n\n## Subheading', 1);

      const spacingReqs = requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType &&
          !r.updateParagraphStyle?.paragraphStyle?.borderBottom
      );
      expect(spacingReqs).toHaveLength(0);
    });

    it('should apply spaceBelow to normal paragraphs and last list items in mixed content', () => {
      const markdown = '# Title\n\nA paragraph.\n\n- List item\n\nAnother paragraph.';
      const requests = convertMarkdownToRequests(markdown, 1);

      const spacingReqs = requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType &&
          !r.updateParagraphStyle?.paragraphStyle?.borderBottom
      );
      // "A paragraph." + "Another paragraph." + last list item trailing spacing = 3
      expect(spacingReqs).toHaveLength(3);
    });

    it('should include tabId in spacing requests when provided', () => {
      const requests = convertMarkdownToRequests('A paragraph.', 1, 'tab-xyz');

      const spacingReqs = requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType
      );
      expect(spacingReqs).toHaveLength(1);
      expect(spacingReqs[0].updateParagraphStyle!.range!.tabId).toBe('tab-xyz');
    });
  });

  describe('List Trailing Spacing', () => {
    // Helper to find spacing requests that target list items (not normal paragraphs or headings).
    // We identify them by checking they don't overlap with normalParagraph spacing ranges or
    // heading styles. Instead we just verify the total spaceBelow count vs paragraph-only count.
    function getListSpacingReqs(requests: ReturnType<typeof convertMarkdownToRequests>) {
      // All spaceBelow requests that are NOT heading styles and NOT border styles
      return requests.filter(
        (r) =>
          r.updateParagraphStyle?.paragraphStyle?.spaceBelow &&
          !r.updateParagraphStyle?.paragraphStyle?.namedStyleType &&
          !r.updateParagraphStyle?.paragraphStyle?.borderBottom
      );
    }

    it('should apply spaceBelow to the last item of a bullet list', () => {
      const requests = convertMarkdownToRequests('- Item 1\n- Item 2\n- Item 3', 1);

      const spacingReqs = getListSpacingReqs(requests);
      // 1 request for the last list item (no normal paragraphs here)
      expect(spacingReqs).toHaveLength(1);
      expect(spacingReqs[0].updateParagraphStyle!.paragraphStyle!.spaceBelow!.magnitude).toBe(8);
    });

    it('should apply spaceBelow to the last item of an ordered list', () => {
      const requests = convertMarkdownToRequests('1. First\n2. Second\n3. Third', 1);

      const spacingReqs = getListSpacingReqs(requests);
      expect(spacingReqs).toHaveLength(1);
      expect(spacingReqs[0].updateParagraphStyle!.paragraphStyle!.spaceBelow!.magnitude).toBe(8);
    });

    it('should apply spaceBelow after each separate list in the document', () => {
      const markdown = '- A\n- B\n\nSome text.\n\n1. One\n2. Two';
      const requests = convertMarkdownToRequests(markdown, 1);

      const spacingReqs = getListSpacingReqs(requests);
      // 2 list-trailing spacing + 1 normal paragraph spacing = 3 total
      expect(spacingReqs).toHaveLength(3);
    });

    it('should create spacing between a list and the following paragraph', () => {
      const markdown = '- Item 1\n- Item 2\n\nFollowing paragraph.';
      const requests = convertMarkdownToRequests(markdown, 1);

      const spacingReqs = getListSpacingReqs(requests);
      // 1 for last list item + 1 for the following paragraph = 2
      expect(spacingReqs).toHaveLength(2);
    });

    it('should handle nested lists and apply spacing after the top-level list', () => {
      const markdown = '- Parent\n  - Child 1\n  - Child 2\n\nAfter the list.';
      const requests = convertMarkdownToRequests(markdown, 1);

      const spacingReqs = getListSpacingReqs(requests);
      // 1 for last item of the top-level list + 1 for the following paragraph = 2
      expect(spacingReqs).toHaveLength(2);
    });

    it('should include tabId in list spacing requests when provided', () => {
      const requests = convertMarkdownToRequests('- Item 1\n- Item 2', 1, 'tab-list');

      const spacingReqs = getListSpacingReqs(requests);
      expect(spacingReqs).toHaveLength(1);
      expect(spacingReqs[0].updateParagraphStyle!.range!.tabId).toBe('tab-list');
    });
  });

  describe('Edge Cases', () => {
    it('should handle empty markdown', () => {
      expect(convertMarkdownToRequests('', 1)).toHaveLength(0);
    });

    it('should handle whitespace-only markdown', () => {
      expect(convertMarkdownToRequests('   \n\n   ', 1)).toHaveLength(0);
    });

    it('should handle plain text without formatting', () => {
      const requests = convertMarkdownToRequests('Just plain text', 1);

      const insertReq = requests.find((r) => r.insertText);
      expect(insertReq).toBeDefined();
      expect(insertReq!.insertText!.text).toBe('Just plain text');

      const styleReqs = requests.filter((r) => r.updateTextStyle);
      expect(styleReqs).toHaveLength(0);
    });
  });

  describe('Horizontal Rules', () => {
    it('should produce a border-bottom paragraph style for ---', () => {
      const requests = convertMarkdownToRequests('Above\n\n---\n\nBelow', 1);

      const hrReqs = requests.filter((r) => r.updateParagraphStyle?.paragraphStyle?.borderBottom);
      expect(hrReqs).toHaveLength(1);

      const border = hrReqs[0].updateParagraphStyle!.paragraphStyle!.borderBottom!;
      expect(border.dashStyle).toBe('SOLID');
      expect(border.width!.magnitude).toBe(1);
      expect(border.width!.unit).toBe('PT');
    });

    it('should handle multiple horizontal rules', () => {
      const requests = convertMarkdownToRequests(
        '# Title\n\n---\n\n## S1\n\nText.\n\n---\n\n## S2',
        1
      );

      const hrReqs = requests.filter((r) => r.updateParagraphStyle?.paragraphStyle?.borderBottom);
      expect(hrReqs).toHaveLength(2);
    });

    it('should not drop surrounding content', () => {
      const requests = convertMarkdownToRequests('Above\n\n---\n\nBelow', 1);

      const allText = requests
        .filter((r) => r.insertText)
        .map((r) => r.insertText!.text)
        .join('');

      expect(allText).toContain('Above');
      expect(allText).toContain('Below');
    });

    it('should place the HR paragraph between surrounding content', () => {
      const requests = convertMarkdownToRequests('Above\n\n---\n\nBelow', 1);

      const hrReqs = requests.filter((r) => r.updateParagraphStyle?.paragraphStyle?.borderBottom);
      expect(hrReqs).toHaveLength(1);

      const hrStart = hrReqs[0].updateParagraphStyle!.range!.startIndex!;
      const hrEnd = hrReqs[0].updateParagraphStyle!.range!.endIndex!;

      const aboveInsert = requests.find(
        (r) => r.insertText && r.insertText.text!.includes('Above')
      );
      const belowInsert = requests.find(
        (r) => r.insertText && r.insertText.text!.includes('Below')
      );

      expect(aboveInsert!.insertText!.location!.index).toBeLessThan(hrStart);
      expect(belowInsert!.insertText!.location!.index).toBeGreaterThanOrEqual(hrEnd);
    });

    it('should include tabId on HR border requests when provided', () => {
      const requests = convertMarkdownToRequests('---', 1, 'tab-abc');

      const hrReqs = requests.filter((r) => r.updateParagraphStyle?.paragraphStyle?.borderBottom);
      expect(hrReqs.length).toBeGreaterThan(0);
      expect(hrReqs[0].updateParagraphStyle!.range!.tabId).toBe('tab-abc');
    });

    it('should work in a realistic document with headings, lists, and rules', () => {
      const markdown = `# Project Plan

---

## Goals

- **Speed:** Ship faster
- **Quality:** Fewer bugs

## Timeline

1. Planning
2. Execution
3. Review

---

*Last updated: 2026*`;

      const requests = convertMarkdownToRequests(markdown, 1);

      // HRs
      const hrReqs = requests.filter((r) => r.updateParagraphStyle?.paragraphStyle?.borderBottom);
      expect(hrReqs).toHaveLength(2);

      // Headings
      const h1Reqs = requests.filter(
        (r) => r.updateParagraphStyle?.paragraphStyle?.namedStyleType === 'HEADING_1'
      );
      const h2Reqs = requests.filter(
        (r) => r.updateParagraphStyle?.paragraphStyle?.namedStyleType === 'HEADING_2'
      );
      expect(h1Reqs).toHaveLength(1);
      expect(h2Reqs).toHaveLength(2);

      // Bullet lists (merged into one range)
      const bulletReqs = requests.filter(
        (r) => r.createParagraphBullets?.bulletPreset === 'BULLET_DISC_CIRCLE_SQUARE'
      );
      expect(bulletReqs).toHaveLength(1);

      // Numbered list (merged into one range)
      const numberedReqs = requests.filter(
        (r) => r.createParagraphBullets?.bulletPreset === 'NUMBERED_DECIMAL_ALPHA_ROMAN'
      );
      expect(numberedReqs).toHaveLength(1);

      // Bold
      const boldReqs = requests.filter((r) => r.updateTextStyle?.textStyle?.bold === true);
      expect(boldReqs.length).toBeGreaterThanOrEqual(2);

      // Italic
      const italicReqs = requests.filter((r) => r.updateTextStyle?.textStyle?.italic === true);
      expect(italicReqs.length).toBeGreaterThanOrEqual(1);

      // All text present
      const allText = requests
        .filter((r) => r.insertText)
        .map((r) => r.insertText!.text)
        .join('');
      expect(allText).toContain('Project Plan');
      expect(allText).toContain('Ship faster');
      expect(allText).toContain('Execution');
      expect(allText).toContain('Last updated: 2026');
    });
  });
});

// ============================================================
// Google Docs JSON -> Markdown
// ============================================================

describe('Docs to Markdown Conversion', () => {
  describe('Headings', () => {
    it('should convert HEADING_1 to # heading', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                paragraphStyle: { namedStyleType: 'HEADING_1' },
                elements: [{ textRun: { content: 'Hello\n' } }],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('# Hello');
    });

    it('should convert HEADING_2 through HEADING_6', () => {
      const doc = {
        body: {
          content: [2, 3, 4, 5, 6].map((level) => ({
            paragraph: {
              paragraphStyle: { namedStyleType: `HEADING_${level}` },
              elements: [{ textRun: { content: `H${level}\n` } }],
            },
          })),
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('## H2');
      expect(md).toContain('### H3');
      expect(md).toContain('#### H4');
      expect(md).toContain('##### H5');
      expect(md).toContain('###### H6');
    });

    it('should convert TITLE to H1 and SUBTITLE to H2', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                paragraphStyle: { namedStyleType: 'TITLE' },
                elements: [{ textRun: { content: 'My Title\n' } }],
              },
            },
            {
              paragraph: {
                paragraphStyle: { namedStyleType: 'SUBTITLE' },
                elements: [{ textRun: { content: 'My Subtitle\n' } }],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('# My Title');
      expect(md).toContain('## My Subtitle');
    });
  });

  describe('Text Formatting', () => {
    it('should convert bold text', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [{ textRun: { content: 'bold', textStyle: { bold: true } } }],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('**bold**');
    });

    it('should convert italic text', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [{ textRun: { content: 'italic', textStyle: { italic: true } } }],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('*italic*');
    });

    it('should convert bold+italic text', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [
                  {
                    textRun: {
                      content: 'both',
                      textStyle: { bold: true, italic: true },
                    },
                  },
                ],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('***both***');
    });

    it('should convert strikethrough text', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [{ textRun: { content: 'struck', textStyle: { strikethrough: true } } }],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('~~struck~~');
    });

    it('should convert links', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [
                  {
                    textRun: {
                      content: 'click here',
                      textStyle: { link: { url: 'https://example.com' } },
                    },
                  },
                ],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('[click here](https://example.com)');
    });

    it('should detect monospace font as code', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                elements: [
                  { textRun: { content: 'normal ' } },
                  {
                    textRun: {
                      content: 'code_here',
                      textStyle: { weightedFontFamily: { fontFamily: 'Roboto Mono' } },
                    },
                  },
                  { textRun: { content: ' more\n' } },
                ],
              },
            },
          ],
        },
      };
      expect(docsJsonToMarkdown(doc)).toContain('`code_here`');
    });
  });

  describe('Lists', () => {
    it('should convert bullet list items', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'list1', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Item 1\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'list1', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Item 2\n' } }],
              },
            },
          ],
        },
        lists: {
          list1: {
            listProperties: {
              nestingLevels: [{ glyphSymbol: '\u25cf' }],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('- Item 1');
      expect(md).toContain('- Item 2');
    });

    it('should detect ordered lists via glyphType', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'olist', nestingLevel: 0 },
                elements: [{ textRun: { content: 'First\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'olist', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Second\n' } }],
              },
            },
          ],
        },
        lists: {
          olist: {
            listProperties: {
              nestingLevels: [{ glyphType: 'DECIMAL' }],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('1. First');
      expect(md).toContain('1. Second');
    });

    it('should render nested lists with indentation', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'nlist', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Parent\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'nlist', nestingLevel: 1 },
                elements: [{ textRun: { content: 'Child\n' } }],
              },
            },
          ],
        },
        lists: {
          nlist: {
            listProperties: {
              nestingLevels: [{ glyphSymbol: '\u25cf' }, { glyphSymbol: '\u25cb' }],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('- Parent');
      expect(md).toContain('  - Child');
    });

    it('should render 3 levels of nested bullet indentation', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'deep', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Level 0\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'deep', nestingLevel: 1 },
                elements: [{ textRun: { content: 'Level 1\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'deep', nestingLevel: 2 },
                elements: [{ textRun: { content: 'Level 2\n' } }],
              },
            },
          ],
        },
        lists: {
          deep: {
            listProperties: {
              nestingLevels: [
                { glyphSymbol: '\u25cf' },
                { glyphSymbol: '\u25cb' },
                { glyphSymbol: '\u25a0' },
              ],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('- Level 0');
      expect(md).toContain('  - Level 1');
      expect(md).toContain('    - Level 2');
    });

    it('should render ordered sub-list inside bullet list', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'mixed', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Bullet parent\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'mixed', nestingLevel: 1 },
                elements: [{ textRun: { content: 'Ordered child\n' } }],
              },
            },
          ],
        },
        lists: {
          mixed: {
            listProperties: {
              nestingLevels: [{ glyphSymbol: '\u25cf' }, { glyphType: 'DECIMAL' }],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('- Bullet parent');
      expect(md).toContain('  1. Ordered child');
    });

    it('should return to parent indentation level after nested items', () => {
      const doc = {
        body: {
          content: [
            {
              paragraph: {
                bullet: { listId: 'bounce', nestingLevel: 0 },
                elements: [{ textRun: { content: 'First\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'bounce', nestingLevel: 1 },
                elements: [{ textRun: { content: 'Nested\n' } }],
              },
            },
            {
              paragraph: {
                bullet: { listId: 'bounce', nestingLevel: 0 },
                elements: [{ textRun: { content: 'Back to top\n' } }],
              },
            },
          ],
        },
        lists: {
          bounce: {
            listProperties: {
              nestingLevels: [{ glyphSymbol: '\u25cf' }, { glyphSymbol: '\u25cb' }],
            },
          },
        },
      };
      const md = docsJsonToMarkdown(doc);
      const lines = md.split('\n').filter((l) => l.trim());
      const firstLine = lines.find((l) => l.includes('First'));
      const nestedLine = lines.find((l) => l.includes('Nested'));
      const backLine = lines.find((l) => l.includes('Back to top'));

      expect(firstLine).toBe('- First');
      expect(nestedLine).toBe('  - Nested');
      expect(backLine).toBe('- Back to top');
    });
  });

  describe('Code Block Tables', () => {
    it('should detect a 1x1 table with gray background as a code block', () => {
      const doc = {
        body: {
          content: [
            {
              table: {
                tableRows: [
                  {
                    tableCells: [
                      {
                        tableCellStyle: {
                          backgroundColor: {
                            color: { rgbColor: { red: 0.937, green: 0.945, blue: 0.953 } },
                          },
                        },
                        content: [
                          {
                            paragraph: {
                              elements: [
                                {
                                  textRun: {
                                    content: 'const x = 1;\n',
                                    textStyle: {
                                      weightedFontFamily: { fontFamily: 'Roboto Mono' },
                                    },
                                  },
                                },
                              ],
                            },
                          },
                        ],
                      },
                    ],
                  },
                ],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('```');
      expect(md).toContain('const x = 1;');
      // Should NOT be a markdown table
      expect(md).not.toContain('|');
    });

    it('should detect a 1x1 table with monospace font as a code block', () => {
      const doc = {
        body: {
          content: [
            {
              table: {
                tableRows: [
                  {
                    tableCells: [
                      {
                        content: [
                          {
                            paragraph: {
                              elements: [
                                {
                                  textRun: {
                                    content: 'print("hello")\n',
                                    textStyle: {
                                      weightedFontFamily: { fontFamily: 'Courier New' },
                                    },
                                  },
                                },
                              ],
                            },
                          },
                        ],
                      },
                    ],
                  },
                ],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('```');
      expect(md).toContain('print("hello")');
    });

    it('should NOT detect a regular 2x2 table as a code block', () => {
      const doc = {
        body: {
          content: [
            {
              table: {
                tableRows: [
                  {
                    tableCells: [
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: 'A\n' } }] } }],
                      },
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: 'B\n' } }] } }],
                      },
                    ],
                  },
                  {
                    tableCells: [
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: '1\n' } }] } }],
                      },
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: '2\n' } }] } }],
                      },
                    ],
                  },
                ],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      // Should be a markdown table, not a code block
      expect(md).toContain('|');
      expect(md).not.toContain('```');
    });

    it('should handle multi-line content in a code block table', () => {
      const doc = {
        body: {
          content: [
            {
              table: {
                tableRows: [
                  {
                    tableCells: [
                      {
                        tableCellStyle: {
                          backgroundColor: {
                            color: { rgbColor: { red: 0.937, green: 0.945, blue: 0.953 } },
                          },
                        },
                        content: [
                          {
                            paragraph: {
                              elements: [
                                {
                                  textRun: {
                                    content: 'line1\n',
                                    textStyle: {
                                      weightedFontFamily: { fontFamily: 'Roboto Mono' },
                                    },
                                  },
                                },
                              ],
                            },
                          },
                          {
                            paragraph: {
                              elements: [
                                {
                                  textRun: {
                                    content: 'line2\n',
                                    textStyle: {
                                      weightedFontFamily: { fontFamily: 'Roboto Mono' },
                                    },
                                  },
                                },
                              ],
                            },
                          },
                        ],
                      },
                    ],
                  },
                ],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('```');
      expect(md).toContain('line1');
      expect(md).toContain('line2');
    });
  });

  describe('Tables', () => {
    it('should convert a simple table', () => {
      const doc = {
        body: {
          content: [
            {
              table: {
                tableRows: [
                  {
                    tableCells: [
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: 'A\n' } }] } }],
                      },
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: 'B\n' } }] } }],
                      },
                    ],
                  },
                  {
                    tableCells: [
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: '1\n' } }] } }],
                      },
                      {
                        content: [{ paragraph: { elements: [{ textRun: { content: '2\n' } }] } }],
                      },
                    ],
                  },
                ],
              },
            },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('| A | B |');
      expect(md).toContain('| --- | --- |');
      expect(md).toContain('| 1 | 2 |');
    });
  });

  describe('Section Breaks', () => {
    it('should convert section breaks to horizontal rules', () => {
      const doc = {
        body: {
          content: [
            { paragraph: { elements: [{ textRun: { content: 'Before\n' } }] } },
            { sectionBreak: {} },
            { paragraph: { elements: [{ textRun: { content: 'After\n' } }] } },
          ],
        },
      };
      const md = docsJsonToMarkdown(doc);
      expect(md).toContain('---');
      expect(md).toContain('Before');
      expect(md).toContain('After');
    });
  });

  describe('Edge Cases', () => {
    it('should return empty string for empty document', () => {
      expect(docsJsonToMarkdown({})).toBe('');
      expect(docsJsonToMarkdown({ body: {} })).toBe('');
      expect(docsJsonToMarkdown({ body: { content: [] } })).toBe('');
    });

    it('should handle paragraphs with no text runs', () => {
      const doc = {
        body: {
          content: [{ paragraph: { elements: [] } }],
        },
      };
      expect(typeof docsJsonToMarkdown(doc)).toBe('string');
    });
  });
});