/**
 * One owner for "which file extensions hold UI markup".
 *
 * Before this module the answer was spelled out separately in hook-lib.mjs
 * (`detector.extensions` config, issue #316) and in live-wrap.mjs /
 * live-accept.mjs (a hardcoded `EXTENSIONS` array, duplicated verbatim in both).
 * The lists drifted: the hook learned configurable server-template extensions
 * while Live kept its six frontend defaults, so a Phoenix project got design
 * findings on `.heex` files but `Session markers not found` on Accept (#374).
 *
 * Extensions are matched against the END OF THE FILENAME, not `path.extname`,
 * so double extensions like `.blade.php`, `.html.erb`, and `.html.heex` work.
 */

import fs from 'node:fs';
import path from 'node:path';

/**
 * Built-in markup extensions for Live's wrap/accept source search.
 *
 * Elixir's `.ex` is here because Phoenix function components put `~H"""`
 * templates directly in `lib/**\/*.ex`; `.heex` and `.eex` cover standalone
 * templates. `.exs` is deliberately absent: those are Elixir *scripts*
 * (`mix.exs`, `config/*.exs`, tests) and never hold markup, so including them
 * only gives the wrap query a chance to match build config by accident.
 */
export const LIVE_TEMPLATE_EXTENSIONS = Object.freeze([
  '.html', '.jsx', '.tsx', '.vue', '.svelte', '.astro',
  '.ex', '.heex', '.eex',
]);

/**
 * Normalize `detector.extensions` entries to `{ ext, engine }`.
 *
 * Accepts `{ ext, engine }` objects (engine 'html' | 'text', default 'html' —
 * the common case for server-side templates) or bare strings as shorthand.
 */
export function normalizeExtensionEntries(entries) {
  if (!Array.isArray(entries)) return [];
  const out = [];
  for (const entry of entries) {
    const raw = typeof entry === 'string' ? entry : entry?.ext;
    if (typeof raw !== 'string') continue;
    let ext = raw.trim().toLowerCase();
    if (!ext) continue;
    if (!ext.startsWith('.')) ext = `.${ext}`;
    const engine = (!(typeof entry === 'string') && entry?.engine === 'text') ? 'text' : 'html';
    out.push({ ext, engine });
  }
  return out;
}

export function mergeExtensions(existing, incoming) {
  const map = new Map();
  for (const entry of normalizeExtensionEntries(existing)) map.set(entry.ext, entry);
  for (const entry of normalizeExtensionEntries(incoming)) map.set(entry.ext, entry);
  return Array.from(map.values());
}

export function matchConfiguredExtension(filePath, extensions) {
  if (!Array.isArray(extensions) || extensions.length === 0) return null;
  const name = path.basename(String(filePath || '')).toLowerCase();
  if (!name) return null;
  // The longest matching suffix wins, so `.blade.php` beats a broader `.php`
  // entry regardless of config order.
  let best = null;
  for (const entry of normalizeExtensionEntries(extensions)) {
    if (name.length > entry.ext.length && name.endsWith(entry.ext)
      && (!best || entry.ext.length > best.ext.length)) {
      best = entry;
    }
  }
  return best;
}

/**
 * Does this filename end in one of `extensions`?
 *
 * Suffix matching rather than `path.extname` equality, so a configured
 * `.html.erb` matches `show.html.erb` (whose extname is only `.erb`). The
 * `name.length > ext.length` guard keeps a file literally named `.heex` from
 * counting as a template.
 */
export function matchesTemplateExtension(filePath, extensions) {
  const name = path.basename(String(filePath || '')).toLowerCase();
  if (!name) return false;
  for (const ext of extensions) {
    if (name.length > ext.length && name.endsWith(ext)) return true;
  }
  return false;
}

/**
 * Built-in Live extensions plus any the project configured for the detector.
 *
 * Reading `detector.extensions` here is the point: a user who taught the design
 * hook about `.blade.php` should not have to teach Live separately. Config
 * parsing is intentionally minimal (own the shape, not the whole hook config)
 * so this module stays importable from the Live CLI without pulling in
 * hook-lib.mjs.
 */
export function resolveLiveTemplateExtensions(cwd = process.cwd()) {
  const cached = extensionCache.get(cwd);
  if (cached) return cached;
  const resolved = readLiveTemplateExtensions(cwd);
  extensionCache.set(cwd, resolved);
  return resolved;
}

// live-wrap calls the resolver once per candidate query per pass (up to eight
// times in one CLI run), and every call would otherwise re-read and re-parse
// both config files. Keyed by cwd; a single CLI process never rewrites its own
// config mid-run.
const extensionCache = new Map();

/** Test seam: drop the memoized config so a fixture can rewrite config.json. */
export function clearTemplateExtensionCache() {
  extensionCache.clear();
}

function readLiveTemplateExtensions(cwd) {
  const configured = [];
  for (const name of ['config.json', 'config.local.json']) {
    const raw = safeReadJson(path.join(cwd, '.impeccable', name));
    const detector = raw?.detector;
    if (detector && typeof detector === 'object' && !Array.isArray(detector)) {
      configured.push(...normalizeExtensionEntries(detector.extensions));
    }
  }
  const seen = new Set(LIVE_TEMPLATE_EXTENSIONS);
  const out = [...LIVE_TEMPLATE_EXTENSIONS];
  for (const { ext } of configured) {
    if (seen.has(ext)) continue;
    seen.add(ext);
    out.push(ext);
  }
  return out;
}

function safeReadJson(filePath) {
  try {
    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
  } catch {
    return null;
  }
}