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

import { getPropertyName, isIdentifier, unwrapExpression } from "../utils.js";

const schemaClassExportCache = new Map();

const message =
  "Use a structural Schema.Struct for HttpApiEndpoint payloads; construct Schema.Class values inside handlers after decoding.";

const SCHEMA_CLASS_PATTERN =
  /export\s+class\s+([A-Za-z_$][\w$]*)\s+extends\s+Schema\.(?:Class|TaggedClass|ErrorClass|TaggedErrorClass)\b/g;

export default {
  meta: {
    type: "problem",
    docs: {
      description: "Disallow Schema.Class-backed schemas as HttpApiEndpoint payload schemas.",
    },
  },
  create(context) {
    const schemaClassNames = new Set();

    const addImportedSchemaClasses = (node) => {
      const specifier = node.source.value;
      if (typeof specifier !== "string" || !specifier.startsWith(".")) return;

      const exportedClassNames = readSchemaClassExports(context.filename, specifier);
      if (exportedClassNames.size === 0) return;

      for (const imported of node.specifiers ?? []) {
        if (imported.type !== "ImportSpecifier") continue;
        const importedName = getPropertyName(imported.imported);
        const localName = imported.local?.name;
        if (importedName && localName && exportedClassNames.has(importedName)) {
          schemaClassNames.add(localName);
        }
      }
    };

    return {
      ImportDeclaration: addImportedSchemaClasses,

      ClassDeclaration(node) {
        if (!node.id?.name || !isSchemaClassExtends(node.superClass)) return;
        schemaClassNames.add(node.id.name);
      },

      CallExpression(node) {
        if (!isHttpApiEndpointCall(node.callee)) return;

        for (const arg of node.arguments ?? []) {
          const payload = getObjectPropertyValue(arg, "payload");
          if (!payload || !isSchemaClassPayload(payload, schemaClassNames)) continue;

          context.report({
            node: payload,
            message,
          });
        }
      },
    };
  },
};

function isHttpApiEndpointCall(callee) {
  const expression = unwrapExpression(callee);
  if (expression?.type !== "MemberExpression") return false;
  return isIdentifier(unwrapExpression(expression.object), "HttpApiEndpoint");
}

function getObjectPropertyValue(node, name) {
  const expression = unwrapExpression(node);
  if (expression?.type !== "ObjectExpression") return undefined;

  for (const property of expression.properties ?? []) {
    if (property.type === "SpreadElement") continue;
    if (getPropertyName(property.key) === name) return unwrapExpression(property.value);
  }
  return undefined;
}

function isSchemaClassPayload(node, schemaClassNames) {
  const expression = unwrapExpression(node);
  if (isIdentifier(expression) && schemaClassNames.has(expression.name)) return true;
  return isSchemaClassCall(expression);
}

function isSchemaClassExtends(node) {
  const expression = unwrapExpression(node);
  return isSchemaClassCall(expression);
}

function isSchemaClassCall(node) {
  const expression = unwrapExpression(node);
  if (expression?.type !== "CallExpression") return false;

  let callee = unwrapExpression(expression.callee);
  while (callee?.type === "CallExpression") {
    callee = unwrapExpression(callee.callee);
  }

  if (callee?.type !== "MemberExpression") return false;
  if (!isIdentifier(unwrapExpression(callee.object), "Schema")) return false;
  const method = getPropertyName(callee.property);
  return (
    method === "Class" ||
    method === "TaggedClass" ||
    method === "ErrorClass" ||
    method === "TaggedErrorClass"
  );
}

function readSchemaClassExports(filename, specifier) {
  const resolved = resolveImport(filename, specifier);
  if (!resolved) return new Set();
  if (schemaClassExportCache.has(resolved)) return schemaClassExportCache.get(resolved);

  const source = fs.readFileSync(resolved, "utf8");
  const names = new Set();
  for (const match of source.matchAll(SCHEMA_CLASS_PATTERN)) {
    names.add(match[1]);
  }
  schemaClassExportCache.set(resolved, names);
  return names;
}

function resolveImport(filename, specifier) {
  const base = path.resolve(path.dirname(filename), specifier);
  const candidates = [
    base,
    `${base}.ts`,
    `${base}.tsx`,
    `${base}.js`,
    path.join(base, "index.ts"),
    path.join(base, "index.tsx"),
    path.join(base, "index.js"),
  ];
  return candidates.find(
    (candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile(),
  );
}