import { afterEach, test } from 'node:test';
import assert from 'node:assert/strict';
import { existsSync } from 'node:fs';
import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import {
  findCompatibilityDependency,
  scanImportBoundaries,
} from '../../scripts/lib/import-boundaries.mjs';

const roots = [];

afterEach(async () => {
  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
});

async function createFixtureRoot() {
  const root = await mkdtemp(join(tmpdir(), 'youle-import-boundaries-'));
  roots.push(root);
  return root;
}

async function writeFixture(root, relativePath, source) {
  const file = join(root, relativePath);
  await mkdir(dirname(file), { recursive: true });
  await writeFile(file, source, 'utf8');
}

function scan(root) {
  return scanImportBoundaries({
    frameworkDir: join(root, 'framework'),
    gamesDir: join(root, 'games'),
  });
}

const frameworkRoot = fileURLToPath(new URL('../../YouleNexus/assets/framework/', import.meta.url));
const modernRuntimeEntries = [
  'net/wire-client.ts',
  'platform/runtime-session.ts',
  'protocol/platform-handlers.ts',
  'protocol/router.ts',
  // Task 10 creates this entry; the same assertion starts covering it as soon as it exists.
  'platform/runtime.ts',
];
const legacyRuntimeFiles = new Set([
  'net/net-client.ts',
  'platform/session.ts',
  'platform/startup.ts',
  'platform/room-rpc-bus.ts',
  'platform/readonly.ts',
  'platform/stores/app-store.ts',
  'platform/stores/player-store.ts',
  'platform/stores/room-store.ts',
  'platform/stores/types.ts',
  'protocol/room-handlers.ts',
].map((file) => resolve(frameworkRoot, file)));

function scanCompatibilityFixture(root, entry = 'framework/protocol/router.ts', tsconfigPath) {
  return findCompatibilityDependency({
    entry: join(root, entry),
    forbiddenFiles: [join(root, 'framework/platform/session.ts')],
    traversalRoot: join(root, 'framework'),
    tsconfigPath: tsconfigPath ? join(root, tsconfigPath) : undefined,
  });
}

test('every existing modern runtime entry is transitively isolated from the legacy compatibility island', () => {
  const entries = modernRuntimeEntries
    .map((file) => resolve(frameworkRoot, file))
    .filter((file) => existsSync(file));
  assert.ok(entries.some((file) => file.endsWith(`${join('protocol', 'router.ts')}`)));

  for (const entry of entries) {
    const dependency = findCompatibilityDependency({
      entry,
      forbiddenFiles: [...legacyRuntimeFiles],
      traversalRoot: frameworkRoot,
      tsconfigPath: fileURLToPath(new URL('../../tsconfig.framework.json', import.meta.url)),
    });
    assert.equal(
      dependency,
      null,
      dependency?.path.map((file) => file.slice(frameworkRoot.length)).join(' -> '),
    );
  }
});

test('compatibility graph catches static imports, re-exports, and import types through barrels', async () => {
  const cases = [
    "import '../platform/session.ts'\n",
    "export * from '../platform/session.ts'\n",
    "export type { LegacySession } from '../platform/session.ts'\n",
    "type Legacy = import('../platform/session.ts').LegacySession\n",
  ];

  for (const source of cases) {
    const root = await createFixtureRoot();
    await writeFixture(root, 'framework/platform/session.ts', 'export interface LegacySession {}\n');
    await writeFixture(root, 'framework/protocol/barrel.ts', source);
    await writeFixture(root, 'framework/protocol/router.ts', "export * from './barrel.ts'\n");

    const found = scanCompatibilityFixture(root);
    assert.equal(found?.kind, 'forbidden', source);
    assert.deepEqual(
      found?.path.map((file) => file.replaceAll('\\', '/').split('/framework/')[1]),
      ['protocol/router.ts', 'protocol/barrel.ts', 'platform/session.ts'],
      source,
    );
  }
});

test('compatibility graph reports direct and ordinary transitive dependency paths', async () => {
  const directRoot = await createFixtureRoot();
  await writeFixture(directRoot, 'framework/platform/session.ts', 'export const legacy = true\n');
  await writeFixture(directRoot, 'framework/protocol/router.ts', "import '../platform/session.ts'\n");
  assert.equal(scanCompatibilityFixture(directRoot)?.path.length, 2);

  const transitiveRoot = await createFixtureRoot();
  await writeFixture(transitiveRoot, 'framework/platform/session.ts', 'export const legacy = true\n');
  await writeFixture(transitiveRoot, 'framework/protocol/helper.ts', "import '../platform/session.ts'\n");
  await writeFixture(transitiveRoot, 'framework/protocol/router.ts', "import './helper.ts'\n");
  assert.equal(scanCompatibilityFixture(transitiveRoot)?.path.length, 3);
});

test('compatibility graph catches string and no-substitution-template dynamic imports', async () => {
  for (const source of [
    "await import('../platform/session.ts')\n",
    'await import(`../platform/session.ts`)\n',
  ]) {
    const root = await createFixtureRoot();
    await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
    await writeFixture(root, 'framework/protocol/router.ts', source);

    assert.equal(scanCompatibilityFixture(root)?.kind, 'forbidden', source);
  }
});

test('compatibility graph resolves tsconfig path aliases to canonical files', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
  await writeFixture(root, 'framework/protocol/router.ts', "import '@legacy/session'\n");
  await writeFixture(root, 'tsconfig.json', JSON.stringify({
    compilerOptions: {
      baseUrl: '.',
      paths: { '@legacy/*': ['framework/platform/*'] },
      module: 'ESNext',
      moduleResolution: 'Bundler',
      allowImportingTsExtensions: true,
    },
  }));

  const found = scanCompatibilityFixture(root, undefined, 'tsconfig.json');
  assert.equal(found?.kind, 'forbidden');
  assert.ok(found?.path.at(-1)?.replaceAll('\\', '/').endsWith('/framework/platform/session.ts'));
});

test('compatibility graph fails closed on a reachable non-static dynamic import', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
  await writeFixture(
    root,
    'framework/protocol/router.ts',
    "const target = '../platform/session.ts'; void import(target)\n",
  );

  const found = scanCompatibilityFixture(root);
  assert.equal(found?.kind, 'dynamic');
  assert.ok(found?.path[0]?.replaceAll('\\', '/').endsWith('/framework/protocol/router.ts'));
});

test('compatibility graph applies the same isolation to a future platform/runtime.ts entry', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
  await writeFixture(root, 'framework/application/barrel.ts', "export * from '../platform/session.ts'\n");
  await writeFixture(root, 'framework/platform/runtime.ts', "import '../application/barrel.ts'\n");

  const found = scanCompatibilityFixture(root, 'framework/platform/runtime.ts');
  assert.equal(found?.kind, 'forbidden');
  assert.equal(found?.path.length, 3);
});

test('scanner rejects sdk contracts importing a framework platform path', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/bad.ts', "import '../platform/session.ts'\n");
  assert.match(scan(root)[0].message, /sdk.*platform/);
});

test('scanner rejects game imports of framework net internals', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/bad.ts', "import '../../../framework/net/net-client.ts'\n");
  assert.match(scan(root)[0].message, /game.*framework\/net/);
});

test('scanner rejects multiline game imports of framework net internals', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/bad.ts', "import {\n  NetClient,\n} from '../../../../framework/net/net-client.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /game.*framework\/net/);
});

test('scanner rejects multiline sdk contract imports outside their sibling directory', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/bad.ts', "import {\n  PlatformSession,\n} from '../../platform/session.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /sdk\/contracts.*sibling contracts/);
});

test('scanner permits a game import of the public sdk barrel', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/allowed.ts', "import '../../../../framework/sdk/index.ts'\n");
  assert.deepEqual(scan(root), []);
});

test('scanner rejects games importing migration-only sdk declarations', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/bad.ts', "import type { GameContext } from '../../../../framework/sdk/index.ts'\n");
  assert.match(scan(root)[0].message, /game.*GameContext.*migration-only/);
});

test('scanner rejects cc imports in sdk contracts', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/bad.ts', "import { Node } from 'cc'\n");
  assert.match(scan(root)[0].message, /sdk\/contracts.*cc/);
});

test('scanner rejects non-relative imports in sdk contracts', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/bad.ts', "import 'node:fs'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /sdk\/contracts.*non-relative/);
});

test('scanner rejects import-type leaks from sdk contracts', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/bad.ts', "type ReadonlyRoom = import('../../platform/readonly.ts').ReadonlyRoomStore\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /sdk\/contracts.*sibling contracts/);
});

test('scanner rejects export-star leaks from sdk contracts', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/index.ts', "export * from '../../platform/readonly.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /sdk\/contracts.*sibling contracts/);
});

test('scanner rejects named re-export leaks from sdk contracts', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/sdk/contracts/index.ts', "export { ReadonlyRoomStore } from '../../platform/readonly.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /sdk\/contracts.*sibling contracts/);
});

test('scanner permits cc imports in game code', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/allowed.ts', "import { Node } from 'cc'\n");
  assert.deepEqual(scan(root), []);
});

test('scanner rejects framework imports resolving under games', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/ui/bad.ts', "import '../../games/a/assets/game/entry.ts'\n");
  assert.match(scan(root)[0].message, /framework.*games/);
});

test('scanner rejects framework production imports of migration-only sdk declarations', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/application/bad.ts', "import type { GameContext } from '../sdk/index.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /GameContext.*migration-only/);
});

test('scanner rejects alias imports of migration-only sdk declarations', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/application/bad.ts', "import type { IGameModule } from '@internal/sdk'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /IGameModule.*migration-only/);
});

test('scanner rejects new production imports of a quarantined legacy runtime', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'framework/application/bad.ts', "import '../net/net-client.ts'\n");
  const violations = scan(root);
  assert.equal(violations.length, 1);
  assert.match(violations[0].message, /new production code.*legacy runtime/);
});

test('scanner rejects string-literal dynamic imports that cross a boundary', async () => {
  const root = await createFixtureRoot();
  await writeFixture(root, 'games/a/assets/game/bad.ts', "await import('../../../framework/net/net-client.ts')\n");
  assert.match(scan(root)[0].message, /game.*framework\/net/);
});