import fs from "node:fs";
import path from "node:path";

import * as ts from "typescript";

const HTTP_API_ENDPOINT_METHODS = new Set(["delete", "patch", "post", "put"]);
const SCHEMA_CLASS_FACTORIES = new Set(["Class", "TaggedClass", "ErrorClass", "TaggedErrorClass"]);
const DEFAULT_ROOTS = ["apps", "packages", "scripts"];
const IGNORED_DIRS = new Set([
  ".git",
  ".local",
  ".reference",
  ".turbo",
  ".worktrees",
  "dist",
  "node_modules",
]);
const EXTENSIONS = new Set([".ts", ".tsx"]);

type Finding = {
  readonly fileName: string;
  readonly line: number;
  readonly column: number;
  readonly endpoint: string;
  readonly className: string;
};

type Analyzer = {
  readonly checker: ts.TypeChecker;
  readonly program: ts.Program;
  readonly findings: Array<Finding>;
  readonly schemaClassCache: Map<ts.Symbol, string | undefined>;
  readonly expressionCache: Map<ts.Node, string | undefined>;
};

const main = () => {
  const repoRoot = process.cwd();
  const files = collectInputFiles(repoRoot, process.argv.slice(2));
  if (files.length === 0) return;

  const program = ts.createProgram(files, {
    allowImportingTsExtensions: true,
    exactOptionalPropertyTypes: true,
    jsx: ts.JsxEmit.ReactJSX,
    module: ts.ModuleKind.Preserve,
    moduleResolution: ts.ModuleResolutionKind.Bundler,
    noEmit: true,
    noUncheckedIndexedAccess: true,
    skipLibCheck: true,
    strict: true,
    target: ts.ScriptTarget.ES2022,
    verbatimModuleSyntax: true,
  });
  const analyzer: Analyzer = {
    checker: program.getTypeChecker(),
    program,
    findings: [],
    schemaClassCache: new Map(),
    expressionCache: new Map(),
  };

  for (const sourceFile of program.getSourceFiles()) {
    if (sourceFile.isDeclarationFile || !files.includes(sourceFile.fileName)) continue;
    visitSourceFile(analyzer, sourceFile);
  }

  if (analyzer.findings.length === 0) return;

  for (const finding of analyzer.findings) {
    const relative = path.relative(repoRoot, finding.fileName);
    console.error(
      `${relative}:${finding.line}:${finding.column} Use a structural schema for HttpApiEndpoint payload "${finding.endpoint}"; ${finding.className} is Schema.Class-backed.`,
    );
  }
  process.exitCode = 1;
};

const collectInputFiles = (repoRoot: string, inputPaths: ReadonlyArray<string>) => {
  const roots = inputPaths.length === 0 ? DEFAULT_ROOTS : inputPaths;
  const files = new Set<string>();
  for (const input of roots) {
    const resolved = path.resolve(repoRoot, input);
    collectFiles(resolved, files);
  }
  return Array.from(files).sort();
};

const collectFiles = (target: string, files: Set<string>) => {
  if (!fs.existsSync(target)) return;
  const stat = fs.statSync(target);
  if (stat.isDirectory()) {
    if (IGNORED_DIRS.has(path.basename(target))) return;
    for (const entry of fs.readdirSync(target)) {
      collectFiles(path.join(target, entry), files);
    }
    return;
  }
  if (!stat.isFile()) return;
  if (!EXTENSIONS.has(path.extname(target))) return;
  if (target.endsWith("routeTree.gen.ts")) return;
  files.add(target);
};

const visitSourceFile = (analyzer: Analyzer, sourceFile: ts.SourceFile) => {
  const visit = (node: ts.Node) => {
    if (ts.isCallExpression(node)) {
      inspectEndpointCall(analyzer, node);
    }
    ts.forEachChild(node, visit);
  };
  ts.forEachChild(sourceFile, visit);
};

const inspectEndpointCall = (analyzer: Analyzer, node: ts.CallExpression) => {
  const endpointName = getHttpEndpointName(analyzer, node.expression);
  if (!endpointName) return;

  for (const argument of node.arguments) {
    const payload = getObjectPropertyExpression(analyzer, argument, "payload");
    if (!payload) continue;

    const className = findSchemaClassSchema(analyzer, payload, new Set(), new Set());
    if (!className) continue;

    const sourceFile = payload.getSourceFile();
    const position = sourceFile.getLineAndCharacterOfPosition(payload.getStart(sourceFile));
    analyzer.findings.push({
      className,
      column: position.character + 1,
      endpoint: endpointName,
      fileName: sourceFile.fileName,
      line: position.line + 1,
    });
  }
};

const getHttpEndpointName = (analyzer: Analyzer, expression: ts.Expression) => {
  const unwrapped = unwrapExpression(expression);
  if (!ts.isPropertyAccessExpression(unwrapped)) return undefined;
  if (!HTTP_API_ENDPOINT_METHODS.has(unwrapped.name.text)) return undefined;
  if (!isHttpApiEndpointExpression(analyzer, unwrapped.expression)) return undefined;
  return unwrapped.name.text;
};

const isHttpApiEndpointExpression = (analyzer: Analyzer, expression: ts.Expression): boolean => {
  const unwrapped = unwrapExpression(expression);
  if (ts.isIdentifier(unwrapped)) {
    if (unwrapped.text === "HttpApiEndpoint") return true;
    return isNodeSymbolNamed(analyzer, unwrapped, "HttpApiEndpoint");
  }
  if (!ts.isPropertyAccessExpression(unwrapped)) return false;
  if (unwrapped.name.text !== "HttpApiEndpoint") return false;
  return true;
};

const getObjectPropertyExpression = (
  analyzer: Analyzer,
  expression: ts.Expression,
  propertyName: string,
): ts.Expression | undefined => {
  const object = resolveObjectLiteral(analyzer, expression, new Set());
  if (!object) return undefined;

  for (const property of object.properties) {
    if (ts.isSpreadAssignment(property)) {
      const spreadValue = getObjectPropertyExpression(analyzer, property.expression, propertyName);
      if (spreadValue) return spreadValue;
      continue;
    }
    if (!ts.isPropertyAssignment(property)) continue;
    if (getPropertyName(property.name) === propertyName) return property.initializer;
  }
  return undefined;
};

const resolveObjectLiteral = (
  analyzer: Analyzer,
  expression: ts.Expression,
  visitedSymbols: Set<ts.Symbol>,
): ts.ObjectLiteralExpression | undefined => {
  const unwrapped = unwrapExpression(expression);
  if (ts.isObjectLiteralExpression(unwrapped)) return unwrapped;

  const symbol = resolveSymbol(analyzer, unwrapped);
  if (!symbol || visitedSymbols.has(symbol)) return undefined;
  visitedSymbols.add(symbol);

  for (const declaration of symbol.declarations ?? []) {
    if (!ts.isVariableDeclaration(declaration) || !declaration.initializer) continue;
    return resolveObjectLiteral(analyzer, declaration.initializer, visitedSymbols);
  }
  return undefined;
};

const findSchemaClassSchema = (
  analyzer: Analyzer,
  expression: ts.Expression,
  visitedSymbols: Set<ts.Symbol>,
  visitedNodes: Set<ts.Node>,
): string | undefined => {
  const unwrapped = unwrapExpression(expression);
  if (visitedNodes.has(unwrapped)) return undefined;
  visitedNodes.add(unwrapped);

  if (analyzer.expressionCache.has(unwrapped)) {
    return analyzer.expressionCache.get(unwrapped);
  }

  const found =
    findSchemaClassFromNode(analyzer, unwrapped, visitedSymbols, visitedNodes) ??
    findSchemaClassFromResolvedSymbol(analyzer, unwrapped, visitedSymbols, visitedNodes);

  analyzer.expressionCache.set(unwrapped, found);
  return found;
};

const findSchemaClassFromNode = (
  analyzer: Analyzer,
  node: ts.Expression,
  visitedSymbols: Set<ts.Symbol>,
  visitedNodes: Set<ts.Node>,
): string | undefined => {
  if (ts.isCallExpression(node)) {
    const classFactory = getSchemaClassFactoryName(analyzer, node.expression);
    if (classFactory) return classFactory;

    const calleeExpression = ts.isPropertyAccessExpression(node.expression)
      ? node.expression.expression
      : node.expression;
    const calleeClass = findSchemaClassSchema(
      analyzer,
      calleeExpression,
      visitedSymbols,
      visitedNodes,
    );
    if (calleeClass) return calleeClass;

    for (const argument of node.arguments) {
      const className = findSchemaClassSchema(analyzer, argument, visitedSymbols, visitedNodes);
      if (className) return className;
    }
    return undefined;
  }

  if (ts.isClassExpression(node)) {
    return getClassSchemaName(analyzer, node);
  }

  if (ts.isObjectLiteralExpression(node)) {
    for (const property of node.properties) {
      if (ts.isPropertyAssignment(property)) {
        const className = findSchemaClassSchema(
          analyzer,
          property.initializer,
          visitedSymbols,
          visitedNodes,
        );
        if (className) return className;
      }
      if (ts.isSpreadAssignment(property)) {
        const className = findSchemaClassSchema(
          analyzer,
          property.expression,
          visitedSymbols,
          visitedNodes,
        );
        if (className) return className;
      }
    }
    return undefined;
  }

  if (ts.isArrayLiteralExpression(node)) {
    for (const element of node.elements) {
      if (ts.isSpreadElement(element)) {
        const className = findSchemaClassSchema(
          analyzer,
          element.expression,
          visitedSymbols,
          visitedNodes,
        );
        if (className) return className;
        continue;
      }
      const className = findSchemaClassSchema(analyzer, element, visitedSymbols, visitedNodes);
      if (className) return className;
    }
  }

  return undefined;
};

const findSchemaClassFromResolvedSymbol = (
  analyzer: Analyzer,
  expression: ts.Expression,
  visitedSymbols: Set<ts.Symbol>,
  visitedNodes: Set<ts.Node>,
): string | undefined => {
  const symbol = resolveSymbol(analyzer, expression);
  if (!symbol || visitedSymbols.has(symbol)) return undefined;
  visitedSymbols.add(symbol);

  const cached = analyzer.schemaClassCache.get(symbol);
  if (cached !== undefined) return cached;

  for (const declaration of symbol.declarations ?? []) {
    if (ts.isClassDeclaration(declaration)) {
      const className = getClassSchemaName(analyzer, declaration);
      if (className) {
        analyzer.schemaClassCache.set(symbol, className);
        return className;
      }
      continue;
    }

    if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
      const className = findSchemaClassSchema(
        analyzer,
        declaration.initializer,
        new Set(visitedSymbols),
        visitedNodes,
      );
      if (className) {
        analyzer.schemaClassCache.set(symbol, className);
        return className;
      }
    }
  }

  analyzer.schemaClassCache.set(symbol, undefined);
  return undefined;
};

const getClassSchemaName = (
  analyzer: Analyzer,
  node: ts.ClassDeclaration | ts.ClassExpression,
): string | undefined => {
  for (const clause of node.heritageClauses ?? []) {
    if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
    for (const type of clause.types) {
      if (getSchemaClassFactoryName(analyzer, type.expression)) {
        return node.name?.text ?? "anonymous Schema.Class";
      }
    }
  }
  return undefined;
};

const getSchemaClassFactoryName = (
  analyzer: Analyzer,
  expression: ts.Expression,
): string | undefined => {
  const callee = getInnermostCallee(expression);
  if (ts.isPropertyAccessExpression(callee)) {
    if (!SCHEMA_CLASS_FACTORIES.has(callee.name.text)) return undefined;
    if (isSchemaNamespaceExpression(analyzer, callee.expression)) return callee.name.text;
    return undefined;
  }

  if (!ts.isIdentifier(callee)) return undefined;
  if (!SCHEMA_CLASS_FACTORIES.has(callee.text)) return undefined;
  return isNodeSymbolNamed(analyzer, callee, callee.text) ? callee.text : undefined;
};

const getInnermostCallee = (expression: ts.Expression): ts.Expression => {
  const unwrapped = unwrapExpression(expression);
  if (!ts.isCallExpression(unwrapped)) return unwrapped;
  return getInnermostCallee(unwrapped.expression);
};

const isSchemaNamespaceExpression = (analyzer: Analyzer, expression: ts.Expression) => {
  const unwrapped = unwrapExpression(expression);
  if (!ts.isIdentifier(unwrapped)) return false;
  if (unwrapped.text === "Schema") return true;
  return isNodeSymbolNamed(analyzer, unwrapped, "Schema");
};

const resolveSymbol = (analyzer: Analyzer, node: ts.Node): ts.Symbol | undefined => {
  const symbol = analyzer.checker.getSymbolAtLocation(node);
  if (!symbol) return undefined;
  if ((symbol.flags & ts.SymbolFlags.Alias) === 0) return symbol;
  return analyzer.checker.getAliasedSymbol(symbol);
};

const isNodeSymbolNamed = (analyzer: Analyzer, node: ts.Node, name: string) => {
  const symbol = analyzer.checker.getSymbolAtLocation(node);
  return isSymbolNamed(symbol, name) || isSymbolNamed(resolveSymbol(analyzer, node), name);
};

const isSymbolNamed = (symbol: ts.Symbol | undefined, name: string) => {
  if (!symbol) return false;
  if (symbol.escapedName === name) return true;
  return (symbol.declarations ?? []).some((declaration) => {
    if (ts.isImportSpecifier(declaration)) {
      return (declaration.propertyName ?? declaration.name).text === name;
    }
    if (ts.isNamespaceImport(declaration)) {
      return declaration.name.text === name;
    }
    if (ts.isExportSpecifier(declaration)) {
      return (declaration.propertyName ?? declaration.name).text === name;
    }
    if (ts.isModuleDeclaration(declaration)) {
      return declaration.name.text === name;
    }
    return false;
  });
};

const unwrapExpression = (expression: ts.Expression): ts.Expression => {
  let current = expression;
  while (
    ts.isParenthesizedExpression(current) ||
    ts.isAsExpression(current) ||
    ts.isSatisfiesExpression(current) ||
    ts.isNonNullExpression(current) ||
    ts.isTypeAssertionExpression(current)
  ) {
    current = current.expression;
  }
  return current;
};

const getPropertyName = (name: ts.PropertyName): string | undefined => {
  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
    return name.text;
  return undefined;
};

main();