// lib-a/src/config.js
import { init as initLibB } from '@scope/lib-b';
export const config = { featureX: initLibB().isEnabled };

// lib-b/src/index.js
import { config } from '@scope/lib-a';

export function init() {
  // config 可能为 undefined！
  return { isEnabled: config.featureY }; 
}

"nodes": {
 "@myorg/web-app": {
      "name": "@myorg/web-app",
      "type": "app",
      "data": {
        "root": "packages/apps/web-app",
        "name": "@myorg/web-app",
        "projectType": "application",
        "tags": [
          "scope:web"
        ],
        // ...
      }
    },
}

"externalNodes": {
  "npm:7zip-bin": {
    "type": "npm",
    "name": "npm:7zip-bin",
    "data": {
      "version": "5.2.0",
      "packageName": "7zip-bin",
      "hash": "sha512-..."
    }
  }
}

// 文件 A.ts
import { some } from 'B';

A → [B, C]  (A 依赖 B 和 C)
B → [D]     (B 依赖 D)
C → []      (C 不依赖任何项目)
D → []      (D 不依赖任何项目)

{
  "A": ["B", "C"],
  "B": ["D"],
  "C": [],
  "D": []
}

A → []      (没有项目依赖 A)
B → [A]     (A 依赖 B)
C → [A]     (A 依赖 C)
D → [B]     (B 依赖 D)

{
  "A": [],
  "B": ["A"],
  "C": ["A"],
  "D": ["B"]
}

dependencies: {
  "项目A": [
    { source: "A", target: "B", type: "static" },
    { source: "A", target: "C", type: "static" }
  ],
  "项目B": [
    { source: "B", target: "D", type: "static" }
  ]
}

A → B  (A 依赖 B)
A → C  (A 依赖 C)
B → D  (B 依赖 D)

B → [A]  (B 被 A 依赖，从 B 可反向到达 A)
C → [A]  (C 被 A 依赖)
D → [B]  (D 被 B 依赖)

interface ProjectNode {
  name: string;
  type: 'lib' | 'app';
  data: {
    root: string;
    tags?: string[];
    projectType?: 'library' | 'application';
  };
}

interface Dependency {
  source: string;
  target: string;
  type: 'static' | 'dynamic';
}

interface ProjectGraph {
  nodes: Record<string, ProjectNode>;
  dependencies: Record<string, Dependency[]>;
}



interface DependencyGraph {
  nodes: Map<string, ProjectNode>;
  edges: Map<string, string[]>;
}

/**
 * 将ProjectGraph 转换为邻接表形式
 * 注意：只保留内部项目依赖，过滤掉 npm: 开头的外部依赖
 */
function buildGraph(projectGraph: ProjectGraph): DependencyGraph {
  const nodes = new Map<string, ProjectNode>();
  const edges = new Map<string, string[]>();

  // 添加所有节点
  for (const [name, node] of Object.entries(projectGraph.nodes)) {
    nodes.set(name, node);
    edges.set(name, []);
  }

  // 添加边（只保留内部项目依赖）
  for (const [source, deps] of Object.entries(projectGraph.dependencies)) {
    const internalDeps = deps
      .filter(dep => !dep.target.startsWith('npm:')) // 过滤掉 npm 包
      .filter(dep => nodes.has(dep.target)) // 确保目标节点存在
      .map(dep => dep.target);

    edges.set(source, internalDeps);
  }

  return { nodes, edges };
}

// ========== 3. 可达性矩阵 ==========

interface GraphReachabilityCache {
  graphHash: string; // 用于缓存失效判断
  matrix: Map<string, Set<string>>; // 使用 Set 更高效
  adjList: Map<string, string[]>;
}

/**
 * 预构建可达性矩阵
 */
function buildReachabilityMatrix(graph: DependencyGraph): GraphReachabilityCache {
  const nodeIds = Array.from(graph.nodes.keys());
  // 可达性矩阵
  // matrix[B][A] = true
  const matrix = new Map<string, Set<string>>();
  // 邻接表
  const adjList = graph.edges;

  // 初始化
  for (const nodeId of nodeIds) {
    matrix.set(nodeId, new Set());
  }

  // DFS 计算传递闭包
  const dfs = (sourceId: string, currentId: string) => {
    const reachable = matrix.get(sourceId);
    if (!reachable || reachable.has(currentId)) return;

    reachable.add(currentId);

    for (const neighbor of adjList.get(currentId) || []) {
      dfs(sourceId, neighbor);
    }
  };

  for (const nodeId of nodeIds) {
    dfs(nodeId, nodeId);
  }

  return {
    graphHash: Date.now().toString(),
    matrix,
    adjList,
  };
}

// ========== 4. 循环依赖检测 ==========

interface CycleResult {
  hasCycle: boolean;
  path: string[]; // 循环路径
  readablePath: string; // 可读的路径描述
}

/**
 * 检测添加依赖后是否会形成循环
 *
 * @param graph 项目依赖图
 * @param fromProject 依赖发起方（即将 import 的项目）
 * @param toProject 被依赖方（被 import 的项目）
 * @param cache 可达性缓存
 */
function detectCycleDependency(
  graph: DependencyGraph,
  fromProject: string,
  toProject: string,
  cache?: GraphReachabilityCache,
): CycleResult {
  // 边界检查
  if (!graph.nodes.has(fromProject) || !graph.nodes.has(toProject)) {
    return { hasCycle: false, path: [], readablePath: '' };
  }

  // 自引用
  if (fromProject === toProject) {
    return {
      hasCycle: true,
      path: [fromProject],
      readablePath: `${fromProject} → ${fromProject} (自引用)`,
    };
  }

  // 获取或构建可达性矩阵
  const { matrix, adjList } = cache || buildReachabilityMatrix(graph);

  // 快速检查：toProject 能否到达 fromProject？
  // 如果能，说明 fromProject → toProject 会形成循环
  const canReachBack = matrix.get(toProject)?.has(fromProject);

  if (!canReachBack) {
    return { hasCycle: false, path: [], readablePath: '' };
  }

  // 使用 BFS + 剪枝 找出具体路径
  const path = findPathWithPruning(toProject, fromProject, matrix, adjList);

  if (path.length === 0) {
    return { hasCycle: false, path: [], readablePath: '' };
  }

  // 构建完整循环路径：fromProject → toProject → ... → fromProject
  const cyclePath = [fromProject, ...path];
  const readablePath = cyclePath.join(' → ');

  return {
    hasCycle: true,
    path: cyclePath,
    readablePath,
  };
}

/**
 * BFS + 可达性矩阵剪枝查找路径
 */
function findPathWithPruning(
  sourceId: string,
  targetId: string,
  matrix: Map<string, Set<string>>,
  adjList: Map<string, string[]>,
): string[] {
  if (sourceId === targetId) return [sourceId];

  const queue: Array<[string, string[]]> = [[sourceId, [sourceId]]];
  const visited = new Set<string>([sourceId]);

  while (queue.length > 0) {
    const item = queue.shift();
    if (!item) break;
    const [currentId, path] = item;

    if (currentId === targetId) {
      return path;
    }

    for (const neighborId of adjList.get(currentId) || []) {
      if (visited.has(neighborId)) continue;

      // 剪枝：检查 neighbor 能否到达 target
      if (!matrix.get(neighborId)?.has(targetId)) continue;

      visited.add(neighborId);
      queue.push([neighborId, [...path, neighborId]]);
    }
  }

  return [];
}

// ========== 5. 实用工具函数 ==========

/**
 * 扫描整个图中所有的循环依赖
 */
function findAllCycles(graph: DependencyGraph): CycleResult[] {
  const cache = buildReachabilityMatrix(graph);
  const cycles: CycleResult[] = [];
  const processedPairs = new Set<string>();

  for (const [source, targets] of graph.edges) {
    for (const target of targets) {
      const pairKey = [source, target].toSorted().join('|');
      if (processedPairs.has(pairKey)) continue;

      const result = detectCycleDependency(graph, source, target, cache);
      if (result.hasCycle) {
        cycles.push(result);
        processedPairs.add(pairKey);
      }
    }
  }

  return cycles;
}

/**
 * 格式化输出循环依赖信息
 */
function formatCycleReport(cycles: CycleResult[], graph: DependencyGraph): string {
  if (cycles.length === 0) {
    return '✅ 未发现循环依赖';
  }

  const lines = [`❌ 发现 ${cycles.length} 个循环依赖:\n`];

  cycles.forEach((cycle, index) => {
    lines.push(`${index + 1}. ${cycle.readablePath}`);

    // 显示涉及项目的详细信息
    const details = cycle.path.map(name => {
      const node = graph.nodes.get(name);
      return `   - ${name} (${node?.type || 'unknown'}) @ ${node?.data.root || 'unknown'}`;
    });
    lines.push(...details);
    lines.push('');
  });

  return lines.join('\n');
}

// ========== 6. 使用示例 ==========

// 模拟项目依赖图数据
const mockProjectGraph: ProjectGraph = {
  nodes: {
    'electron-main': {
      name: 'electron-main',
      type: 'app',
      data: { root: 'packages/electron/electron-main', tags: ['electron:app'] },
    },
    'electron-renderer': {
      name: 'electron-renderer',
      type: 'app',
      data: { root: 'packages/electron/electron-renderer', tags: ['electron:web'] },
    },
    'shared-utils': {
      name: 'shared-utils',
      type: 'lib',
      data: { root: 'packages/shared/utils', tags: ['scope:shared'] },
    },
    'shared-components': {
      name: 'shared-components',
      type: 'lib',
      data: { root: 'packages/shared/components', tags: ['scope:shared'] },
    },
    foundation: {
      name: 'foundation',
      type: 'lib',
      data: { root: 'packages/foundation', tags: ['scope:core'] },
    },
  },
  dependencies: {
    'electron-main': [
      { source: 'electron-main', target: 'foundation', type: 'static' },
      { source: 'electron-main', target: 'npm:electron', type: 'static' },
    ],
    'electron-renderer': [
      { source: 'electron-renderer', target: 'shared-components', type: 'static' },
      { source: 'electron-renderer', target: 'shared-utils', type: 'static' },
    ],
    'shared-components': [
      { source: 'shared-components', target: 'shared-utils', type: 'static' },
      // 故意添加循环依赖用于测试
      { source: 'shared-components', target: 'electron-renderer', type: 'static' },
    ],
    'shared-utils': [{ source: 'shared-utils', target: 'foundation', type: 'static' }],
    foundation: [],
  },
};

// 运行检测
const depGraph = buildGraph(mockProjectGraph);
const reachabilityCache = buildReachabilityMatrix(depGraph);

// 场景1：检测现有依赖是否形成循环
console.log('=== 检测 electron-renderer → shared-components ===');
const result1 = detectCycleDependency(
  depGraph,
  'electron-renderer',
  'shared-components',
  reachabilityCache,
);
console.log(result1);


// 场景2：检测添加新依赖是否安全
console.log('\n=== 检测 foundation → shared-utils 是否安全 ===');
const result2 = detectCycleDependency(depGraph, 'foundation', 'shared-utils', reachabilityCache);
console.log(result2);


// 场景3：扫描所有循环
console.log('\n=== 扫描所有循环依赖 ===');
const allCycles = findAllCycles(depGraph);
console.log(formatCycleReport(allCycles, depGraph));

// ❌ 错误
import { foo } from '../../libs/shared';

// ✅ 正确
import { foo } from '@myorg/shared';

// ❌ 错误
import _ from '../../node_modules/lodash';
import axios from '/home/user/project/node_modules/axios';

// ✅ 正确
import _ from 'lodash';

// 在 @myorg/shared 库内部
// ❌ 错误
import { helper } from '@myorg/shared';

// ✅ 正确
import { helper } from './helper';

项目 A → 项目 B → 项目 C → 项目 A  ❌

// ❌ 错误（从 lib 导入 app）
import { AppComponent } from '@myorg/my-app';

// ❌ 错误
import { testUtils } from '@myorg/my-app-e2e';

buildable-lib → non-buildable-lib  ❌

// 假设 feature-dashboard 配置为懒加载
// ❌ 错误
import { DashboardModule } from '@myorg/feature-dashboard';

// ✅ 正确（动态导入）
loadChildren: () => import('@myorg/feature-dashboard')

// 配置：type:feature 只能依赖 type:util 或 type:data
// ❌ 错误：feature 依赖了另一个 feature
import { OtherFeature } from '@myorg/other-feature';

// 配置：onlyDependOnLibsWithTags: []
// ❌ 目标库有标签

// 配置：scope:client 不能依赖 scope:server
// ❌ 错误
import { serverUtil } from '@myorg/server-utils';

// 配置：type:util 的项目禁止导入 lodash
// ❌ 错误
import _ from 'lodash';

项目 A → 项目 B → lodash（被禁用）❌

// 项目 A 的 package.json 没声明 lodash
// 但 A 依赖的 B 有 lodash
// ❌ 错误
import _ from 'lodash';

项目 A → 项目 B → lodash
    ↑         ↑
  直接依赖   传递依赖（对 A 来说）

// 项目 A 的代码
import _ from 'lodash';  // 能运行！但 A 的 package.json 没声明 lodash

// dep-a.ts
import { b } from './dep-b';  // A → B

// dep-b.ts
import { c } from './dep-c';  // B → C

// dep-c.ts
import { a } from './dep-a';  // C → A ❌ 形成循环 A → B → C → A

{
  "rules": {
    "import/no-cycle": [
      "error",
      {
        "maxDepth": 10,
        "ignoreTypes": false,
        "ignoreExternal": false,
        "allowUnsafeDynamicCyclicDependency": false
      }
    ]
  }
}