import { expect } from '@open-wc/testing';
import { markdownToHtml, looksLikeMarkdown, inlineToHtml } from './markdown-parse';
import { defaultSchema, htmlToDoc, docToMarkdown } from './index';

describe('markdown-parse', () => {
  describe('markdownToHtml — blocks', () => {
    it('parses headings', () => {
      expect(markdownToHtml('# One')).to.equal('<h1>One</h1>');
      expect(markdownToHtml('### Three')).to.equal('<h3>Three</h3>');
      expect(markdownToHtml('## Trailing ##')).to.equal('<h2>Trailing</h2>');
    });

    it('parses paragraphs and hard breaks', () => {
      expect(markdownToHtml('one\ntwo\n\nthree')).to.equal(
        '<p>one<br>two</p><p>three</p>'
      );
    });

    it('parses blockquotes with lazy continuation', () => {
      expect(markdownToHtml('> quoted\ncontinues')).to.equal(
        '<blockquote><p>quoted<br>continues</p></blockquote>'
      );
    });

    it('parses fenced code blocks with language', () => {
      expect(markdownToHtml('```js\nconst a = 1 < 2;\n```')).to.equal(
        '<pre data-language="js"><code>const a = 1 &lt; 2;</code></pre>'
      );
    });

    it('keeps markdown syntax literal inside code fences', () => {
      expect(markdownToHtml('```\n# not a heading\n**not bold**\n```')).to.equal(
        '<pre><code># not a heading\n**not bold**</code></pre>'
      );
    });

    it('parses horizontal rules but not list dashes', () => {
      expect(markdownToHtml('---')).to.equal('<hr>');
      expect(markdownToHtml('- item')).to.equal('<ul><li><p>item</p></li></ul>');
    });

    it('parses nested bullet lists', () => {
      expect(markdownToHtml('- a\n  - b')).to.equal(
        '<ul><li><p>a</p><ul><li><p>b</p></li></ul></li></ul>'
      );
    });

    it('parses ordered lists with a start offset', () => {
      expect(markdownToHtml('3. three\n4. four')).to.equal(
        '<ol start="3"><li><p>three</p></li><li><p>four</p></li></ol>'
      );
    });

    it('splits sibling lists when the marker type changes', () => {
      expect(markdownToHtml('- a\n1. b')).to.equal(
        '<ul><li><p>a</p></li></ul><ol><li><p>b</p></li></ol>'
      );
    });

    it('parses task lists without converting plain neighbours', () => {
      expect(markdownToHtml('- plain\n- [x] done')).to.equal(
        '<ul><li><p>plain</p></li></ul>' +
          '<ul data-task-list="true"><li data-task-item="true" data-checked="true"><p>done</p></li></ul>'
      );
    });

    it('parses GFM tables with header cells', () => {
      expect(markdownToHtml('| A | B |\n| - | - |\n| 1 | 2 |')).to.equal(
        '<table><tr><th><p>A</p></th><th><p>B</p></th></tr>' +
          '<tr><td><p>1</p></td><td><p>2</p></td></tr></table>'
      );
    });
  });

  describe('inlineToHtml — marks', () => {
    it('converts the inline marks', () => {
      expect(inlineToHtml('**b** *i* ~~s~~ `c`')).to.equal(
        '<strong>b</strong> <em>i</em> <s>s</s> <code>c</code>'
      );
    });

    it('converts links and images', () => {
      expect(inlineToHtml('[x](https://a.b)')).to.equal('<a href="https://a.b">x</a>');
      expect(inlineToHtml('![y](https://a.b/i.png)')).to.equal(
        '<img src="https://a.b/i.png" alt="y">'
      );
    });

    it('escapes HTML in text and keeps code spans literal', () => {
      expect(inlineToHtml('<b>hi</b>')).to.equal('&lt;b&gt;hi&lt;/b&gt;');
      expect(inlineToHtml('`*literal*`')).to.equal('<code>*literal*</code>');
    });

    it('honors backslash escapes', () => {
      expect(inlineToHtml('\\*not italic\\*')).to.equal('*not italic*');
    });

    it('does not read mid-word underscores as emphasis', () => {
      expect(inlineToHtml('snake_case_name')).to.equal('snake_case_name');
    });
  });

  describe('round-trip with docToMarkdown', () => {
    it('survives a structural round-trip', () => {
      const source = [
        '# Title',
        '',
        'Some **bold** and *italic* text.',
        '',
        '- one',
        '- two',
        '',
        '```js',
        'const x = 1;',
        '```',
      ].join('\n');
      const doc = htmlToDoc(defaultSchema, markdownToHtml(source));
      expect(docToMarkdown(doc).trim()).to.equal(source);
    });

    it('round-trips task lists', () => {
      const source = '- [ ] todo\n- [x] done';
      const doc = htmlToDoc(defaultSchema, markdownToHtml(source));
      expect(docToMarkdown(doc).trim()).to.equal(source);
    });
  });

  describe('looksLikeMarkdown', () => {
    it('detects block constructs', () => {
      expect(looksLikeMarkdown('# Heading')).to.be.true;
      expect(looksLikeMarkdown('- a list item')).to.be.true;
      expect(looksLikeMarkdown('1. ordered')).to.be.true;
      expect(looksLikeMarkdown('> quote')).to.be.true;
      expect(looksLikeMarkdown('```\ncode\n```')).to.be.true;
    });

    it('detects unambiguous inline constructs', () => {
      expect(looksLikeMarkdown('some **bold** text')).to.be.true;
      expect(looksLikeMarkdown('a [link](https://x.y) here')).to.be.true;
    });

    it('rejects plain text and HTML', () => {
      expect(looksLikeMarkdown('just a sentence.')).to.be.false;
      expect(looksLikeMarkdown('2 * 3 = 6 and 4 - 2 = 2')).to.be.false;
      expect(looksLikeMarkdown('<p>markup</p>')).to.be.false;
    });
  });
});