/**
 * Codemod value-preserving del vocabulario de tokens (D-TH.6, acta 2026-08-20).
 *
 *   node --import tsx/esm scripts/__names-codemod.ts --dry    # sólo mide
 *   node --import tsx/esm scripts/__names-codemod.ts --write  # escribe
 *
 * Renombra la CLAVE en `recipes/base.ts` y TODAS sus referencias
 * `var(--{c}-{clave})` en el árbol indexado por git. No toca valores: un
 * rename no cambia lo que se ve ni cuánto alcanza el tema.
 *
 * Molde: la normalización px/py del 2026-07-06 (recipe-contract §1) y su
 * triple muro. Aquí los muros son: colisión de destino · clave duplicada en
 * `base.ts` (añadir un bloque que ya existe lo descarta EN SILENCIO) · el
 * diff de `generated/` como renombres 1:1.
 *
 * Corre con `tsx`, no con el `node` pelado del centinela, porque importa
 * `theming-census`, que a su vez importa `../src/uix/morfo/compile` SIN extensión
 * — y todo `src/uix/morfo` está escrito así. El type stripping de Node no resuelve
 * un import extensionless; alinear la vía de carga es un barrido de `src/`, no de
 * este fichero.
 *
 * Lo que NO reescribe, y por qué:
 *   docs/process/**            — actas, planes y handoffs: son HISTORIA
 *   docs/theming/changelog.md  — crónica fechada
 * Reescribir un registro histórico lo convierte en una mentira retroactiva.
 */

import { readFileSync, writeFileSync } from 'node:fs';
import { execSync } from 'node:child_process';
import { resolve } from 'node:path';

import { names, type NameFinding } from './theming-census';

const BASE = resolve('src/uix/eidos/lib/recipes/base.ts');
const HISTORY = /^(docs\/process\/|docs\/theming\/changelog\.md$)/;

const read = (p: string) => readFileSync(p, 'utf8').replace(/\r\n/g, '\n');

/**
 * Los bloques de primer nivel. Casi todos abren `nombre: {`, pero `avatar` envuelve
 * su mapa en una IIFE (`nombre: ((): RecipeTokenMap => {`) y sus claves viven un
 * tabulador más adentro, dentro del `return {` del cierre — la misma lectura que
 * `theming-sentinel.ts`. Exigir `: {` dejaba a `avatar` fuera de la lista: sin
 * bloque para el muro de colisiones, engullido por el rango de su vecino anterior
 * para el de duplicadas, e intocable para el pase A.
 *
 * `at`/`end` acotan la REGIÓN DE CLAVES y `depth` dice a cuántos tabuladores están.
 * Son offsets REALES del fichero — dedentar el bloque para reusar el regex de dos
 * tabuladores rompería el mapeo con el que el pase A edita por rango.
 */
type Block = { name: string; at: number; end: number; depth: number };

function blocks(src: string): Block[] {
	const opens = [...src.matchAll(/^\t'?([a-z0-9-]+)'?: (\{|\(\()/gm)];
	return opens.map((m, i) => {
		const at = m.index!;
		const end = i + 1 < opens.length ? opens[i + 1].index! : src.length;
		if (m[2] === '{') return { name: m[1], at, end, depth: 2 };
		const body = src.indexOf('\n\t\treturn {', at);
		const close = src.indexOf('\n\t\t};', body);
		if (body < 0 || body > end || close < 0 || close > end)
			throw new Error(`${m[1]}: IIFE sin un \`return {\` legible`);
		return { name: m[1], at: body, end: close, depth: 3 };
	});
}

/** Las claves de un bloque, al nivel de indentación que ese bloque use. */
const keyRe = (depth: number) => new RegExp(`^\\t{${depth}}'?(_?[a-z0-9-]+)'?\\s*:`, 'gm');

/** Claves de primer nivel duplicadas dentro de un mismo bloque de receta. */
function duplicateKeys(src: string): string[] {
	const dupes: string[] = [];
	for (const b of blocks(src)) {
		const seen = new Set<string>();
		for (const k of src.slice(b.at, b.end).matchAll(keyRe(b.depth))) {
			if (seen.has(k[1])) dupes.push(b.name + '.' + k[1]);
			seen.add(k[1]);
		}
	}
	return dupes;
}

function blockRange(src: string, component: string): Block | null {
	return blocks(src).find((b) => b.name === component) ?? null;
}

async function run() {
	const write = process.argv.includes('--write');
	const findings = await names();
	const renames = findings.filter(
		(f) => (f.klass === 'ink' || f.klass === 'modifier' || f.klass === 'both') && f.to
	);

	// ── Muro 1: colisiones ────────────────────────────────────────────────────
	const base0 = read(BASE);
	const collisions: string[] = [];
	const byComponent = new Map<string, NameFinding[]>();
	for (const f of renames) byComponent.set(f.component, [...(byComponent.get(f.component) ?? []), f]);
	for (const [component, fs] of byComponent) {
		const range = blockRange(base0, component);
		if (!range) {
			collisions.push(`${component}: SIN BLOQUE`);
			continue;
		}
		const existing = new Set(
			[...base0.slice(range.at, range.end).matchAll(keyRe(range.depth))].map((m) => m[1])
		);
		const targets = new Set<string>();
		for (const f of fs) {
			if (existing.has(f.to!) && f.to !== f.key) collisions.push(`${component}.${f.to} YA EXISTE`);
			if (targets.has(f.to!)) collisions.push(`${component}.${f.to} destino DUPLICADO`);
			targets.add(f.to!);
		}
	}

	// ── Muro 2: claves duplicadas ANTES ───────────────────────────────────────
	const dupesBefore = duplicateKeys(base0);

	// El PLAN se escribe antes de tocar nada: es lo único que sobrevive al
	// renombrado, y sin él el verificador del diff no tiene contra qué medir
	// (el clasificador, releído después, ya no ve desviación alguna).
	const planPath = resolve('scripts/__names-plan.json');
	if (write)
		writeFileSync(
			planPath,
			JSON.stringify(
				renames.map((f) => ({ component: f.component, from: f.key, to: f.to })),
				null,
				'\t'
			) + '\n',
			'utf8'
		);

	console.log(`renombres: ${renames.length} en ${byComponent.size} componentes`);
	console.log(`muro 1 · colisiones: ${collisions.length ? collisions.join(' | ') : 'ninguna'}`);
	console.log(`muro 2 · duplicadas ANTES: ${dupesBefore.length ? dupesBefore.join(' | ') : 'ninguna'}`);
	if (collisions.length || dupesBefore.length) {
		console.error('\nABORTA: un muro está en rojo.');
		process.exit(1);
	}

	// ── Pase A: la CLAVE en base.ts, acotado a su bloque ──────────────────────
	let base = base0;
	let keyHits = 0;
	for (const [component, fs] of byComponent) {
		const range = blockRange(base, component);
		if (!range) continue;
		let block = base.slice(range.at, range.end);
		// más largas primero: una clave puede ser prefijo de otra
		for (const f of [...fs].sort((a, b) => b.key.length - a.key.length)) {
			const re = new RegExp(`^(\\t{${range.depth}})'?` + f.key + "'?(\\s*:)", 'm');
			if (!re.test(block)) continue;
			const quoted = /-/.test(f.to!) ? `'${f.to}'` : f.to!;
			block = block.replace(re, `$1${quoted}$2`);
			keyHits++;
		}
		base = base.slice(0, range.at) + block + base.slice(range.end);
	}
	console.log(`pase A · claves reescritas en base.ts: ${keyHits} / ${renames.length}`);

	// ── Pase B: las REFERENCIAS `--{c}-{clave}` en el árbol indexado ──────────
	const files = execSync('git ls-files "*.ts" "*.css" "*.svelte" "*.md"', {
		encoding: 'utf8',
		maxBuffer: 1 << 28
	})
		.split('\n')
		.filter(Boolean)
		.filter((f) => !HISTORY.test(f));

	// Más largas primero y con frontera: `--waveform-color` no puede comerse
	// `--waveform-color-played`.
	const refs = [...renames].sort((a, b) => b.key.length - a.key.length);
	let refHits = 0;
	const touched: string[] = [];
	for (const file of files) {
		const before = file === 'src/uix/eidos/lib/recipes/base.ts' ? base : read(file);
		let after = before;
		for (const f of refs) {
			const from = `--${f.component}-${f.key}`;
			const re = new RegExp(from.replace(/-/g, '\\-') + '(?![a-zA-Z0-9-])', 'g');
			const n = (after.match(re) ?? []).length;
			if (!n) continue;
			after = after.replace(re, `--${f.component}-${f.to}`);
			refHits += n;
		}
		if (after === before) continue;
		touched.push(file);
		if (write) writeFileSync(file, after, 'utf8');
	}
	if (write && !touched.includes('src/uix/eidos/lib/recipes/base.ts'))
		writeFileSync(BASE, base, 'utf8');
	console.log(`pase B · referencias reescritas: ${refHits} en ${touched.length} ficheros`);

	// ── Muro 3: claves duplicadas DESPUÉS ─────────────────────────────────────
	const dupesAfter = duplicateKeys(base);
	console.log(`muro 3 · duplicadas DESPUÉS: ${dupesAfter.length ? dupesAfter.join(' | ') : 'ninguna'}`);
	if (dupesAfter.length) {
		console.error('\nABORTA: el renombrado creó una clave duplicada.');
		process.exit(1);
	}

	if (!write) console.log('\n(--dry: no se ha escrito nada)');
}

void run();