import path from "node:path";
import { fileURLToPath } from "node:url";

export const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");

export function toRepoRelative(filename) {
  return path.relative(repoRoot, path.resolve(filename)).split(path.sep).join("/");
}

export function isConfigOrTooling(filename) {
  const normalized = toRepoRelative(filename);
  return (
    /(^|\/)(vite|vitest|tsup|drizzle|autumn)\.config\.ts$/.test(normalized) ||
    normalized.startsWith("scripts/")
  );
}

export function isTestLike(filename) {
  const normalized = toRepoRelative(filename);
  return (
    /(\.|\/)(test|spec|e2e|node\.test)\.tsx?$/.test(normalized) || normalized.startsWith("tests/")
  );
}

export function isDeclarationFile(filename) {
  return toRepoRelative(filename).endsWith(".d.ts");
}

export function unwrapExpression(node) {
  let current = node;
  while (
    current?.type === "ChainExpression" ||
    current?.type === "ParenthesizedExpression" ||
    current?.type === "TSNonNullExpression" ||
    current?.type === "TSAsExpression" ||
    current?.type === "TSTypeAssertion"
  ) {
    current = current.expression;
  }
  return current;
}

export function getPropertyName(node) {
  if (!node) return undefined;
  if (node.type === "Identifier") return node.name;
  if (node.type === "PrivateIdentifier") return node.name;
  if (node.type === "Literal" && typeof node.value === "string") return node.value;
  if (node.type === "StringLiteral") return node.value;
  return undefined;
}

export function getCallName(node) {
  const expression = unwrapExpression(node);
  if (expression?.type === "Identifier") return expression.name;
  if (expression?.type === "MemberExpression") return getPropertyName(expression.property);
  return undefined;
}

export function hasObjectProperty(node, name) {
  const expression = unwrapExpression(node);
  if (expression?.type !== "ObjectExpression") return false;
  return expression.properties.some((property) => {
    if (property.type === "SpreadElement") return false;
    return getPropertyName(property.key) === name;
  });
}

export function getStringValue(node) {
  const expression = unwrapExpression(node);
  if (expression?.type === "Literal" && typeof expression.value === "string")
    return expression.value;
  if (expression?.type === "StringLiteral") return expression.value;
  return undefined;
}

export function isIdentifier(node, name) {
  return node?.type === "Identifier" && (name === undefined || node.name === name);
}

export function isStringLiteral(node) {
  return (
    (node?.type === "Literal" && typeof node.value === "string") || node?.type === "StringLiteral"
  );
}

export function typeName(node) {
  if (node?.type === "Identifier") return node.name;
  if (node?.type === "TSQualifiedName") {
    const left = typeName(node.left);
    const right = typeName(node.right);
    return left && right ? `${left}.${right}` : undefined;
  }
  return undefined;
}

export function typeReferenceName(node) {
  return node?.type === "TSTypeReference" ? typeName(node.typeName) : undefined;
}

export function isPromiseType(node) {
  return typeReferenceName(node) === "Promise";
}

export function containsPromiseType(node) {
  if (!node || typeof node !== "object") return false;
  if (isPromiseType(node)) return true;

  switch (node.type) {
    case "TSTypeAnnotation":
      return containsPromiseType(node.typeAnnotation);
    case "TSFunctionType":
      return containsPromiseType(node.returnType);
    case "TSParenthesizedType":
      return containsPromiseType(node.typeAnnotation);
    case "TSUnionType":
    case "TSIntersectionType":
      return (node.types ?? []).some(containsPromiseType);
    case "TSConditionalType":
      return containsPromiseType(node.trueType) || containsPromiseType(node.falseType);
    default:
      return false;
  }
}

export function nodeName(node) {
  if (isIdentifier(node)) return node.name;
  if (node?.type === "PrivateIdentifier") return node.name;
  if (isStringLiteral(node)) return node.value;
  return undefined;
}