import { defineCommand } from "@bunli/core";
import { boringGrammar } from "../parse/grammar";
import { semantics } from "../parse/semantics";
import TraitChecker from "../types/trait_checker";
import { TypeAliasResolver } from "../types/type_alias_resolution";
import { TypeSystem } from "../types/type_system";
import { TypeChecker } from "../types/type_checker";
import { TypeResolver } from "../types/type_resolver";
import { TreeWalkInterpreter } from "../interpreter";

export const run = defineCommand({
  name: "run",
  description: "Run a boringlang file",

  handler: async ({ positional }) => {
    const [path] = positional;

    if (!path) {
      throw new Error("Usage: run <path>");
    }

    const file = Bun.file(path);
    const text = await file.text();

    const match = boringGrammar.match(text, "Module");
    if (match.succeeded()) {
      const adapter = semantics(match);
      const ast = adapter.toAST();
      // console.log(JSON.stringify(ast, null, 2));
      new TraitChecker().withModule(ast);
      const aliasResolvedAst = new TypeAliasResolver().withModule(ast);
      const typeSystem = new TypeSystem();
      const typeChecker = new TypeChecker();
      const typeResolver = new TypeResolver();

      typeChecker.withModule(aliasResolvedAst, typeSystem);
      try {
        typeSystem.solve();
      } catch (e) {
        console.log(e);
        console.log(JSON.stringify(typeSystem.result, null, 2));
        return;
      }

      const typeResolvedAst = typeResolver.withModule(aliasResolvedAst, typeSystem);
      // console.log(JSON.stringify(typeResolvedAst, null, 2));
      const interpreter = new TreeWalkInterpreter();
      const result = interpreter.withModule(typeResolvedAst);
      console.log(JSON.stringify(result, null, 2));

      // console.log(JSON.stringify(aliasResolvedAst, null, 2));
    } else {
      console.log(match.message);
      // console.log(boringGrammar.trace(text, "Module").toString());
    }
  },
});