// 假设已通过 madge 生成依赖数据 dependencyData.json
// 结构大致为：{ "graph": { "src/a.js": ["src/b.js", "lodash"], ... } }

import * as d3 from 'd3';

async function renderDependencyGraph() {
  const response = await fetch('./dependencyData.json');
  const data = await response.json();

  const nodes = [];
  const links = [];
  const nodeMap = new Map();

  // 构建节点和边
  Object.keys(data.graph).forEach(sourcePath => {
    if (!nodeMap.has(sourcePath)) {
      nodeMap.set(sourcePath, { id: sourcePath });
      nodes.push({ id: sourcePath });
    }
    data.graph[sourcePath].forEach(targetPath => {
      if (!nodeMap.has(targetPath)) {
        nodeMap.set(targetPath, { id: targetPath });
        nodes.push({ id: targetPath });
      }
      links.push({ source: sourcePath, target: targetPath });
    });
  });

  const width = 1200, height = 800;
  const svg = d3.select('#graph-container')
    .append('svg')
    .attr('width', width)
    .attr('height', height);

  const simulation = d3.forceSimulation(nodes)
    .force('link', d3.forceLink(links).id(d => d.id).distance(100))
    .force('charge', d3.forceManyBody().strength(-300))
    .force('center', d3.forceCenter(width / 2, height / 2));

  const link = svg.append('g')
    .selectAll('line')
    .data(links)
    .enter().append('line')
    .attr('stroke', '#999')
    .attr('stroke-opacity', 0.6);

  const node = svg.append('g')
    .selectAll('circle')
    .data(nodes)
    .enter().append('circle')
    .attr('r', 5)
    .attr('fill', d => d.id.startsWith('node_modules') ? '#f06' : '#69b3a2')
    .call(d3.drag()
      .on('start', dragstarted)
      .on('drag', dragged)
      .on('end', dragended));

  node.append('title').text(d => d.id);

  simulation.on('tick', () => {
    link
      .attr('x1', d => d.source.x)
      .attr('y1', d => d.source.y)
      .attr('x2', d => d.target.x)
      .attr('y2', d => d.target.y);
    node
      .attr('cx', d => d.x)
      .attr('cy', d => d.y);
  });

  function dragstarted(event) {
    if (!event.active) simulation.alphaTarget(0.3).restart();
    event.subject.fx = event.subject.x;
    event.subject.fy = event.subject.y;
  }
  function dragged(event) {
    event.subject.fx = event.x;
    event.subject.fy = event.y;
  }
  function dragended(event) {
    if (!event.active) simulation.alphaTarget(0);
    event.subject.fx = null;
    event.subject.fy = null;
  }
}

renderDependencyGraph();

// 使用类Tarjan算法检测强连通分量（即循环依赖）
function detectCycles(graph) {
  const index = 0;
  const stack = [];
  const indices = new Map();
  const lowlinks = new Map();
  const cycles = [];

  function strongconnect(node) {
    indices.set(node, index);
    lowlinks.set(node, index);
    index++;
    stack.push(node);

    graph[node]?.forEach(neighbor => {
      if (!indices.has(neighbor)) {
        strongconnect(neighbor);
        lowlinks.set(node, Math.min(lowlinks.get(node), lowlinks.get(neighbor)));
      } else if (stack.includes(neighbor)) {
        lowlinks.set(node, Math.min(lowlinks.get(node), indices.get(neighbor)));
      }
    });

    if (lowlinks.get(node) === indices.get(node)) {
      const cycle = [];
      let w;
      do {
        w = stack.pop();
        cycle.push(w);
      } while (w !== node);
      if (cycle.length > 1) {
        cycles.push(cycle);
      }
    }
  }

  Object.keys(graph).forEach(node => {
    if (!indices.has(node)) {
      strongconnect(node);
    }
  });
  return cycles;
}

const architectureRules = [
  {
    name: 'UI层不能直接依赖API层',
    from: '**/components/**/*.js',
    to: '**/api/**/*.js',
    severity: 'error'
  },
  {
    name: '工具函数保持纯净',
    from: '**/utils/**/*.js',
    to: '**/components/**/*.js',
    severity: 'warning'
  }
];

function validateArchitecture(graph, rules) {
  const violations = [];
  rules.forEach(rule => {
    const fromPattern = new RegExp(rule.from.replace('**', '.*'));
    const toPattern = new RegExp(rule.to.replace('**', '.*'));

    Object.entries(graph).forEach(([source, targets]) => {
      if (fromPattern.test(source)) {
        targets.forEach(target => {
          if (toPattern.test(target)) {
            violations.push({
              rule: rule.name,
              source,
              target,
              severity: rule.severity
            });
          }
        });
      }
    });
  });
  return violations;
}