import { readFile } from "node:fs/promises";
import path from "node:path";
import { PermissionRegistryError } from "../authorization/index.js";
import {
  composePlatformPermissionRegistry,
  createModuleUiPublicationRegistry,
  discoverModuleSchemas,
  ModuleDiscoveryError,
  ModulePermissionCompositionError,
  ModuleSchemaDiscoveryError,
} from "../modules/index.js";

interface PackageVersion {
  version?: unknown;
}

async function readPackageVersion(packagePath: string): Promise<string> {
  const packageData = JSON.parse(await readFile(packagePath, "utf8")) as PackageVersion;
  if (typeof packageData.version !== "string") {
    throw new Error(`${packagePath} does not declare a version.`);
  }
  return packageData.version;
}

async function main(): Promise<void> {
  const repositoryRoot = process.cwd();
  const [platformVersion, moduleSdkVersion] = await Promise.all([
    readPackageVersion(path.join(repositoryRoot, "package.json")),
    readPackageVersion(path.join(repositoryRoot, "packages/module-sdk/package.json")),
  ]);
  const schemaAggregate = await discoverModuleSchemas({
    moduleSdkVersion,
    modulesDirectory: path.join(repositoryRoot, "modules"),
    platformVersion,
  });
  const modules = schemaAggregate.discoveredModules;

  // Reuses the modules discoverModuleSchemas already discovered — never rediscovers modules
  // solely for permission composition. A manifest that passes structural validation but claims
  // the reserved core.* namespace, or duplicates another declaration, fails validation here
  // before this module is considered installable.
  composePlatformPermissionRegistry(modules);

  if (modules.length === 0) {
    console.log("Module validation passed (0 modules installed).");
    return;
  }

  // Built from the same registry the API publishes from, so this command can never disagree with
  // what a running platform would actually serve. A contribution whose target capability nobody
  // provides — or whose provider moved outside its declared range — is otherwise silent: the
  // manifest is valid, the artifact exists, and nothing renders (ADR 0041).
  const publication = createModuleUiPublicationRegistry(modules);
  const compatibleContributions = new Set(
    publication
      .listContributions()
      .map((contribution) => `${contribution.moduleId}\u0000${contribution.contributionId}`),
  );

  console.log(
    `Module validation passed (${modules.length} modules, ${schemaAggregate.tables.length} tables):`,
  );
  for (const discoveredModule of modules) {
    console.log(`- ${discoveredModule.manifest.id}@${discoveredModule.manifest.version}`);
    for (const contribution of discoveredModule.contributions) {
      const resolved = compatibleContributions.has(
        `${discoveredModule.manifest.id}\u0000${contribution.id}`,
      );
      console.log(
        `  contributes ${contribution.id}@${contribution.version} to ${contribution.capability} ${contribution.capabilityRange} — ${
          resolved ? "compatible provider installed" : "no compatible provider installed"
        }`,
      );
    }
  }
}

main().catch((error: unknown) => {
  if (error instanceof ModuleDiscoveryError) {
    console.error(error.message);
    for (const issue of error.issues) {
      const issuePath = issue.path ? ` (${issue.path})` : "";
      console.error(`[${issue.code}] ${issue.moduleDirectory}${issuePath}: ${issue.message}`);
    }
  } else if (error instanceof ModuleSchemaDiscoveryError) {
    console.error(error.message);
    for (const issue of error.issues) {
      const issuePath = issue.path ? ` (${issue.path})` : "";
      console.error(`[${issue.code}] ${issue.moduleId}${issuePath}: ${issue.message}`);
    }
  } else if (error instanceof ModulePermissionCompositionError) {
    console.error(`[${error.code}] ${error.message}`);
  } else if (error instanceof PermissionRegistryError) {
    console.error(`[${error.code}] ${error.message}`);
  } else {
    console.error(error instanceof Error ? error.message : String(error));
  }
  process.exitCode = 1;
});