const { releaseChangelog, releasePublish, releaseVersion } = require('nx/release');
const { execSync } = require('child_process');
const path = require('path');
const fs = require('fs');
const yargs = require('yargs');

(async () => {
  const options = await yargs
    .version(false)
    .option('version', {
      description:
        'Explicit version specifier to use, overriding conventional commits if provided.',
      type: 'string',
    })
    .option('preid', {
      description:
        'Specify the prerelease identifier (e.g., beta, alpha, rc) to append to the version when creating a prerelease.',
      type: 'string',
    })
    .option('dryRun', {
      alias: 'd',
      description: 'Run the release process in dry-run mode, defaults to true.',
      type: 'boolean',
      default: true,
    })
    .option('verbose', {
      description: 'Enable verbose logging for debugging, defaults to false.',
      type: 'boolean',
      default: false,
    })
    .option('publish', {
      description: 'Control whether the packages should be published, defaults to true.',
      type: 'boolean',
      default: true,
    })
    .option('changelog', {
      description:
        'Control whether a GitHub release and changelog should be generated, defaults to true.',
      type: 'boolean',
      default: true,
    })
    .options('onlyPublish', {
      description: 'Publish packages without performing other release steps.',
      type: 'boolean',
      default: false,
    })
    .option('tag', {
      description: 'Specify a custom tag for the release.',
      type: 'string',
    })
    .option('opt', {
      description: 'npm one time password',
      type: 'string',
    })
    .option('gitCommit', {
      description: 'Control whether to commit or not. (default to true)',
      type: 'boolean',
      default: true,
    })
    .option('gitTag', {
      description: 'Control whether to add git tag or not. (default to true)',
      type: 'boolean',
      default: true,
    })
    .parseAsync();

  let workspaceVersion, projectsVersionData;

  if (!options.onlyPublish) {
    const versionResult = await releaseVersion({
      specifier: options.version,
      dryRun: options.dryRun,
      verbose: options.verbose,
      gitCommit: options.gitCommit,
      preid: options.preid,
      gitCommitArgs: '--no-verify',
    });
    workspaceVersion = versionResult.workspaceVersion;
    projectsVersionData = versionResult.projectsVersionData;

    /**
     * Nx's releaseVersion updates `dependencies`, `devDependencies`, and `optionalDependencies`
     * but intentionally skips `peerDependencies` (see: https://github.com/nrwl/nx/issues/22776).
     *
     * For experimental/nightly releases (e.g. 0.0.0-experimental.<sha>), peer dep ranges like
     * `^5.0.0` cannot satisfy `0.0.0-experimental.*` — semver prerelease matching is tuple-locked,
     * so no range notation can express "any 5.x stable OR any 0.0.0-experimental.*".
     *
     * We fix this by rewriting internal @strapi/* peerDependencies to the exact experimental
     * version after Nx versioning completes, but before the build step.
     */
    if (options.version !== undefined && /^0\.0\.0-.+/.test(options.version)) {
      rewriteInternalPeerDependencies(options.version, options.dryRun);
    }
  }

  // Run clean and build
  execSync('./node_modules/.bin/nx run-many --target=clean --nx-ignore-cycles', {
    stdio: 'inherit',
  });
  execSync('./node_modules/.bin/nx run-many --target=build --nx-ignore-cycles --skip-nx-cache', {
    stdio: 'inherit',
  });

  let publishResults;
  if (options.publish) {
    publishResults = await releasePublish({
      dryRun: options.dryRun,
      verbose: options.verbose,
      tag: options.tag,
      otp: options.otp,
    });
  }

  if (options.changelog && !options.onlyPublish) {
    await releaseChangelog({
      versionData: projectsVersionData,
      version: workspaceVersion,
      dryRun: options.dryRun,
      verbose: options.verbose,
      gitCommit: false,
      gitTag: options.gitTag,
    });
  }

  // Exit with code 0 if all publish results are successful, else 1
  if (publishResults) {
    const exitCode = Object.values(publishResults).every((result) => result.code === 0) ? 0 : 1;
    process.exit(exitCode);
  } else {
    process.exit();
  }
})();

/**
 * Rewrites internal @strapi/* peerDependencies across all workspace packages to an exact version.
 *
 * Why: Nx release does not update peerDependencies (by design). For prerelease versions like
 * `0.0.0-experimental.<sha>`, ranges such as `^5.0.0` can never match due to semver's
 * tuple-locked prerelease matching rules. This causes npm ERESOLVE failures at install time.
 *
 * When: Only called for versions matching `0.0.0-*` (experimental, nightly).
 * Where: After releaseVersion() bumps all `version` fields, before the build/publish steps.
 */
function rewriteInternalPeerDependencies(version, dryRun) {
  const rootDir = path.resolve(__dirname, '..');
  const rootPkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
  const workspacePatterns = rootPkg.workspaces || [];

  // Only process packages/ — examples/, .github/, scripts/ are not published to npm
  const publishablePatterns = workspacePatterns.filter((p) => p.startsWith('packages/'));

  // Collect all publishable package.json paths
  const packageJsonPaths = [];
  for (const pattern of publishablePatterns) {
    // pattern is a simple glob like "packages/*" or "packages/*/*"
    // Resolve it by listing matching directories
    const parts = pattern.split('/');
    const resolved = resolveGlobDirs(rootDir, parts);
    for (const dir of resolved) {
      const candidate = path.join(dir, 'package.json');
      if (fs.existsSync(candidate)) {
        packageJsonPaths.push(candidate);
      }
    }
  }

  // First pass: collect all @strapi/* package names in the workspace
  const workspacePackageNames = new Set();
  for (const pkgPath of packageJsonPaths) {
    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
    if (pkg.name !== undefined && pkg.name.startsWith('@strapi/')) {
      workspacePackageNames.add(pkg.name);
    }
  }

  // Second pass: rewrite peerDependencies
  let updatedCount = 0;
  for (const pkgPath of packageJsonPaths) {
    const raw = fs.readFileSync(pkgPath, 'utf8');
    const pkg = JSON.parse(raw);

    if (pkg.peerDependencies === undefined) {
      continue;
    }

    let changed = false;
    for (const dep of Object.keys(pkg.peerDependencies)) {
      if (workspacePackageNames.has(dep)) {
        pkg.peerDependencies[dep] = version;
        changed = true;
      }
    }

    if (changed === true) {
      if (dryRun === true) {
        console.log(
          `[dry-run] Would rewrite peerDependencies in ${path.relative(rootDir, pkgPath)}`
        );
      } else {
        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
        console.log(`Rewrote peerDependencies in ${path.relative(rootDir, pkgPath)}`);
      }
      updatedCount++;
    }
  }

  console.log(
    `${dryRun === true ? '[dry-run] ' : ''}Rewrote @strapi/* peerDependencies to "${version}" in ${updatedCount} packages`
  );
}

/**
 * Resolves a simple workspace glob pattern (e.g. ["packages", "*", "*"]) into actual directories.
 */
function resolveGlobDirs(base, parts) {
  if (parts.length === 0) {
    return [base];
  }

  const [current, ...rest] = parts;

  if (current === '*') {
    if (fs.existsSync(base) === false) {
      return [];
    }
    const entries = fs.readdirSync(base, { withFileTypes: true });
    const dirs = entries.filter((e) => e.isDirectory()).map((e) => path.join(base, e.name));
    return dirs.flatMap((dir) => resolveGlobDirs(dir, rest));
  }

  return resolveGlobDirs(path.join(base, current), rest);
}