const LIST_MARKER = /^[\-*][ \t]+/v;
const RUN_OF_AUDIT_IDS = /^(?:\[[0-9a-f]{7,}\][ \t]*)+/iv;
const RUN_OF_WHITESPACE = /\s+/gv;
const LINE_BREAK = /\r?\n/v;
const DEPENDENCY_BUMP_LINE = '- Updated dependencies.\n';
const WORKSPACE_ROOTS = new Set(['packages', 'sites', 'tools', 'apps']);
const MAX_FILE_EXTENSION_LENGTH = 5;
const PUNCTUATION_AROUND_TOKEN = /[\(\),:;]/gv;
const FILE_EXTENSION = /^[a-z0-9]+$/iv;

// A bare `name.ext` stays: `Node.js` and `index.html` read as prose more often
// than as a file, and dropping the bullet would delete release notes silently.
// Requiring a slash also removes the need for an extension list to maintain.
function isFilePath(token) {
  if (token.includes('://')) {
    return false;
  }

  const withoutPunctuation = token.replaceAll(PUNCTUATION_AROUND_TOKEN, '');
  if (!withoutPunctuation.includes('/')) {
    return false;
  }
  if (WORKSPACE_ROOTS.has(withoutPunctuation.split('/')[0])) {
    return true;
  }

  const lastSegment = withoutPunctuation.split('/').at(-1) ?? '';
  if (!lastSegment.includes('.')) {
    return false;
  }

  const extension = lastSegment.split('.').at(-1) ?? '';
  return (
    extension.length > 0 &&
    extension.length <= MAX_FILE_EXTENSION_LENGTH &&
    FILE_EXTENSION.test(extension)
  );
}

function containsFilePath(text) {
  return text.split(' ').some((token) => isFilePath(token));
}

function normaliseKeepingTypeScopePrefix(line) {
  const withoutMarkers = String(line ?? '')
    .trim()
    .replace(LIST_MARKER, '')
    .replace(RUN_OF_AUDIT_IDS, '')
    .replaceAll('`', '')
    .replaceAll(RUN_OF_WHITESPACE, ' ')
    .trim();

  // A bullet naming a file path is an implementation note, not a release note.
  return containsFilePath(withoutMarkers) ? '' : withoutMarkers;
}

/**
 * @param {{summary?: string}} changeset - The changeset being released.
 * @returns {Promise<string>} Flat bullets, or an empty string.
 */
export async function getReleaseLine(changeset) {
  if (typeof changeset?.summary !== 'string') {
    throw new TypeError(
      `changelog-formatter: changeset.summary must be a string, got ${typeof changeset?.summary}`,
    );
  }

  const publishable = changeset.summary
    .split(LINE_BREAK)
    .map((line) => normaliseKeepingTypeScopePrefix(line))
    .filter(Boolean);

  if (publishable.length === 0) return '';
  return `${publishable.map((bullet) => `- ${bullet}`).join('\n')}\n`;
}

/**
 * @param {unknown} _changesets - Unused; kept for the changesets call signature.
 * @param {unknown[]} dependenciesUpdated - The updated dependencies.
 * @returns {Promise<string>} One collapsed bullet, or an empty string.
 */
export async function getDependencyReleaseLine(
  _changesets,
  dependenciesUpdated,
) {
  if (!Array.isArray(dependenciesUpdated)) {
    throw new TypeError(
      `changelog-formatter: dependenciesUpdated must be an array, got ${typeof dependenciesUpdated}`,
    );
  }
  return dependenciesUpdated.length === 0 ? '' : DEPENDENCY_BUMP_LINE;
}

{
  "$schema": "https://unpkg.com/@changesets/config@3.1.2/schema.json",
  "commit": false,
  "fixed": [],
  "linked": [],
  "access": "restricted",
  "baseBranch": "main",
  "updateInternalDependencies": "patch",
  "ignore": []
}

import { execFileSync } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';

const SCRIPT_FOLDER = path.dirname(fileURLToPath(import.meta.url));
const TAXONOMY_FILE = 'changelog-taxonomy.mjs';

let taxonomy;

let GROUP_HEADINGS_ALREADY_WRITTEN;

const VERSION_HEADING = /^##[ \t]+\S/v;
const SEVERITY_HEADING = /^###[ \t]+(.*)$/v;
const GROUP_HEADING_LINE = /^####[ \t]+(.*)$/v;
const BULLET = /^-[ \t]+(.*)$/v;
const TYPE_SCOPE_PREFIXED_BULLET =
  /^(?:\*\*)?([a-zA-Z]+)(?:\(([^\)]*)\))?(?:\*\*)?!?:[ \t]*(.*)$/v;
const TRAILING_BLANK_LINES = /\n{3,}$/v;
function abort(message) {
  throw new Error(message);
}

function resolveCompanionFile(fileName, explicitPath, flagName) {
  if (explicitPath) {
    if (!fs.existsSync(explicitPath)) {
      abort(
        `${flagName} points at a file that does not exist: ${explicitPath}`,
      );
    }
    return path.resolve(explicitPath);
  }

  const besideThisScript = path.join(SCRIPT_FOLDER, fileName);
  if (fs.existsSync(besideThisScript)) return besideThisScript;

  const skillsFolder = path.dirname(SCRIPT_FOLDER);
  const inSiblingSkills = (
    fs.existsSync(skillsFolder)
      ? fs
          .readdirSync(skillsFolder, { withFileTypes: true })
          .filter((entry) => entry.isDirectory())
          .map((entry) => path.join(skillsFolder, entry.name, fileName))
      : []
  )
    .filter((candidate) => fs.existsSync(candidate))
    .toSorted();

  if (inSiblingSkills.length > 0) return inSiblingSkills[0];

  abort(
    `cannot find ${fileName}: looked beside this script and in every sibling skill folder under ${skillsFolder}. Copy it next to this script, or pass ${flagName} <path>.`,
  );
}

function changelogsModifiedSinceHead() {
  return execFileSync('git', ['diff', '--name-only', '--', '*CHANGELOG.md'], {
    encoding: 'utf8',
  })
    .split('\n')
    .map((line) => line.trim())
    .filter((line) => line !== '');
}

function boundsOfNewestVersionSection(lines) {
  const start = lines.findIndex((line) => VERSION_HEADING.test(line));
  if (start === -1) return null;
  const offsetOfNextVersion = lines
    .slice(start + 1)
    .findIndex((line) => VERSION_HEADING.test(line));
  return {
    end:
      offsetOfNextVersion === -1
        ? lines.length
        : start + 1 + offsetOfNextVersion,
    start,
  };
}

function readGroupScopeAndText(bulletText) {
  const prefixed = TYPE_SCOPE_PREFIXED_BULLET.exec(bulletText);
  if (!prefixed) {
    return {
      group: taxonomy.UNRECOGNISED_TYPE_GROUP,
      scope: null,
      text: bulletText,
    };
  }
  const [, rawType, scope = null, textAfterPrefix] = prefixed;
  const type = rawType.toLowerCase();
  const group = taxonomy.GROUP_OF_CONVENTIONAL_TYPE[type];
  if (group === undefined) {
    return {
      group: taxonomy.UNRECOGNISED_TYPE_GROUP,
      scope: null,
      text: bulletText,
    };
  }
  return { group, scope: scope || null, text: textAfterPrefix.trim(), type };
}

function splitIntoSeverityBlocks(sectionBody) {
  const blocks = [];
  let openBlock = { bullets: [], heading: null, prose: [] };
  blocks.push(openBlock);

  for (const line of sectionBody) {
    if (GROUP_HEADING_LINE.test(line)) continue;
    if (SEVERITY_HEADING.test(line)) {
      openBlock = { bullets: [], heading: line, prose: [] };
      blocks.push(openBlock);
      continue;
    }
    const bullet = BULLET.exec(line);
    if (bullet) {
      openBlock.bullets.push(readGroupScopeAndText(bullet[1].trim()));
      continue;
    }
    if (line.trim() !== '') openBlock.prose.push(line);
  }

  return blocks.filter(
    (block) =>
      block.heading !== null ||
      block.bullets.length > 0 ||
      block.prose.length > 0,
  );
}

function renderBlockGroupedByType(bullets, leadWithScope) {
  const asLine = (bullet) =>
    leadWithScope && bullet.scope
      ? `- **${bullet.scope}:** ${bullet.text}`
      : `- ${bullet.text}`;

  const groupsPresent = taxonomy.READER_GROUPS_IN_ORDER.filter((group) =>
    bullets.some((bullet) => bullet.group === group),
  );
  if (groupsPresent.length <= 1) return bullets.map((bullet) => asLine(bullet));

  const lines = [];
  for (const group of groupsPresent) {
    lines.push(
      `#### ${taxonomy.GROUP_HEADING[group]}`,
      '',
      ...bullets
        .filter((bullet) => bullet.group === group)
        .map((bullet) => asLine(bullet)),
      '',
    );
  }
  return lines;
}

function regroupNewestSection(file, leadWithScope) {
  const lines = fs.readFileSync(file, 'utf8').split('\n');
  const section = boundsOfNewestVersionSection(lines);
  if (!section) abort(`${file}: no version heading found`);

  const sectionBody = lines.slice(section.start + 1, section.end);
  const alreadyRegrouped = sectionBody.some((line) =>
    GROUP_HEADINGS_ALREADY_WRITTEN.has(
      GROUP_HEADING_LINE.exec(line)?.[1]?.trim(),
    ),
  );
  if (alreadyRegrouped) return { file, skipped: 'already regrouped' };

  const blocks = splitIntoSeverityBlocks(sectionBody);
  const bulletsMoved = blocks.reduce(
    (total, block) => total + block.bullets.length,
    0,
  );
  if (bulletsMoved === 0) {
    return { bullets: 0, file, skipped: 'no bullets in newest section' };
  }

  const rebuiltSection = [lines[section.start], ''];
  for (const block of blocks) {
    if (block.heading) rebuiltSection.push(block.heading, '');
    if (block.prose.length > 0) rebuiltSection.push(...block.prose, '');
    if (block.bullets.length === 0) continue;
    rebuiltSection.push(
      ...renderBlockGroupedByType(block.bullets, leadWithScope),
    );
    if (rebuiltSection.at(-1) !== '') rebuiltSection.push('');
  }

  fs.writeFileSync(
    file,
    [
      ...lines.slice(0, section.start),
      ...rebuiltSection,
      ...lines.slice(section.end),
    ]
      .join('\n')
      .replace(TRAILING_BLANK_LINES, '\n'),
    'utf8',
  );
  return { bullets: bulletsMoved, file };
}

async function main() {
  const argv = process.argv.slice(2);
  const taxonomyFlag = argv.indexOf('--taxonomy');
  const explicitFiles =
    taxonomyFlag === -1
      ? argv
      : [...argv.slice(0, taxonomyFlag), ...argv.slice(taxonomyFlag + 2)];

  taxonomy = await import(
    pathToFileURL(
      resolveCompanionFile(
        TAXONOMY_FILE,
        taxonomyFlag === -1 ? undefined : argv[taxonomyFlag + 1],
        '--taxonomy',
      ),
    ).href
  );
  GROUP_HEADINGS_ALREADY_WRITTEN = new Set(
    Object.values(taxonomy.GROUP_HEADING),
  );
  const targets =
    explicitFiles.length > 0 ? explicitFiles : changelogsModifiedSinceHead();
  if (targets.length === 0) abort('no modified CHANGELOG.md files');

  const leadWithScope = !taxonomy.repositoryDeclaresWorkspaceMembers();
  const results = targets.map((file) =>
    regroupNewestSection(file, leadWithScope),
  );

  process.stdout.write(
    `${JSON.stringify(
      { grouping: 'type', results, scopeShown: leadWithScope },
      undefined,
      2,
    )}\n`,
  );
}

try {
  await main();
} catch (error) {
  process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
  process.exitCode = 1;
}