/*
 * The comparison behind lint:format (scripts/format-lint.mjs): which files
 * Prettier would rewrite, against the list of files that were unformatted
 * when the check came in.
 */
import { join } from 'node:path';
import * as prettier from 'prettier';
import {
  fileList,
  listFiles,
  lowerList,
  RatchetError,
  readBaseline,
  readText,
  toKey,
  writeBaseline,
} from './ratchet.mjs';

export const DIRS = ['src', 'tests'];

export const accepts = (key) => /\.(?:tsx?|css)$/.test(key);

/**
 * Whether Prettier leaves the file as it is, with the config that applies to
 * it. The text is read with LF line ends, so a Windows checkout agrees with CI
 * about endOfLine. A file Prettier cannot parse is not formatted.
 */
export async function isFormatted(path) {
  const options = await prettier.resolveConfig(path);
  if (!options) throw new RatchetError(`no Prettier config applies to ${path}`);
  try {
    return await prettier.check(readText(path), { ...options, filepath: path });
  } catch {
    return false;
  }
}

/** The files under root that Prettier would rewrite, keyed by their path from root. */
export async function unformatted(root) {
  const found = [];
  for (const path of listFiles(root, DIRS, accepts)) if (!(await isFormatted(path))) found.push(toKey(root, path));
  return found;
}

/**
 * Runs the check against the list at baselinePath. A file outside the list
 * must be formatted. A listed file that is formatted now, or gone, fails the
 * check as well until --update takes it out: the list only shrinks, and a
 * stale entry would let the next file at that path in unformatted. Returns
 * the exit code.
 */
export async function check({
  root,
  baselinePath = join(root, 'scripts/format-baseline.json'),
  update = false,
  list = false,
  log = console.log,
  error = console.error,
}) {
  const found = await unformatted(root);
  let baseline = readBaseline(baselinePath, fileList);

  if (update) {
    baseline = lowerList(baseline, found);
    writeBaseline(baselinePath, baseline);
  }

  const allowed = new Set(baseline);
  const fresh = found.filter((key) => !allowed.has(key));
  const now = new Set(found);
  const stale = baseline.filter((key) => !now.has(key));

  if (list) for (const key of found) log(`${allowed.has(key) ? 'listed' : 'new   '}  ${key}`);
  for (const key of fresh) {
    error(`FAIL  ${key} is not formatted. Run: npx prettier --write ${key}`);
  }
  for (const key of stale) {
    error(`FAIL  ${key} is listed in scripts/format-baseline.json but is formatted now or gone.`);
  }
  if (stale.length) error('Run npm run lint:format -- --update to take the formatted files off the list.');
  log(`format: ${found.length} unformatted file(s), ${baseline.length} listed in the baseline`);
  return fresh.length || stale.length ? 1 : 0;
}