compilation.js

const {
  diagnostic,
  parsePgxDocument,
  parseProfile,
  span,
  walkTraversal
} = require("./syntax");

function indexNodes(nodes) {
  const index = new Map();
  for (const node of nodes) {
    const declarations = index.get(node.pointer) ?? [];
    declarations.push(node);
    index.set(node.pointer, declarations);
  }
  return index;
}

function duplicateDiagnostics(index, provenance) {
  const diagnostics = [];
  for (const [pointer, declarations] of index) {
    declarations.slice(1).forEach((node) => {
      const first = declarations[0];
      diagnostics.push(
        diagnostic(
          provenance === "document" ? "duplicate-document-pointer" : "duplicate-profile-pointer",
          "schema-profile-1",
          "error",
          provenance === "document"
            ? `Duplicate PGX address ${pointer}; first declared on line ${first.lineNumber + 1}.`
            : `Duplicate profile pointer ${pointer}.`,
          node.pointerSpan ?? span(0, Math.max(pointer.length, 1))
        )
      );
    });
  }
  return diagnostics;
}

function referenceOccurrences(nodes) {
  const references = [];
  for (const node of nodes) {
    if (!node.descriptionTraversal) {
      continue;
    }
    walkTraversal(node.descriptionTraversal, (pointer, path) => {
      references.push({
        kind: "reference",
        id: `${node.identity}:ref:${path.join(".")}`,
        pointer: pointer.id,
        span: pointer.span,
        path,
        owner: node,
        provenance: node.provenance
      });
    });
  }
  return references;
}

function nearestDocumentDeclaration(declarations, context = {}) {
  if (!declarations?.length) {
    return undefined;
  }
  const line = context.line ?? 0;
  return [...declarations].sort((left, right) => {
    const leftDistance = Math.abs(left.lineNumber - line);
    const rightDistance = Math.abs(right.lineNumber - line);
    if (leftDistance !== rightDistance) {
      return leftDistance - rightDistance;
    }
    const leftIsLater = left.lineNumber > line ? 1 : 0;
    const rightIsLater = right.lineNumber > line ? 1 : 0;
    return leftIsLater - rightIsLater;
  })[0];
}

/**
 * Compile PGX source and an optional profile into contextual declarations,
 * reference occurrences, diagnostics, and derived graph views.
 * @param {{source?: string, sourceId?: string, profile?: object}} input
 */
function createCompilation({ source = "", sourceId = "document", profile = {} } = {}) {
  const document = parsePgxDocument(source, sourceId);
  const parsedProfile = parseProfile(profile);
  const documentIndex = indexNodes(document.nodes);
  const profileIndex = indexNodes(parsedProfile.nodes);
  const documentReferences = referenceOccurrences(document.nodes);
  const profileReferences = referenceOccurrences(parsedProfile.nodes);
  const diagnostics = [
    ...document.diagnostics,
    ...parsedProfile.diagnostics,
    ...duplicateDiagnostics(documentIndex, "document"),
    ...duplicateDiagnostics(profileIndex, "profile")
  ];

  const documentPointerOccurrences = [
    ...document.nodes
      .filter((node) => node.pointerSpan)
      .map((node) => ({
        kind: "declaration",
        pointer: node.pointer,
        span: node.pointerSpan,
        owner: node,
        provenance: "document"
      })),
    ...documentReferences
  ].sort((left, right) =>
    left.span.start - right.span.start || left.span.end - right.span.end
  );

  function resolve(pointer, context = {}, options = {}) {
    const id = pointer;
    const layers = options.layers ?? ["document", "profile"];
    for (const layer of layers) {
      if (layer === "document") {
        const declaration = nearestDocumentDeclaration(documentIndex.get(id), context);
        if (declaration) {
          return { declaration, provenance: "document", pointer: id };
        }
      } else if (layer === "profile") {
        const declaration = profileIndex.get(id)?.[0];
        if (declaration) {
          return { declaration, provenance: "profile", pointer: id };
        }
      }
    }
    return undefined;
  }

  function pointerOccurrenceAt(offset) {
    return documentPointerOccurrences.find((occurrence) =>
      occurrence.span.start <= offset && offset < occurrence.span.end
    );
  }

  function references(options = {}) {
    const layer = options.layer ?? "all";
    if (layer === "document") {
      return documentReferences;
    }
    if (layer === "profile") {
      return profileReferences;
    }
    return [...documentReferences, ...profileReferences];
  }

  function nodes(options = {}) {
    const layer = options.layer ?? "all";
    if (layer === "document") {
      return document.nodes;
    }
    if (layer === "profile") {
      return parsedProfile.nodes;
    }
    return [...document.nodes, ...parsedProfile.nodes];
  }

  function validateReferences(options = {}) {
    const layer = options.layer ?? "all";
    const layers = options.layers ?? (layer === "profile" ? ["profile"] : ["document", "profile"]);
    const result = [];
    for (const reference of references({ layer })) {
      const context = { line: reference.owner.lineNumber, offset: reference.span?.start };
      if (!resolve(reference.pointer, context, { layers })) {
        result.push(
          diagnostic(
            "unresolved-pointer",
            "binding",
            "error",
            `${reference.owner.pointer} references unresolved pointer ${reference.pointer}.`,
            reference.span ?? span(0, reference.pointer.length)
          )
        );
      }
    }
    return result;
  }

  function graphView(options = {}) {
    const layer = options.layer ?? "document";
    const layers = options.layers ?? (layer === "profile" ? ["profile"] : ["document", "profile"]);
    const graphNodes = nodes({ layer });
    const edges = references({ layer }).map((reference) => {
      const bound = resolve(
        reference.pointer,
        { line: reference.owner.lineNumber, offset: reference.span?.start },
        { layers }
      );
      return {
        kind: "edge",
        id: reference.id,
        from: reference.owner.identity,
        to: bound?.declaration.identity,
        pointer: reference.pointer,
        path: reference.path,
        span: reference.span,
        provenance: bound?.provenance,
        resolved: Boolean(bound)
      };
    });
    return { nodes: graphNodes, edges };
  }

  function findCycles(options = {}) {
    const graph = graphView(options);
    const adjacency = new Map(graph.nodes.map((node) => [node.identity, []]));
    for (const edge of graph.edges) {
      if (edge.to && adjacency.has(edge.from)) {
        adjacency.get(edge.from).push(edge.to);
      }
    }

    const visiting = new Set();
    const visited = new Set();
    const stack = [];
    const cycles = [];
    const seen = new Set();

    function visit(identity) {
      if (visiting.has(identity)) {
        const start = stack.indexOf(identity);
        const cycle = [...stack.slice(start), identity];
        const key = cycle.join(" -> ");
        if (!seen.has(key)) {
          seen.add(key);
          cycles.push(cycle);
        }
        return;
      }
      if (visited.has(identity)) {
        return;
      }
      visiting.add(identity);
      stack.push(identity);
      for (const target of adjacency.get(identity) ?? []) {
        visit(target);
      }
      stack.pop();
      visiting.delete(identity);
      visited.add(identity);
    }

    for (const node of graph.nodes) {
      visit(node.identity);
    }
    return cycles;
  }

  return {
    kind: "pgx-compilation",
    sourceId,
    source,
    schemaProfile: parsedProfile.schemaProfile,
    document,
    profile: parsedProfile,
    documentIndex,
    profileIndex,
    documentPointerOccurrences,
    diagnostics,
    findCycles,
    graphView,
    nodes,
    pointerOccurrenceAt,
    references,
    resolve,
    validateReferences
  };
}

module.exports = { createCompilation };