import fs from 'fs';
import path from 'path';

import { ast } from '../../src';
import * as nodes from '../../src/ast/nodes';
import { NodeVisitor, walk } from '../../src/ast/visit';
import { loadYamlCases } from '../loaders/yaml';

const fixturesDir = path.resolve(__dirname, '..', 'fixtures');

class TestVisitor extends NodeVisitor {
  public visited: Map<string, number>;

  constructor() {
    super();
    this.visited = new Map();
  }

  override genericVisit(node: nodes.ASTRootBase): void {
    this.visited.set(node.constructor.name, (this.visited.get(node.constructor.name) || 0) + 1);
    return super.genericVisit(node);
  }
}

describe('NodeVisitor', () => {
  test('block.tlb can be visited', () => {
    expect.hasAssertions();

    const blockInput = fs.readFileSync(path.resolve(fixturesDir, 'tlb', 'block.tlb'), 'utf-8');
    const tree = ast(blockInput);
    expect(tree).toBeInstanceOf(nodes.Program);

    const visitor = new TestVisitor();
    visitor.visit(tree);

    expect(visitor.visited).not.toEqual(new Map());
  });

  for (let caseDef of loadYamlCases(fixturesDir, 'ast', 'visit.yml')) {
    test(`Generated visit example: ${caseDef.case}`, () => {
      expect.hasAssertions();

      const visitor = new TestVisitor();
      visitor.visit(ast(caseDef.code));

      const expected = Object.entries(JSON.parse(caseDef.result!));
      expect(visitor.visited).toEqual(new Map(expected));
    });
  }
});

describe('walk parents', () => {
  test('block.tlb can be visited', () => {
    expect.hasAssertions();

    const blockInput = fs.readFileSync(path.resolve(fixturesDir, 'tlb', 'block.tlb'), 'utf-8');
    const tree = ast(blockInput);
    expect(tree).toBeInstanceOf(nodes.Program);

    for (let node of walk(tree)) {
      if (node instanceof nodes.Program) {
        expect(node.parent).toBe(null);
      } else {
        expect(node).toBeInstanceOf(nodes.ASTBase);
        expect(node.parent).toBeInstanceOf(nodes.ASTRootBase);
      }
    }
  });
});