import * as assert from 'assert';
import * as vscode from 'vscode';
import { FixSessionManager } from '../src/fix/fixSession';

suite('FixSession Tests', () => {
  const uri = vscode.Uri.file('C:/fake/project/src/app.js');

  test('add/get/has roundtrip', () => {
    const session = new FixSessionManager();
    const key = 'eslint:no-extra-semi@5';
    session.add(uri, {
      key,
      ruleId: 'eslint:no-extra-semi',
      line: 5,
      fixes: [{ originalText: 'var x = 1;;', newText: 'var x = 1;', line: 5 }],
      source: 'linter',
    });
    assert.strictEqual(session.has(uri, key), true);
    const entry = session.get(uri, key);
    assert.ok(entry);
    assert.strictEqual(entry!.ruleId, 'eslint:no-extra-semi');
    assert.strictEqual(entry!.line, 5);
    assert.strictEqual(entry!.fixes.length, 1);
  });

  test('get returns undefined for missing key', () => {
    const session = new FixSessionManager();
    assert.strictEqual(session.get(uri, 'eslint:x@1'), undefined);
    assert.strictEqual(session.has(uri, 'eslint:x@1'), false);
  });

  test('getEntries filters per uri', () => {
    const session = new FixSessionManager();
    const other = vscode.Uri.file('C:/fake/project/src/other.js');
    session.add(uri, { key: 'a@1', ruleId: 'a', line: 1, fixes: [{ originalText: '1', newText: '2', line: 1 }], source: 'linter' });
    session.add(uri, { key: 'b@2', ruleId: 'b', line: 2, fixes: [{ originalText: '3', newText: '4', line: 2 }], source: 'linter' });
    session.add(other, { key: 'c@3', ruleId: 'c', line: 3, fixes: [{ originalText: '5', newText: '6', line: 3 }], source: 'linter' });

    const entries = session.getEntries(uri);
    assert.strictEqual(entries.length, 2);
    assert.deepStrictEqual(entries.map(e => e.ruleId).sort(), ['a', 'b']);
  });

  test('clear removes entries for uri only', () => {
    const session = new FixSessionManager();
    const other = vscode.Uri.file('C:/fake/project/src/other.js');
    session.add(uri, { key: 'a@1', ruleId: 'a', line: 1, fixes: [{ originalText: '1', newText: '2', line: 1 }], source: 'linter' });
    session.add(other, { key: 'c@3', ruleId: 'c', line: 3, fixes: [{ originalText: '5', newText: '6', line: 3 }], source: 'linter' });

    session.clear(uri);
    assert.strictEqual(session.getEntries(uri).length, 0);
    assert.strictEqual(session.getEntries(other).length, 1);
  });

  test('recordFixes merges multi-round fixes under same key', () => {
    const session = new FixSessionManager();
    session.recordFixes(uri, 'eslint:no-extra-semi', 5, [
      { originalText: ';;', newText: ';', line: 5 },
    ]);
    session.recordFixes(uri, 'eslint:no-extra-semi', 5, [
      { originalText: ';', newText: '', line: 5 },
    ]);

    const entry = session.get(uri, 'eslint:no-extra-semi@5');
    assert.ok(entry);
    assert.strictEqual(entry!.fixes.length, 2);
  });

  test('undo restores original text via workspace edit', async () => {
    const doc = await vscode.workspace.openTextDocument({
      content: 'var x = 1;;\nvar y = 2;\n',
      language: 'javascript',
    });

    const session = new FixSessionManager();
    const key = session.recordFixes(doc.uri, 'eslint:no-extra-semi', 0, [
      { originalText: ';;', newText: ';', line: 0 },
    ]);

    const edit = new vscode.WorkspaceEdit();
    edit.replace(doc.uri, new vscode.Range(0, 0, 1, 0), 'var x = 1;\n');
    const applied = await vscode.workspace.applyEdit(edit);
    assert.ok(applied);

    const docAfterFix = await vscode.workspace.openTextDocument(doc.uri);
    assert.strictEqual(docAfterFix.getText(), 'var x = 1;\nvar y = 2;\n');

    const undone = await session.undo(docAfterFix, key);
    assert.ok(undone);

    const docAfterUndo = await vscode.workspace.openTextDocument(doc.uri);
    assert.strictEqual(docAfterUndo.getText(), 'var x = 1;;\nvar y = 2;\n');
    assert.strictEqual(session.has(doc.uri, key), false);
  });
});