import fs from "node:fs/promises";
import path from "node:path";
import fg from "fast-glob";
import { type CommandResult, success } from "../../../lib/command-result";
import { APP_PATHS } from "../../../lib/paths";

export interface ResolverMeasure {
  count: number;
  avgLoC: number;
  maxLoC: number;
  filesOverThreshold: { path: string; loc: number }[];
}

export interface CommandMeasure {
  count: number;
  avgLoC: number;
  handWrittenRatio: number;
  libNonTypesFiles: string[];
}

export interface FrontendMeasure {
  pages: { count: number };
  appShellCatalog: {
    localVersion: string | null;
    source: "local" | "unresolved";
  };
  jsxComposition: {
    appShellTags: number;
    replaceableTags: number;
    candidateTags: number;
    structuralTags: number;
    otherLibraryTags: number;
    unclassifiedTags: number;
    appShellRatio: number;
  };
  appShellGaps: { tag: string; count: number }[];
  suspectedHandRolled: {
    path: string;
    appShellTags: number;
    structuralTags: number;
    replaceableTags: number;
  }[];
  rawHtmlHeavyPages: { path: string; appShellRatio: number; replaceableTags: number }[];
  customComponents: number;
  localComponentRisks: {
    path: string;
    exportedNames: string[];
    reasons: string[];
    appShellTags: number;
    replaceableTags: number;
    structuralTags: number;
  }[];
}

export interface MeasureThinResult {
  resolver?: ResolverMeasure;
  command?: CommandMeasure;
  frontend?: FrontendMeasure;
}

const RESOLVER_LOC_THRESHOLD = 200;
const APP_SHELL_PACKAGE = "@tailor-platform/app-shell";
const RAW_HTML_HEAVY_RATIO = 0.5;
const RAW_HTML_HEAVY_MIN_TAGS = 5;

const HANDROLLED_MIN_STRUCTURAL = 20;
const HANDROLLED_MAX_APPSHELL_RATIO = 0.4;

const STRUCTURAL_TAGS = new Set([
  "div",
  "span",
  "p",
  "br",
  "hr",
  "ul",
  "ol",
  "li",
  "dl",
  "dt",
  "dd",
  "section",
  "article",
  "nav",
  "header",
  "footer",
  "main",
  "aside",
  "figure",
  "figcaption",
  "hgroup",
  "address",
  "small",
  "strong",
  "em",
  "b",
  "i",
  "u",
  "s",
  "mark",
  "code",
  "pre",
  "blockquote",
  "abbr",
  "cite",
  "q",
  "sub",
  "sup",
  "kbd",
  "samp",
  "var",
  "wbr",
  "h1",
  "h2",
  "h3",
  "h4",
  "h5",
  "h6",
]);

const TS_TYPE_KEYWORDS = new Set([
  "string",
  "number",
  "boolean",
  "void",
  "typeof",
  "null",
  "undefined",
  "any",
  "unknown",
  "never",
  "bigint",
  "keyof",
  "infer",
  "readonly",
]);

// SVG drawing primitives. Not something app-shell provides a replacement for
// (they are the raw material of a drawing, not UI parts), so they belong in
// neither the ratio nor appShellGaps — treat as neutral and skip.
const SVG_TAGS = new Set([
  "svg",
  "g",
  "defs",
  "use",
  "symbol",
  "marker",
  "mask",
  "clipPath",
  "pattern",
  "path",
  "rect",
  "circle",
  "ellipse",
  "line",
  "polyline",
  "polygon",
  "text",
  "tspan",
  "textPath",
  "image",
  "foreignObject",
  "linearGradient",
  "radialGradient",
  "stop",
  "filter",
  "feGaussianBlur",
  "feOffset",
  "feBlend",
  "feColorMatrix",
  "feMerge",
  "feMergeNode",
]);

const IMPORT_RE =
  /import\s+(type\s+)?(?:(?:([A-Za-z_$][\w$]*)\s*,\s*)?(?:\{([^}]+)\}|\*\s+as\s+([A-Za-z_$][\w$]*))|([A-Za-z_$][\w$]*))\s+from\s+["']([^"']+)["']/g;
const JSX_TAG_OPEN_RE = /<([A-Za-z][A-Za-z0-9_.]*)/g;
const COMPONENT_DECL_RE = /^export declare (?:function|const) ([A-Z][A-Za-z0-9]*)/gm;
// Namespace/compound members, e.g. `Label` in
// `export declare const Field: { Label: typeof Label; ... }`. These expose
// components like `<Field.Label>` that the top-level COMPONENT_DECL_RE misses,
// so a raw `<label>` would otherwise be a false-positive gap. Used ONLY to
// judge tag replaceability — never for the shadow check, where generic member
// names (`Item`/`Content`/`Title`) would manufacture false "shadows" risks.
const NAMESPACE_MEMBER_RE = /^\s+([A-Z][A-Za-z0-9]*):\s*typeof\s/gm;
const COMPONENT_PROPS_RE = /ComponentProps<"([a-z][a-z0-9]*)"/g;
const COMPONENT_SOURCE_DECL_RE =
  /export\s+(?:default\s+)?(?:async\s+)?(?:function|const)\s+([A-Z][A-Za-z0-9]*)/g;
const EXPORT_LIST_RE = /export\s*\{([^}]*)\}(?!\s*from)/g;
const LOCAL_RISK_MIN_REPLACEABLE = 3;

interface AppShellCatalog {
  version: string | null;
  /** Top-level PascalCase exports. Used for the shadow check (re-implementation). */
  componentNames: Set<string>;
  /**
   * componentNames PLUS namespace members (`Field.Label` → `Label`). Used only
   * to judge raw-tag replaceability, so `<label>` resolves to `Field.Label`
   * instead of being a false-positive gap.
   */
  replaceableNames: Set<string>;
  componentPropsTags: Set<string>;
}

function readPkgMeta(parsed: unknown): { version: string | null; dtsRel: string } {
  const pkg = (parsed ?? {}) as { version?: unknown; exports?: Record<string, unknown> };
  const version = typeof pkg.version === "string" ? pkg.version : null;
  const dot = pkg.exports?.["."] as { types?: unknown } | undefined;
  const dtsRel = typeof dot?.types === "string" ? dot.types : "./dist/app-shell.d.ts";
  return { version, dtsRel };
}

function parseCatalog(dts: string, version: string | null): AppShellCatalog {
  const componentNames = new Set<string>();
  COMPONENT_DECL_RE.lastIndex = 0;
  let m: RegExpExecArray | null;
  while ((m = COMPONENT_DECL_RE.exec(dts)) !== null) {
    componentNames.add(m[1]);
  }
  // Replaceability also recognises namespace members (`Field.Label` etc.);
  // shadow detection deliberately stays on the top-level names above.
  const replaceableNames = new Set<string>(componentNames);
  NAMESPACE_MEMBER_RE.lastIndex = 0;
  while ((m = NAMESPACE_MEMBER_RE.exec(dts)) !== null) {
    replaceableNames.add(m[1]);
  }
  const componentPropsTags = new Set<string>();
  COMPONENT_PROPS_RE.lastIndex = 0;
  while ((m = COMPONENT_PROPS_RE.exec(dts)) !== null) {
    const tag = m[1];
    if (!STRUCTURAL_TAGS.has(tag)) componentPropsTags.add(tag);
  }
  return { version, componentNames, replaceableNames, componentPropsTags };
}

async function loadLocalCatalog(cwd: string, appRoot: string): Promise<AppShellCatalog | null> {
  const bases = [path.join(cwd, appRoot, "frontend"), path.join(cwd, appRoot), cwd];
  for (const base of bases) {
    const pkgPath = path.join(base, "node_modules", APP_SHELL_PACKAGE, "package.json");
    try {
      const { version, dtsRel } = readPkgMeta(JSON.parse(await fs.readFile(pkgPath, "utf-8")));
      const dts = await fs.readFile(path.join(path.dirname(pkgPath), dtsRel), "utf-8");
      return parseCatalog(dts, version);
    } catch {}
  }
  return null;
}

function isReplaceableTag(tag: string, catalog: AppShellCatalog): boolean {
  const pascal = tag.charAt(0).toUpperCase() + tag.slice(1);
  return catalog.replaceableNames.has(pascal) || catalog.componentPropsTags.has(tag);
}

interface LocalImportMatcher {
  aliasPrefixes: string[];
  workspaceNames: Set<string>;
}

const EMPTY_LOCAL_MATCHER: LocalImportMatcher = { aliasPrefixes: [], workspaceNames: new Set() };
const DEFAULT_LOCAL_ALIAS_PREFIXES = ["@/", "~/"];

function stripJsonComments(src: string): string {
  return src
    .replace(/\/\*[\s\S]*?\*\//g, "")
    .replace(/(^|[^:])\/\/[^\n\r]*/g, "$1")
    .replace(/,(\s*[}\]])/g, "$1");
}

async function readTsconfigAliasPrefixes(dir: string): Promise<string[]> {
  const prefixes = new Set<string>();
  let files: string[];
  try {
    files = await fg("tsconfig*.json", { cwd: dir, deep: 1 });
  } catch {
    return [];
  }
  for (const f of files) {
    try {
      const raw = await fs.readFile(path.join(dir, f), "utf-8");
      const json = JSON.parse(stripJsonComments(raw)) as {
        compilerOptions?: { paths?: Record<string, unknown> };
      };
      for (const key of Object.keys(json.compilerOptions?.paths ?? {})) {
        prefixes.add(key.replace(/\*+$/, ""));
      }
    } catch {}
  }
  return [...prefixes];
}

async function readWorkspacePackageNames(cwd: string): Promise<Set<string>> {
  const names = new Set<string>();
  let files: string[];
  try {
    files = await fg("**/package.json", {
      cwd,
      ignore: ["**/node_modules/**", "**/dist/**"],
      deep: 5,
    });
  } catch {
    return names;
  }
  for (const f of files) {
    try {
      const json = JSON.parse(await fs.readFile(path.join(cwd, f), "utf-8")) as { name?: unknown };
      if (typeof json.name === "string") names.add(json.name);
    } catch {}
  }
  return names;
}

async function buildLocalImportMatcher(cwd: string, appRoot: string): Promise<LocalImportMatcher> {
  const [tsconfigPrefixes, workspaceNames] = await Promise.all([
    readTsconfigAliasPrefixes(path.join(cwd, appRoot, "frontend")),
    readWorkspacePackageNames(cwd),
  ]);
  const aliasPrefixes = [...new Set([...DEFAULT_LOCAL_ALIAS_PREFIXES, ...tsconfigPrefixes])];
  return { aliasPrefixes, workspaceNames };
}

function isLocalImport(from: string, matcher: LocalImportMatcher): boolean {
  for (const prefix of matcher.aliasPrefixes) {
    if (prefix.endsWith("/")) {
      if (from === prefix.slice(0, -1) || from.startsWith(prefix)) return true;
    } else if (from === prefix || from.startsWith(`${prefix}/`)) {
      return true;
    }
  }
  const head = from.startsWith("@") ? from.split("/").slice(0, 2).join("/") : from.split("/")[0];
  return matcher.workspaceNames.has(from) || matcher.workspaceNames.has(head);
}

function extractNamedIdentifiers(clause: string): string[] {
  return clause
    .split(",")
    .map((entry) => entry.trim())
    .filter(Boolean)
    .filter((entry) => !entry.startsWith("type "))
    .map((entry) => {
      const parts = entry.split(/\s+as\s+/);
      return parts[parts.length - 1].trim();
    })
    .filter(Boolean);
}

function extractImportIdentifiers(match: RegExpExecArray): { ids: string[]; from: string } | null {
  const typeOnly = Boolean(match[1]);
  if (typeOnly) return null;

  const defaultWithNamedOrNamespace = match[2];
  const namedClause = match[3];
  const namespaceIdentifier = match[4];
  const defaultOnly = match[5];
  const from = match[6];
  const ids = [
    defaultWithNamedOrNamespace,
    namespaceIdentifier,
    defaultOnly,
    ...(namedClause ? extractNamedIdentifiers(namedClause) : []),
  ].filter((id): id is string => Boolean(id));

  return { ids, from };
}

function extractExportedComponentNames(content: string): Set<string> {
  const names = new Set<string>();
  let m: RegExpExecArray | null;
  COMPONENT_SOURCE_DECL_RE.lastIndex = 0;
  while ((m = COMPONENT_SOURCE_DECL_RE.exec(content)) !== null) names.add(m[1]);
  EXPORT_LIST_RE.lastIndex = 0;
  while ((m = EXPORT_LIST_RE.exec(content)) !== null) {
    for (const name of extractNamedIdentifiers(m[1])) {
      if (/^[A-Z][A-Za-z0-9]*$/.test(name)) names.add(name);
    }
  }
  return names;
}

function parseImports(
  content: string,
  localMatcher: LocalImportMatcher = EMPTY_LOCAL_MATCHER,
): {
  appShell: Set<string>;
  otherLibrary: Set<string>;
} {
  const appShell = new Set<string>();
  const otherLibrary = new Set<string>();
  let m: RegExpExecArray | null;
  IMPORT_RE.lastIndex = 0;
  while ((m = IMPORT_RE.exec(content)) !== null) {
    const parsed = extractImportIdentifiers(m);
    if (!parsed) continue;
    const { ids, from } = parsed;
    if (from === APP_SHELL_PACKAGE) {
      for (const id of ids) appShell.add(id);
    } else if (from.startsWith(".") || from === "react" || from === "react-dom") {
    } else if (isLocalImport(from, localMatcher)) {
    } else {
      for (const id of ids) otherLibrary.add(id);
    }
  }
  return { appShell, otherLibrary };
}

interface FileJsxCount {
  appShellTags: number;
  replaceableTags: number;
  structuralTags: number;
  otherLibraryTags: number;
  unclassifiedTags: number;
  candidate: Map<string, number>;
}

function countJsxTags(
  content: string,
  appShell: Set<string>,
  otherLibrary: Set<string>,
  catalog: AppShellCatalog | null,
): FileJsxCount {
  let appShellTags = 0;
  let replaceableTags = 0;
  let structuralTags = 0;
  let otherLibraryTags = 0;
  let unclassifiedTags = 0;
  const candidate = new Map<string, number>();
  let m: RegExpExecArray | null;
  JSX_TAG_OPEN_RE.lastIndex = 0;
  while ((m = JSX_TAG_OPEN_RE.exec(content)) !== null) {
    const topLevel = m[1].split(".")[0];
    if (/^[a-z]/.test(topLevel)) {
      if (TS_TYPE_KEYWORDS.has(topLevel)) continue;
      if (SVG_TAGS.has(topLevel)) continue;
      if (STRUCTURAL_TAGS.has(topLevel)) {
        structuralTags++;
      } else if (!catalog) {
        unclassifiedTags++;
      } else if (isReplaceableTag(topLevel, catalog)) {
        replaceableTags++;
      } else {
        candidate.set(topLevel, (candidate.get(topLevel) ?? 0) + 1);
      }
    } else if (appShell.has(topLevel)) {
      appShellTags++;
    } else if (otherLibrary.has(topLevel)) {
      otherLibraryTags++;
    }
  }
  return {
    appShellTags,
    replaceableTags,
    structuralTags,
    otherLibraryTags,
    unclassifiedTags,
    candidate,
  };
}

async function measureJsxFile(
  absPath: string,
  catalog: AppShellCatalog | null,
  localMatcher: LocalImportMatcher = EMPTY_LOCAL_MATCHER,
): Promise<FileJsxCount> {
  const content = await fs.readFile(absPath, "utf-8");
  const { appShell, otherLibrary } = parseImports(content, localMatcher);
  return countJsxTags(content, appShell, otherLibrary, catalog);
}

async function measureLocalComponentRisks(
  appRoot: string,
  cwd: string,
  catalog: AppShellCatalog | null,
  localMatcher: LocalImportMatcher,
): Promise<FrontendMeasure["localComponentRisks"]> {
  const files = await fg([`${appRoot}/frontend/src/**/*.tsx`, "packages/*/src/**/*.tsx"], {
    cwd,
    ignore: [`${appRoot}/frontend/src/pages/**/*.tsx`, "**/*.test.tsx"],
  });

  const risks: FrontendMeasure["localComponentRisks"] = [];
  for (const rel of files) {
    const content = await fs.readFile(path.join(cwd, rel), "utf-8");
    const { appShell, otherLibrary } = parseImports(content, localMatcher);
    const counts = countJsxTags(content, appShell, otherLibrary, catalog);

    const exportedNames = extractExportedComponentNames(content);

    const reasons: string[] = [];
    const shadowed = catalog
      ? [...exportedNames].filter((name) => catalog.componentNames.has(name))
      : [];
    if (shadowed.length > 0) reasons.push(`shadows app-shell component: ${shadowed.join(", ")}`);
    if (counts.replaceableTags >= LOCAL_RISK_MIN_REPLACEABLE)
      reasons.push(`uses ${counts.replaceableTags} replaceable raw tags`);
    const structuralBase = counts.appShellTags + counts.structuralTags;
    if (
      counts.structuralTags >= HANDROLLED_MIN_STRUCTURAL &&
      structuralBase > 0 &&
      counts.appShellTags / structuralBase < HANDROLLED_MAX_APPSHELL_RATIO
    )
      reasons.push("structural-heavy with little app-shell use");

    if (reasons.length > 0) {
      risks.push({
        path: rel,
        exportedNames: [...exportedNames],
        reasons,
        appShellTags: counts.appShellTags,
        replaceableTags: counts.replaceableTags,
        structuralTags: counts.structuralTags,
      });
    }
  }

  return risks.sort((a, b) => b.reasons.length - a.reasons.length || a.path.localeCompare(b.path));
}

async function lineCount(absPath: string): Promise<number> {
  const content = await fs.readFile(absPath, "utf-8");
  return content.split("\n").length;
}

async function measureResolvers(appRoot: string, cwd: string): Promise<ResolverMeasure> {
  const files = await fg(`${appRoot}/${APP_PATHS.code.resolver}/*.ts`, {
    cwd,
    ignore: ["**/*.test.ts", "**/index.ts"],
  });
  if (files.length === 0) {
    return { count: 0, avgLoC: 0, maxLoC: 0, filesOverThreshold: [] };
  }
  const locs: { path: string; loc: number }[] = [];
  for (const f of files) {
    locs.push({ path: f, loc: await lineCount(path.join(cwd, f)) });
  }
  const total = locs.reduce((s, x) => s + x.loc, 0);
  const max = locs.reduce((m, x) => Math.max(m, x.loc), 0);
  return {
    count: locs.length,
    avgLoC: Math.round(total / locs.length),
    maxLoC: max,
    filesOverThreshold: locs.filter((x) => x.loc > RESOLVER_LOC_THRESHOLD),
  };
}

async function measureCommands(modulesRoot: string, cwd: string): Promise<CommandMeasure> {
  const allFiles = await fg(`${modulesRoot}/*/command/*.ts`, {
    cwd,
    ignore: ["**/*.test.ts", "**/index.ts"],
  });
  const handWritten = allFiles.filter((f) => !f.endsWith(".generated.ts"));
  const generated = allFiles.filter((f) => f.endsWith(".generated.ts"));

  let avgLoC = 0;
  if (handWritten.length > 0) {
    const locs = await Promise.all(handWritten.map((f) => lineCount(path.join(cwd, f))));
    avgLoC = Math.round(locs.reduce((s, x) => s + x, 0) / locs.length);
  }

  const totalFiles = handWritten.length + generated.length;
  const handWrittenRatio =
    totalFiles > 0 ? Math.round((handWritten.length / totalFiles) * 100) / 100 : 0;

  const libFiles = await fg(`${modulesRoot}/*/lib/*.ts`, {
    cwd,
    ignore: ["**/*.test.ts"],
  });
  const libNonTypesFiles = libFiles.filter((f) => {
    const basename = path.basename(f);
    return (
      basename !== "types.ts" && !basename.endsWith(".generated.ts") && !basename.startsWith("_")
    );
  });

  return { count: handWritten.length, avgLoC, handWrittenRatio, libNonTypesFiles };
}

async function measureFrontend(appRoot: string, cwd: string): Promise<FrontendMeasure> {
  const pages = await fg(`${appRoot}/frontend/src/pages/**/*.tsx`, {
    cwd,
    ignore: ["**/*.test.tsx"],
  });

  const localCatalog = await loadLocalCatalog(cwd, appRoot);
  const localMatcher = await buildLocalImportMatcher(cwd, appRoot);

  let totalAppShell = 0;
  let totalReplaceable = 0;
  let totalStructural = 0;
  let totalOtherLib = 0;
  let totalUnclassified = 0;
  const candidateTotal = new Map<string, number>();
  const rawHtmlHeavyPages: FrontendMeasure["rawHtmlHeavyPages"] = [];
  const suspectedHandRolled: FrontendMeasure["suspectedHandRolled"] = [];

  for (const p of pages) {
    const counts = await measureJsxFile(path.join(cwd, p), localCatalog, localMatcher);
    totalAppShell += counts.appShellTags;
    totalReplaceable += counts.replaceableTags;
    totalStructural += counts.structuralTags;
    totalOtherLib += counts.otherLibraryTags;
    totalUnclassified += counts.unclassifiedTags;
    for (const [tag, n] of counts.candidate) {
      candidateTotal.set(tag, (candidateTotal.get(tag) ?? 0) + n);
    }

    const fileTotal = counts.appShellTags + counts.replaceableTags + counts.otherLibraryTags;
    if (fileTotal > 0) {
      const fileRatio = counts.appShellTags / fileTotal;
      if (fileRatio < RAW_HTML_HEAVY_RATIO && counts.replaceableTags >= RAW_HTML_HEAVY_MIN_TAGS) {
        rawHtmlHeavyPages.push({
          path: p,
          appShellRatio: Math.round(fileRatio * 100) / 100,
          replaceableTags: counts.replaceableTags,
        });
      }
    }

    if (counts.structuralTags >= HANDROLLED_MIN_STRUCTURAL) {
      const structuralRatio = counts.appShellTags / (counts.appShellTags + counts.structuralTags);
      if (structuralRatio < HANDROLLED_MAX_APPSHELL_RATIO) {
        suspectedHandRolled.push({
          path: p,
          appShellTags: counts.appShellTags,
          structuralTags: counts.structuralTags,
          replaceableTags: counts.replaceableTags,
        });
      }
    }
  }

  const denominator = totalAppShell + totalReplaceable + totalOtherLib;
  const appShellRatio = denominator > 0 ? Math.round((totalAppShell / denominator) * 100) / 100 : 0;

  const candidateTags = [...candidateTotal.values()].reduce((s, n) => s + n, 0);
  const appShellGaps = [...candidateTotal.entries()]
    .map(([tag, count]) => ({ tag, count }))
    .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag));

  const components = await fg(`${appRoot}/frontend/src/components/**/*.tsx`, {
    cwd,
    ignore: ["**/*.test.tsx"],
  });

  const localComponentRisks = await measureLocalComponentRisks(
    appRoot,
    cwd,
    localCatalog,
    localMatcher,
  );

  return {
    pages: { count: pages.length },
    appShellCatalog: {
      localVersion: localCatalog?.version ?? null,
      source: localCatalog ? "local" : "unresolved",
    },
    jsxComposition: {
      appShellTags: totalAppShell,
      replaceableTags: totalReplaceable,
      candidateTags,
      structuralTags: totalStructural,
      otherLibraryTags: totalOtherLib,
      unclassifiedTags: totalUnclassified,
      appShellRatio,
    },
    appShellGaps,
    suspectedHandRolled,
    rawHtmlHeavyPages,
    customComponents: components.length,
    localComponentRisks,
  };
}

export async function collectMeasureThin(
  config: { appRoot?: string; modulesRoot?: string },
  cwd: string,
): Promise<MeasureThinResult> {
  const result: MeasureThinResult = {};
  if (config.appRoot) {
    result.resolver = await measureResolvers(config.appRoot, cwd);
    result.frontend = await measureFrontend(config.appRoot, cwd);
  }
  if (config.modulesRoot) {
    result.command = await measureCommands(config.modulesRoot, cwd);
  }
  return result;
}

export async function runInternalMeasureThin(
  config: { appRoot?: string; modulesRoot?: string },
  cwd: string,
): Promise<CommandResult> {
  const result = await collectMeasureThin(config, cwd);
  console.log(formatMeasureThinReport(result));
  return success();
}

function formatMeasureThinReport(result: MeasureThinResult): string {
  return JSON.stringify(result, null, 2);
}