import { describe, it } from "node:test";
import assert from "node:assert/strict";
import {
  buildRenderableGraph,
  edgeOpacity,
  edgeRelationClass,
  edgeStrokeWidth,
  edgeVisualOpacity,
  edgeVisualStrokeWidth,
  evaluateCommunityQuality,
  GRAPH_COMMUNITY_FOCUS_BUDGETS,
  GRAPH_RENDER_BUDGETS,
  makeEdgePath,
  nodeDisplayModeForDensity,
  screenEffectiveDensityMode
} from "../src/render";
import { UNGROUPED_COMMUNITY_ID, UNGROUPED_COMMUNITY_LABEL } from "../src/types";
import type { GraphData } from "../src/types";

function sampleGraph(): GraphData {
  return {
    meta: {
      build_date: "2026-06-12T00:00:00.000Z",
      wiki_title: "Stage 4 Demo",
      total_nodes: 4,
      total_edges: 3
    },
    nodes: [
      { id: "topic", label: "主题", type: "topic", community: "c1", source_path: "wiki/topic.md", weight: 80, x: 20, y: 30 },
      { id: "entity", label: "实体", type: "entity", community: "c1", source_path: "wiki/entity.md", weight: 50 },
      { id: "source", label: "来源", type: "source", community: "c2", source_path: "wiki/source.md", weight: 40, x: 70, y: 60 },
      { id: "island", label: "孤岛", type: "entity", community: "c3", source_path: "wiki/island.md", weight: 10 }
    ],
    edges: [
      { id: "e1", from: "topic", to: "entity", type: "EXTRACTED", confidence: "EXTRACTED", relation_type: "实现", weight: 1 },
      { id: "e2", from: "topic", to: "source", type: "INFERRED", confidence: "INFERRED", relation_type: "对比", weight: 0.5 },
      { id: "missing", from: "topic", to: "missing", type: "UNVERIFIED", weight: 0.1 }
    ],
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "topic", recommended_start_reason: "community_hub", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: ["topic", "entity", "source", "island"], degraded: false }
      },
      communities: [
        { id: "c1", label: "核心", node_count: 2, color_index: 0, recommended_start_node_id: "topic" },
        { id: "c2", label: "来源", node_count: 1, color_index: 1 },
        { id: "c3", label: "孤岛", node_count: 1, color_index: 2 }
      ]
    }
  };
}

function outlierCommunityGraph(): GraphData {
  const nodes = [
    { id: "core-a", label: "Core A", type: "entity", community: "c1", source_path: "wiki/core-a.md", weight: 70, x: 20, y: 40 },
    { id: "core-b", label: "Core B", type: "entity", community: "c1", source_path: "wiki/core-b.md", weight: 65, x: 22, y: 42 },
    { id: "core-c", label: "Core C", type: "topic", community: "c1", source_path: "wiki/core-c.md", weight: 80, x: 24, y: 39 },
    { id: "core-d", label: "Core D", type: "source", community: "c1", source_path: "wiki/core-d.md", weight: 55, x: 26, y: 41 },
    { id: "outlier", label: "Outlier", type: "entity", community: "c1", source_path: "wiki/outlier.md", weight: 35, x: 92, y: 78 }
  ];
  return {
    meta: {
      build_date: "2026-06-12T00:00:00.000Z",
      wiki_title: "Outlier Fixture",
      total_nodes: nodes.length,
      total_edges: 0
    },
    nodes,
    edges: [],
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "core-c", recommended_start_reason: "community_hub", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: [
        { id: "c1", label: "Cluster", node_count: nodes.length, color_index: 0, recommended_start_node_id: "core-c" }
      ]
    }
  };
}

function budgetGraph(nodeCount: number, edgeCount: number): GraphData {
  const nodes = Array.from({ length: nodeCount }, (_, index) => ({
    id: `n${index}`,
    label: `Budget node ${index}`,
    type: index % 7 === 0 ? "topic" : index % 11 === 0 ? "source" : "entity",
    community: "c1",
    source_path: `wiki/budget/n${index}.md`,
    weight: 100 - (index % 83),
    x: (index * 37) % 100,
    y: (index * 53) % 100
  }));
  const edges: NonNullable<GraphData["edges"]> = [];
  for (let sourceIndex = 0; sourceIndex < nodeCount && edges.length < edgeCount; sourceIndex += 1) {
    for (let targetIndex = sourceIndex + 1; targetIndex < nodeCount && edges.length < edgeCount; targetIndex += 1) {
      edges.push({
        id: `e${edges.length}`,
        from: `n${sourceIndex}`,
        to: `n${targetIndex}`,
        type: "EXTRACTED",
        confidence: "EXTRACTED",
        relation_type: edges.length % 3 === 0 ? "实现" : "依赖",
        weight: (edges.length % 10) / 10
      });
    }
  }

  return {
    meta: {
      build_date: "2026-06-18T00:00:00.000Z",
      wiki_title: "Budget Fixture",
      total_nodes: nodes.length,
      total_edges: edges.length
    },
    nodes,
    edges,
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "n0", recommended_start_reason: "budget_fixture", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: [
        { id: "c1", label: "Budget Community", node_count: nodes.length, color_index: 0, recommended_start_node_id: "n0" }
      ]
    }
  };
}

function densePointMapGraph(): GraphData {
  const nodeCount = 2000;
  const edgeTarget = 3996;
  const communityCount = 16;
  const nodes = Array.from({ length: nodeCount }, (_, index) => ({
    id: `dense-${index}`,
    label: `Dense node ${index}`,
    type: index % 17 === 0 ? "topic" : index % 29 === 0 ? "source" : "entity",
    community: `dense-community-${index % communityCount}`,
    source_path: `wiki/dense/dense-${index}.md`,
    weight: 100 - (index % 97),
    x: (index * 37) % 100,
    y: (index * 53) % 100
  }));
  const edges: NonNullable<GraphData["edges"]> = [
    {
      id: "dense-selected-weak",
      from: "dense-1999",
      to: "dense-1",
      type: "INFERRED",
      confidence: "INFERRED",
      relation_type: "依赖",
      weight: 0
    },
    {
      id: "dense-selected-strong",
      from: "dense-1999",
      to: "dense-2",
      type: "EXTRACTED",
      confidence: "EXTRACTED",
      relation_type: "实现",
      weight: 1
    }
  ];

  for (let index = 0; edges.length < edgeTarget; index += 1) {
    const source = index % nodeCount;
    const target = (source + 1 + (index % 113)) % nodeCount;
    if (source === target) continue;
    edges.push({
      id: `dense-edge-${index}`,
      from: `dense-${source}`,
      to: `dense-${target}`,
      type: index % 5 === 0 ? "INFERRED" : "EXTRACTED",
      confidence: index % 5 === 0 ? "INFERRED" : "EXTRACTED",
      relation_type: index % 7 === 0 ? "对比" : "依赖",
      weight: (index % 11) / 10
    });
  }

  return {
    meta: {
      build_date: "2026-06-21T00:00:00.000Z",
      wiki_title: "Dense Point Map Fixture",
      total_nodes: nodes.length,
      total_edges: edges.length
    },
    nodes,
    edges,
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "dense-0", recommended_start_reason: "dense_fixture", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: Array.from({ length: communityCount }, (_, index) => ({
        id: `dense-community-${index}`,
        label: `Dense Community ${index}`,
        node_count: nodes.filter((node) => node.community === `dense-community-${index}`).length,
        color_index: index,
        recommended_start_node_id: index === 0 ? "dense-0" : null
      }))
    }
  };
}

function manyTinyCommunitiesGraph(): GraphData {
  const nodes = Array.from({ length: 10 }, (_, index) => ({
    id: `tiny-${index}`,
    label: `Tiny node ${index}`,
    type: "entity",
    community: `tiny-${index}`,
    source_path: `wiki/tiny/${index}.md`,
    weight: 20 + index,
    x: (index * 11) % 100,
    y: (index * 17) % 100
  }));
  return {
    meta: {
      build_date: "2026-06-18T00:00:00.000Z",
      wiki_title: "Many Tiny Communities",
      total_nodes: nodes.length,
      total_edges: 0
    },
    nodes,
    edges: [],
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "tiny-0", recommended_start_reason: "fixture", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: nodes.map((node, index) => ({
        id: String(node.community),
        label: `Specific topic ${index}`,
        node_count: 1,
        color_index: index
      }))
    }
  };
}

function oversizedWeakCommunityGraph(): GraphData {
  const nodes = Array.from({ length: 120 }, (_, index) => ({
    id: `blob-${index}`,
    label: `Blob node ${index}`,
    type: index % 9 === 0 ? "topic" : "entity",
    community: "community",
    source_path: `wiki/blob/${index}.md`,
    weight: 60 - (index % 30),
    x: (index * 19) % 100,
    y: (index * 23) % 100
  }));
  return {
    meta: {
      build_date: "2026-06-18T00:00:00.000Z",
      wiki_title: "Oversized Weak Community",
      total_nodes: nodes.length,
      total_edges: 0
    },
    nodes,
    edges: [],
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "blob-0", recommended_start_reason: "fixture", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: true, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: [
        { id: "community", label: "community", node_count: nodes.length, color_index: 0, is_weak: true }
      ]
    }
  };
}

function mixedCrossCommunityGraph(): GraphData {
  const nodes = Array.from({ length: 12 }, (_, index) => ({
    id: `mixed-${index}`,
    label: `Mixed node ${index}`,
    type: "entity",
    community: index < 6 ? "left" : "right",
    source_path: `wiki/mixed/${index}.md`,
    weight: 30,
    x: (index * 13) % 100,
    y: (index * 29) % 100
  }));
  const edges = Array.from({ length: 8 }, (_, index) => ({
    id: `mixed-edge-${index}`,
    from: `mixed-${index % 6}`,
    to: `mixed-${6 + (index % 6)}`,
    type: "INFERRED",
    confidence: "INFERRED",
    relation_type: "依赖",
    weight: 0.5
  }));
  return {
    meta: {
      build_date: "2026-06-18T00:00:00.000Z",
      wiki_title: "Mixed Cross Community",
      total_nodes: nodes.length,
      total_edges: edges.length
    },
    nodes,
    edges,
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "mixed-0", recommended_start_reason: "fixture", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: true, degraded: true },
        global: { enabled: true, node_ids: nodes.map((node) => node.id), degraded: false }
      },
      communities: [
        { id: "left", label: "left", node_count: 6, color_index: 0, is_weak: true },
        { id: "right", label: "right", node_count: 6, color_index: 1, is_weak: true }
      ]
    }
  };
}

describe("buildRenderableGraph", () => {
  it("maps graph data to static renderable nodes, edges, communities, and minimap points", () => {
    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });

    assert.equal(graph.counts.totalNodes, 4);
    assert.equal(graph.nodes.length, 4);
    assert.equal(graph.edges.length, 2);
    assert.equal(graph.communities.length, 3);
    assert.equal(graph.densityMode, "card");
    assert.equal(graph.nodes.find((node) => node.id === "topic")?.visualRole, "index-slip");
    assert.equal(graph.edges[0].type, "extracted");
    assert.equal(graph.edges[0].confidence, "extracted");
    assert.equal(graph.edges[0].relationType, "实现");
    assert.equal(graph.edges[0].relationClass, "relation-implementation");
    assert.equal(graph.edges[1].confidence, "inferred");
    assert.equal(graph.edges[1].relationType, "对比");
    assert.equal(graph.edges[1].relationClass, "relation-contrast");
    assert.match(graph.edges[0].path, /^M \d+ \d+ Q /);
    assert.equal(graph.minimap.path, "M8 40 C34 20 54 36 76 22 C98 8 118 24 150 12");
    assert.equal(graph.minimap.nodes.length, 4);
  });

  it("uses low-weight global edges and fuller focused relation edges", () => {
    const global = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });
    const focused = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" }
    });

    assert.equal(global.edges.find((edge) => edge.id === "e1")?.relationClass, "relation-implementation");
    assert.equal(global.edges.find((edge) => edge.id === "e2")?.relationClass, "relation-contrast");
    assert.equal(focused.edges[0].relationClass, "relation-implementation");
    assert.ok(focused.edges[0].strokeWidth > global.edges[0].strokeWidth, "focused relation edge should render with a fuller stroke");
    assert.ok(focused.edges[0].opacity > global.edges[0].opacity, "focused relation edge should render with higher opacity");
  });

  it("uses pins as the cold-start coordinates when a node source path matches", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      pins: {
        "wiki/entity.md": { x: 800, y: 340, coordinateSpace: "world" }
      }
    });

    const pinned = graph.nodes.find((node) => node.id === "entity");
    assert.ok(pinned);
    assert.equal(pinned.x, 80);
    assert.equal(pinned.y, 50);
    assert.deepEqual(pinned.point, { x: 800, y: 340 });
  });

  it("keeps explicit world pins readable even when coordinates look like old percentages", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      pins: {
        "wiki/entity.md": { x: 80, y: -42.5, coordinateSpace: "world" }
      }
    });

    const pinned = graph.nodes.find((node) => node.id === "entity");
    assert.ok(pinned);
    assert.deepEqual(pinned.point, { x: 80, y: -42.5 });
    assert.ok(graph.worldBounds.minY < 0);
  });

  it("continues to read migrated old percent pins with an explicit coordinate-space marker", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      pins: {
        "wiki/entity.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" }
      }
    });

    const pinned = graph.nodes.find((node) => node.id === "entity");
    assert.ok(pinned);
    assert.deepEqual(pinned.point, { x: 800, y: 340 });
  });

  it("infers wiki-relative source paths for graph data without source_path", () => {
    const data = sampleGraph();
    data.nodes = data.nodes.map(({ source_path: _sourcePath, ...node }) => node);
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      pins: {
        "wiki/topics/topic.md": { x: 900, y: 408, coordinateSpace: "world" }
      }
    });

    const topic = graph.nodes.find((node) => node.id === "topic");
    assert.ok(topic);
    assert.equal(topic.sourcePath, "wiki/topics/topic.md");
    assert.deepEqual(topic.point, { x: 900, y: 408 });
  });

  it("marks selected nodes and preserves cinnabar visual role", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "mo-ye",
      selection: { kind: "node", id: "source" }
    });

    const selected = graph.nodes.find((node) => node.id === "source");
    assert.ok(selected);
    assert.equal(selected.selected, true);
    assert.equal(selected.visualRole, "cinnabar-note");
    assert.equal(graph.minimap.nodes.find((node) => node.id === "source")?.selected, true);
  });

  it("marks shift-style multi-node selections", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      selection: { kind: "nodes", ids: ["topic", "source"] }
    });

    const selected = graph.nodes.filter((node) => node.selected).map((node) => node.id);
    assert.deepEqual(selected, ["topic", "source"]);
    assert.notEqual(graph.nodes.find((node) => node.id === "topic")?.displayMode, "card");
    assert.equal(graph.nodes.find((node) => node.id === "source")?.visualRole, "cinnabar-note");
    assert.equal(graph.minimap.nodes.filter((node) => node.selected).length, 2);
  });

  it("enforces zero full cards in global view even for selected, search, and pinned nodes", () => {
    const data = budgetGraph(80, 1200);
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "n79" },
      searchResultIds: data.nodes.map((node) => node.id),
      pins: {
        "wiki/budget/n79.md": { x: 900, y: 500, coordinateSpace: "world" }
      }
    });

    assert.equal(graph.budget.view, "global");
    assert.equal(graph.budget.limits.maxCards, GRAPH_RENDER_BUDGETS.global.maxCards);
    assert.equal(graph.budget.usage.maxCards, 0);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.ok(graph.nodes.find((node) => node.id === "n79")?.labelVisible, "selected and pinned node should be promoted into labels");
  });

  it("keeps global labels, edges, and interaction updates within budget and reports overflow", () => {
    const data = budgetGraph(200, 1200);
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      searchResultIds: data.nodes.map((node) => node.id)
    });

    assert.ok(graph.budget.usage.maxLabels <= GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.ok(graph.budget.usage.maxVisibleEdges <= GRAPH_RENDER_BUDGETS.global.maxVisibleEdges);
    assert.ok(graph.budget.usage.maxInteractionUpdates <= GRAPH_RENDER_BUDGETS.global.maxInteractionUpdates);
    assert.equal(graph.nodes.filter((node) => node.labelVisible).length, GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.equal(graph.edges.length, GRAPH_RENDER_BUDGETS.global.maxVisibleEdges);
    assert.ok(graph.overflow.labels.hidden > 0);
    assert.ok(graph.overflow.edges.hidden > 0);
    assert.ok(graph.overflow.interactionUpdates.hidden > 0);
    assert.equal(graph.overflow.labels.total, 200);
    assert.equal(graph.overflow.edges.total, 1200);
  });

  it("keeps interaction-time detail updates inside budget while preserving anchors", () => {
    const data = budgetGraph(200, 1200);
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "n199" },
      searchResultIds: ["n198", "n199"],
      pins: {
        "wiki/budget/n197.md": { x: 850, y: 500, coordinateSpace: "world" }
      }
    });

    assert.ok(graph.interaction.updatedObjects <= GRAPH_RENDER_BUDGETS.global.maxInteractionUpdates);
    assert.ok(graph.interaction.updateCandidates < graph.overflow.interactionUpdates.total);
    assert.ok(graph.interaction.edgesVisibleDuringInteraction <= graph.budget.usage.maxVisibleEdges);
    assert.ok(graph.interaction.preservedNodeIds.includes("n199"), "selected node should stay traceable");
    assert.ok(graph.interaction.preservedNodeIds.includes("n198"), "searched node should stay traceable");
    assert.ok(graph.interaction.preservedNodeIds.includes("n197"), "pinned node should stay traceable");
    assert.ok(graph.interaction.preservedNodeIds.some((id) => graph.importance.stableCoreNodeIds.includes(id)), "stable core anchors should stay traceable");
  });

  it("keeps focused community nodes as a lightweight map without full cards", () => {
    const data = budgetGraph(80, 1200);
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      searchResultIds: data.nodes.map((node) => node.id),
      pins: {
        "wiki/budget/n79.md": { x: 900, y: 500, coordinateSpace: "world" }
      }
    });

    assert.equal(graph.budget.view, "community");
    assert.equal(graph.nodes.length, 80);
    assert.equal(graph.budget.limits.maxCards, 0);
    assert.equal(graph.budget.usage.maxCards, 0);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.ok(graph.nodes.find((node) => node.id === "n79")?.labelVisible, "selected/search/pinned context should still be eligible for a label");
    assert.ok(graph.nodes.filter((node) => node.labelVisible).length <= graph.budget.limits.maxLabels);
    assert.equal(graph.overflow.cards.total, 0);
    assert.equal(graph.overflow.cards.hidden, 0);

    const firstNode = graph.nodes[0];
    assert.ok(firstNode.communityMapDotSize >= 9, `community map dot should keep a floor size, got ${firstNode.communityMapDotSize}`);
    assert.ok(firstNode.communityMapDotSize <= 24, `community map dot should respect the importance ceiling, got ${firstNode.communityMapDotSize}`);
    assert.ok(["left", "right", "top", "bottom"].includes(firstNode.communityMapLabelSide));
    assert.equal(typeof firstNode.communityMapRelationLabel, "boolean");
  });

  it("uses the small community band as a lightweight map with sparse labels", () => {
    const graph = buildRenderableGraph(budgetGraph(24, 120), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" }
    });

    assert.equal(graph.communityFocus?.sizeBand, "small");
    assert.equal(graph.communityFocus?.representation, "cards-and-labels");
    assert.equal(graph.communityFocus?.completePresence, "nodes");
    assert.equal(graph.nodes.length, 24);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.ok(graph.nodes.filter((node) => node.labelVisible).length <= GRAPH_COMMUNITY_FOCUS_BUDGETS.small.maxLabels);
    assert.ok(graph.nodes.some((node) => node.displayMode === "point" || node.displayMode === "overview"), "ordinary nodes should remain point-like");
  });

  it("uses the medium community band with all nodes present and no full cards", () => {
    const graph = buildRenderableGraph(budgetGraph(120, 600), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      searchResultIds: Array.from({ length: 120 }, (_, index) => `n${index}`)
    });
    const cardCount = graph.nodes.filter((node) => node.displayMode === "card").length;
    const pointCount = graph.nodes.filter((node) => node.displayMode === "point" || node.displayMode === "overview").length;

    assert.equal(graph.communityFocus?.sizeBand, "medium");
    assert.equal(graph.communityFocus?.representation, "points-with-cards");
    assert.equal(graph.nodes.length, 120);
    assert.equal(cardCount, 0);
    assert.ok(pointCount > 0);
    assert.ok(graph.nodes.filter((node) => node.labelVisible).length <= GRAPH_COMMUNITY_FOCUS_BUDGETS.medium.maxLabels);
  });

  it("uses the large community band as a lightweight outline map with strict label caps", () => {
    const graph = buildRenderableGraph(budgetGraph(800, 1400), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      searchResultIds: Array.from({ length: 800 }, (_, index) => `n${index}`)
    });

    assert.equal(graph.communityFocus?.sizeBand, "large");
    assert.equal(graph.communityFocus?.representation, "outline-with-caps");
    assert.equal(graph.communityFocus?.completePresence, "outline");
    assert.equal(graph.nodes.length, 800);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.equal(graph.nodes.filter((node) => node.labelVisible).length, GRAPH_COMMUNITY_FOCUS_BUDGETS.large.maxLabels);
    assert.ok(graph.edges.length > 0);
    assert.ok(graph.edges.length <= GRAPH_COMMUNITY_FOCUS_BUDGETS.large.maxVisibleEdges);
  });

  it("uses the oversized community band as an internal-map entry without rendering every member as a card", () => {
    const graph = buildRenderableGraph(budgetGraph(3000, 1200), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      searchResultIds: Array.from({ length: 3000 }, (_, index) => `n${index}`)
    });

    assert.equal(graph.communityFocus?.sizeBand, "oversized");
    assert.equal(graph.communityFocus?.representation, "internal-map-entry");
    assert.equal(graph.communityFocus?.completePresence, "internal-map");
    assert.equal(graph.nodes.length, GRAPH_COMMUNITY_FOCUS_BUDGETS.oversized.maxVisibleNodes);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.equal(graph.nodes.filter((node) => node.labelVisible).length, GRAPH_COMMUNITY_FOCUS_BUDGETS.oversized.maxLabels);
    assert.ok(graph.overflow.nodes.hidden > 0);
  });

  it("keeps stable core anchors unchanged when search boosts change", () => {
    const data = budgetGraph(200, 1200);
    const baseline = buildRenderableGraph(data, { theme: "shan-shui" });
    const searched = buildRenderableGraph(data, {
      theme: "shan-shui",
      searchResultIds: data.nodes.slice(120).map((node) => node.id)
    });

    assert.deepEqual(searched.importance.stableCoreNodeIds, baseline.importance.stableCoreNodeIds);
    assert.deepEqual(searched.importance.stableSkeletonEdgeIds, baseline.importance.stableSkeletonEdgeIds);
    assert.ok(searched.importance.temporaryBoostNodeIds.includes("n199"));
    assert.equal(searched.nodes.find((node) => node.id === "n199")?.coreAnchor, baseline.nodes.find((node) => node.id === "n199")?.coreAnchor);
  });

  it("lets search and selection boost visibility without rewriting stable core identity", () => {
    const data = budgetGraph(200, 1200);
    const baseline = buildRenderableGraph(data, { theme: "shan-shui" });
    const boosted = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "n199" },
      searchResultIds: ["n199"]
    });
    const node = boosted.nodes.find((item) => item.id === "n199");

    assert.ok(node);
    assert.deepEqual(boosted.importance.stableCoreNodeIds, baseline.importance.stableCoreNodeIds);
    assert.equal(node.labelVisible, true);
    assert.ok(node.temporaryBoost > 0);
    assert.equal(node.coreAnchor, baseline.nodes.find((item) => item.id === "n199")?.coreAnchor);
  });

  it("keeps many search hits, many pins, and a pressured selected object inside budget caps", () => {
    const data = budgetGraph(200, 1200);
    const pins = Object.fromEntries(
      data.nodes.slice(80).map((node) => [node.source_path || `wiki/budget/${node.id}.md`, { x: 700, y: 420, coordinateSpace: "world" as const }])
    );
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "n199" },
      searchResultIds: data.nodes.map((node) => node.id),
      pins
    });

    assert.ok(graph.importance.temporaryBoostNodeIds.length > GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.ok(graph.budget.usage.maxLabels <= GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.ok(graph.budget.usage.maxVisibleEdges <= GRAPH_RENDER_BUDGETS.global.maxVisibleEdges);
    assert.ok(graph.budget.usage.maxInteractionUpdates <= GRAPH_RENDER_BUDGETS.global.maxInteractionUpdates);
    assert.equal(graph.nodes.find((node) => node.id === "n199")?.labelVisible, true);
    assert.ok(graph.overflow.labels.hidden > 0);
  });

  it("keeps crowded accepted global graphs as sparse point maps without aggregation", () => {
    const data = densePointMapGraph();
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "dense-1999" },
      searchResultIds: ["dense-20", "dense-120", "dense-1220"],
      pins: {
        "wiki/dense/dense-40.md": { x: 860, y: 500, coordinateSpace: "world" },
        "wiki/dense/dense-1440.md": { x: 920, y: 540, coordinateSpace: "world" }
      },
      aggregationMarkers: [
        {
          id: "dense-aggregation",
          label: "Dense aggregation should stay hidden",
          communityId: "dense-community-0",
          nodeIds: data.nodes.slice(0, 200).map((node) => node.id),
          totalCount: 200
        }
      ]
    });
    const selected = graph.nodes.find((node) => node.id === "dense-1999");
    const searched = ["dense-20", "dense-120", "dense-1220"].map((id) => graph.nodes.find((node) => node.id === id));
    const pinned = ["dense-40", "dense-1440"].map((id) => graph.nodes.find((node) => node.id === id));
    const ordinaryNodes = graph.nodes.filter((node) => !node.selected && node.temporaryBoost === 0 && !node.coreAnchor);
    const weakEdge = graph.edges.find((edge) => edge.id === "dense-selected-weak");
    const strongEdge = graph.edges.find((edge) => edge.id === "dense-selected-strong");

    assert.equal(graph.counts.visibleNodes, 2000);
    assert.equal(graph.counts.totalEdges, 3996);
    assert.equal(graph.budget.view, "global");
    assert.equal(graph.densityMode, "overview");
    assert.equal(graph.aggregationContainers.length, 0);
    assert.equal(graph.budget.usage.maxCards, 0);
    assert.equal(graph.nodes.filter((node) => node.displayMode === "card").length, 0);
    assert.ok(ordinaryNodes.length > 1500);
    assert.ok(ordinaryNodes.every((node) => node.displayMode === "overview"), "ordinary dense nodes should stay in overview point mode");
    assert.ok(graph.budget.usage.maxLabels <= GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.ok(graph.nodes.filter((node) => node.labelVisible).length <= GRAPH_RENDER_BUDGETS.global.maxLabels);
    assert.ok(graph.nodes.filter((node) => node.labelVisible).length / graph.nodes.length <= 0.03);
    assert.ok(graph.budget.usage.maxVisibleEdges <= GRAPH_RENDER_BUDGETS.global.maxVisibleEdges);
    assert.ok(graph.budget.usage.maxInteractionUpdates <= GRAPH_RENDER_BUDGETS.global.maxInteractionUpdates);
    assert.ok(graph.interaction.updatedObjects <= GRAPH_RENDER_BUDGETS.global.maxInteractionUpdates);
    assert.ok(selected);
    assert.equal(selected.selected, true);
    assert.equal(selected.labelVisible, true);
    assert.ok(searched.every(Boolean));
    assert.ok(searched.every((node) => node?.labelVisible === true));
    assert.ok(pinned.every(Boolean));
    assert.ok(pinned.every((node) => node?.labelVisible === true));
    assert.ok(graph.importance.stableCoreNodeIds.every((id) => graph.nodes.some((node) => node.id === id)), "core anchors should stay visible");
    assert.ok(weakEdge);
    assert.ok(strongEdge);
    assert.ok(weakEdge.opacity < strongEdge.opacity, "weak dense edges should be faded behind strong edges");
    assert.ok(weakEdge.strokeWidth < strongEdge.strokeWidth, "weak dense edges should be thinner than strong edges");
  });

  it("does not produce visible aggregation containers in the normal render model", () => {
    const data = budgetGraph(20, 40);
    const pins = {
      "wiki/budget/n3.md": { x: 700, y: 420, coordinateSpace: "world" as const }
    };
    const graph = buildRenderableGraph(data, {
      theme: "shan-shui",
      selection: { kind: "node", id: "n2" },
      searchResultIds: ["n1", "n4"],
      pins,
      aggregationMarkers: [
        {
          id: "agg-c1",
          label: "Budget container",
          communityId: "c1",
          nodeIds: ["n1", "n2", "n3", "n4"],
          totalCount: 12
        }
      ]
    });

    assert.deepEqual(graph.aggregationContainers, []);
  });

  it("marks moderate community quality without auxiliary organization modes", () => {
    const graph = buildRenderableGraph(manyTinyCommunitiesGraph(), { theme: "shan-shui" });

    assert.equal(graph.communityQuality.level, "moderate");
    assert.equal(graph.communityQuality.boundaryCertainty, "reduced");
    assert.equal(graph.communityQuality.warning, "moderate-community-quality");
    assert.deepEqual(graph.communityQuality.signals.map((signal) => signal.id), ["many-tiny-communities"]);
    assert.deepEqual(graph.communityQuality.auxiliaryViews, []);
  });

  it("lowers boundary certainty and exposes only core connectivity for poor community quality", () => {
    const graph = buildRenderableGraph(oversizedWeakCommunityGraph(), { theme: "shan-shui" });

    assert.equal(graph.communityQuality.level, "poor");
    assert.equal(graph.communityQuality.boundaryCertainty, "low");
    assert.deepEqual(graph.communityQuality.auxiliaryViews, [
      { id: "core-structure-connectivity", label: "核心结构 / 连通性" }
    ]);
    assert.deepEqual(
      graph.communityQuality.signals.map((signal) => signal.id),
      ["oversized-community", "weak-community-labels", "abnormal-community-count"]
    );
    assert.ok(graph.communities.every((community) => community.boundaryCertainty === "low"));
    assert.deepEqual(graph.communityQuality.auxiliaryViews.map((view) => view.id), ["core-structure-connectivity"]);
    assert.equal(graph.communityQuality.auxiliaryViews.some((view) => /type|source|time/i.test(view.id)), false);
  });

  it("detects mixed cross-community edges as an explicit quality signal", () => {
    const quality = evaluateCommunityQuality(mixedCrossCommunityGraph());

    assert.equal(quality.level, "poor");
    assert.ok(quality.signals.some((signal) => signal.id === "mixed-cross-community-edges"));
    assert.deepEqual(quality.auxiliaryViews.map((view) => view.id), ["core-structure-connectivity"]);
  });

  it("enters a community focus view by hiding nodes outside the selected community", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" }
    });

    assert.deepEqual(graph.nodes.map((node) => node.id), ["topic", "entity"]);
    assert.deepEqual(graph.edges.map((edge) => edge.id), ["e1"]);
    assert.equal(graph.counts.visibleNodes, 2);
    assert.equal(graph.counts.totalNodes, 4);
    assert.equal(graph.focus?.kind, "community");
    assert.equal(graph.focus?.id, "c1");
    assert.deepEqual(
      communityWashStates(graph),
      [["c1", true], ["c2", false], ["c3", false]]
    );
  });

  it("filters visible nodes by graph node type and stacks with community focus", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      typeFilters: {
        entity: true,
        topic: false,
        source: true
      }
    });

    assert.deepEqual(graph.nodes.map((node) => node.id), ["entity"]);
    assert.deepEqual(graph.edges, []);
    assert.equal(graph.counts.visibleNodes, 1);
    assert.equal(graph.typeFilters.topic, false);
  });

  it("preserves community focus and type filters when positions are reapplied", () => {
    const graph = buildRenderableGraph(sampleGraph(), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      typeFilters: {
        entity: true,
        topic: false,
        source: true
      },
      positions: {
        topic: { x: 500, y: 500 },
        entity: { x: 420, y: 320 },
        source: { x: 900, y: 120 },
        island: { x: 120, y: 120 }
      }
    });

    assert.deepEqual(graph.nodes.map((node) => node.id), ["entity"]);
    assert.deepEqual(graph.edges, []);
    assert.equal(graph.focus?.id, "c1");
    assert.equal(graph.typeFilters.topic, false);
    assert.deepEqual(
      communityWashStates(graph),
      [["c1", true], ["c2", false], ["c3", false]]
    );
  });

  it("keeps community wash around the member cluster instead of chasing an outlier", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), { theme: "shan-shui" });
    const community = graph.communities.find((item) => item.id === "c1");

    assert.ok(community?.wash);
    assert.equal(community.nodeCount, 5);
    assert.ok(community.wash.cx > 300, `wash center should respond toward the outlier, got ${community.wash.cx}`);
    assert.ok(community.wash.cx < 430, `wash center should stay near the clustered members, got ${community.wash.cx}`);
    assert.equal(community.wash.rx, 190);
    assert.equal(community.wash.ry, 142.8);
  });

  it("keeps community membership stable when a pinned member is outside the wash cap", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      pins: {
        "wiki/outlier.md": { x: 980, y: 650 }
      }
    });
    const community = graph.communities.find((item) => item.id === "c1");
    const outlier = graph.nodes.find((node) => node.id === "outlier");

    assert.ok(community?.wash);
    assert.ok(outlier);
    assert.equal(outlier.community, "c1");
    assert.equal(community.nodeCount, 5);
    assert.equal(community.wash.rx, 190);
    assert.equal(community.wash.ry, 142.8);
    assert.ok(outlier.point.x > community.wash.cx + community.wash.rx, "pinned member may sit outside the capped visual wash");
  });

  it("lets a dragged core member reshape the wash within caps without changing membership", () => {
    const before = buildRenderableGraph(outlierCommunityGraph(), { theme: "shan-shui" });
    const after = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      positions: {
        "core-a": { x: 980, y: 650 }
      }
    });
    const beforeCommunity = before.communities.find((item) => item.id === "c1");
    const afterCommunity = after.communities.find((item) => item.id === "c1");
    const dragged = after.nodes.find((node) => node.id === "core-a");

    assert.ok(beforeCommunity?.wash);
    assert.ok(afterCommunity?.wash);
    assert.ok(dragged);
    assert.equal(dragged.community, "c1");
    assert.equal(afterCommunity.nodeCount, beforeCommunity.nodeCount);
    assert.notEqual(afterCommunity.wash.cx, beforeCommunity.wash.cx);
    assert.ok(afterCommunity.wash.cx > beforeCommunity.wash.cx, "wash should move toward the dragged member");
    assert.equal(afterCommunity.wash.rx, 190);
    assert.equal(afterCommunity.wash.ry, 142.8);
  });

  it("preserves community focus after a member is dragged beyond the wash cap", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      focus: { kind: "community", id: "c1" },
      positions: {
        outlier: { x: 980, y: 650 }
      }
    });
    const community = graph.communities.find((item) => item.id === "c1");

    assert.deepEqual(graph.nodes.map((node) => node.id).sort(), ["core-a", "core-b", "core-c", "core-d", "outlier"]);
    assert.ok(community?.wash);
    assert.equal(graph.focus?.id, "c1");
    assert.equal(community.wash.rx, 190);
    assert.equal(community.wash.ry, 142.8);
  });

  it("preserves live drag positions outside the old default world", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      positions: {
        outlier: { x: 1240, y: 816 }
      }
    });
    const outlier = graph.nodes.find((node) => node.id === "outlier");

    assert.ok(outlier);
    assert.deepEqual(outlier.point, { x: 1240, y: 816 });
    assert.equal(outlier.x, 93.939);
    assert.equal(outlier.y, 91.071);
    assert.equal(graph.worldBounds.maxX, 1320);
    assert.equal(graph.worldBounds.maxY, 896);
    assert.equal(outlier.community, "c1");
  });

  it("preserves pinned positions outside the old default world by expanding render bounds", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      pins: {
        "wiki/outlier.md": { x: 1240, y: 816, coordinateSpace: "world" }
      }
    });
    const outlier = graph.nodes.find((node) => node.id === "outlier");

    assert.ok(outlier);
    assert.deepEqual(outlier.point, { x: 1240, y: 816 });
    assert.equal(outlier.x, 93.939);
    assert.equal(outlier.y, 91.071);
    assert.equal(graph.worldBounds.width, 1320);
    assert.equal(graph.worldBounds.height, 896);
  });

  it("does not let expanded render bounds enlarge the community wash cap", () => {
    const graph = buildRenderableGraph(outlierCommunityGraph(), {
      theme: "shan-shui",
      positions: {
        outlier: { x: 5000, y: 3400 }
      }
    });
    const community = graph.communities.find((item) => item.id === "c1");
    const outlier = graph.nodes.find((node) => node.id === "outlier");

    assert.ok(community?.wash);
    assert.ok(outlier);
    assert.ok(graph.worldBounds.width > 5000, `world bounds should expand to include the outlier, got ${graph.worldBounds.width}`);
    assert.ok(graph.worldBounds.height > 3400, `world bounds should expand to include the outlier, got ${graph.worldBounds.height}`);
    assert.equal(community.wash.rx, 190);
    assert.equal(community.wash.ry, 142.8);
    assert.ok(outlier.point.x > community.wash.cx + community.wash.rx, "the node can sit outside the capped visual wash");
    assert.equal(outlier.community, "c1");
  });

  it("normalizes ungrouped nodes into a selectable render community", () => {
    const graph = buildRenderableGraph(graphFixtureWithUngroupedNodes(), {
      selection: { kind: "community", id: UNGROUPED_COMMUNITY_ID }
    });

    const ungrouped = graph.communities.find((community) => community.id === UNGROUPED_COMMUNITY_ID);
    assert.equal(ungrouped?.label, UNGROUPED_COMMUNITY_LABEL);
    assert.ok(ungrouped?.wash, "ungrouped community should be clickable when its nodes are visible");
    assert.deepEqual(
      graph.nodes.filter((node) => node.community === UNGROUPED_COMMUNITY_ID && node.selected).map((node) => node.id),
      ["loose-a", "loose-b"]
    );
  });
});

function communityWashStates(graph: ReturnType<typeof buildRenderableGraph>): Array<[string, boolean]> {
  return graph.communities
    .map((community): [string, boolean] => [community.id, Boolean(community.wash)])
    .sort(([left], [right]) => left.localeCompare(right));
}

describe("screen-effective density", () => {
  it("uses viewport scale to choose the effective density mode", () => {
    assert.equal(screenEffectiveDensityMode(120, 1), "compact-card");
    assert.equal(screenEffectiveDensityMode(120, 2), "card");
    assert.equal(screenEffectiveDensityMode(120, 0.5), "point-plus-focus");
    assert.equal(screenEffectiveDensityMode(30, 0.5), "compact-card");
  });

  it("maps effective density to node display without changing selected cards", () => {
    const node = {
      selected: false,
      labelVisible: false,
      visualRole: "map-pin" as const
    };
    const labeledNode = {
      selected: false,
      labelVisible: true,
      visualRole: "map-pin" as const
    };
    const selectedNode = {
      selected: true,
      labelVisible: false,
      visualRole: "map-pin" as const
    };

    assert.equal(nodeDisplayModeForDensity(node, "card"), "card");
    assert.equal(nodeDisplayModeForDensity(node, "compact-card"), "compact-card");
    assert.equal(nodeDisplayModeForDensity(node, "point-plus-focus"), "point");
    assert.equal(nodeDisplayModeForDensity(labeledNode, "point-plus-focus"), "compact-card");
    assert.equal(nodeDisplayModeForDensity(selectedNode, "overview"), "card");
  });
});

describe("edge drawing helpers", () => {
  it("keeps graph-wash stroke strength bounds", () => {
    assert.equal(edgeStrokeWidth({ weight: 0 }), 1.1);
    assert.equal(edgeStrokeWidth({ weight: 1 }), 2.9);
    assert.equal(edgeOpacity({ weight: 0 }), 0.32);
    assert.equal(edgeOpacity({ weight: 1 }), 0.76);
  });

  it("maps relation type to a separate visual class from confidence", () => {
    assert.equal(edgeRelationClass("实现"), "relation-implementation");
    assert.equal(edgeRelationClass("依赖"), "relation-dependency");
    assert.equal(edgeRelationClass("衍生"), "relation-derivation");
    assert.equal(edgeRelationClass("对比"), "relation-contrast");
    assert.equal(edgeRelationClass("矛盾"), "relation-conflict");
    assert.equal(edgeRelationClass("未知"), "relation-dependency");
  });

  it("keeps global relation edges subdued and focused edges fuller", () => {
    assert.equal(edgeVisualStrokeWidth({ weight: 1 }, false), 1.7);
    assert.equal(edgeVisualStrokeWidth({ weight: 1 }, true), 2.9);
    assert.equal(edgeVisualOpacity({ weight: 1 }, false), 0.42);
    assert.equal(edgeVisualOpacity({ weight: 1 }, true), 0.76);
  });

  it("builds a curved path from atlas node coordinates", () => {
    const path = makeEdgePath(
      { id: "a", label: "A", type: "entity", kind: "概念", community: "c1", x: 10, y: 20 },
      { id: "b", label: "B", type: "entity", kind: "概念", community: "c1", x: 60, y: 70 },
      { weight: 0.5 }
    );

    assert.equal(path, "M 100 136 Q 274 284 600 476");
  });
});

function graphFixtureWithUngroupedNodes(): GraphData {
  return {
    meta: {
      build_date: "2026-06-18T00:00:00.000Z",
      wiki_title: "Ungrouped render graph",
      total_nodes: 4,
      total_edges: 1
    },
    nodes: [
      { id: "a", label: "Alpha", type: "topic", community: "alpha", source_path: "wiki/alpha/a.md", weight: 2 },
      { id: "b", label: "Beta", type: "entity", community: "alpha", source_path: "wiki/alpha/b.md" },
      { id: "loose-a", label: "Loose A", type: "topic", community: null, source_path: "wiki/loose/a.md", score: 2 },
      { id: "loose-b", label: "Loose B", type: "entity", source_path: "wiki/loose/b.md", weight: 1 }
    ],
    edges: [
      { id: "a-b", from: "a", to: "b", type: "EXTRACTED", relation_type: "实现", weight: 0.6 }
    ],
    learning: {
      version: 1,
      entry: { recommended_start_node_id: "a", recommended_start_reason: "hub", default_mode: "global" },
      views: {
        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
        global: { enabled: true, node_ids: ["a", "b"], degraded: false }
      },
      communities: [
        { id: "alpha", label: "Alpha", node_count: 2, color_index: 0, members: ["a", "b"] }
      ]
    }
  };
}