/** Lit / décorateurs : chemins publisher avec `${prop}` ou `{$prop}`. */

export function cleanPlaceholder(value: string): string {
  return value.trim().replace(/^this\./, "");
}

export function getValueFromExpression(
  component: unknown,
  expression: string,
): unknown {
  if (!expression) return undefined;
  const segments = expression.split(".").filter(Boolean);
  if (segments.length === 0) return undefined;
  let current: unknown = component;
  for (const segment of segments) {
    if (
      current === undefined ||
      current === null ||
      typeof current !== "object"
    ) {
      return undefined;
    }
    current = (current as Record<string, unknown>)[segment];
  }
  return current;
}

export function resolveDynamicPath(
  component: unknown,
  template: string,
): { ready: boolean; path: string | null } {
  let missing = false;
  const replaceValue = (_match: string, expression: string) => {
    const cleaned = cleanPlaceholder(expression);
    const resolved = getValueFromExpression(component, cleaned);
    if (resolved === undefined || resolved === null) {
      missing = true;
      return "";
    }
    return `${resolved}`;
  };
  const resolvedPath = template
    .replace(/\$\{([^}]+)\}/g, replaceValue)
    .replace(/\{\$([^}]+)\}/g, replaceValue)
    .trim();
  if (missing || !resolvedPath.length) {
    return { ready: false, path: null };
  }
  const segments = resolvedPath.split(".").filter(Boolean);
  if (segments.length === 0 || !segments[0]) {
    return { ready: false, path: null };
  }
  return { ready: true, path: resolvedPath };
}

export function extractDynamicDependencies(path: string): string[] {
  const patterns = [/\$\{([^}]+)\}/g, /\{\$([^}]+)\}/g];
  const deps = new Set<string>();
  for (const pattern of patterns) {
    let match;
    while ((match = pattern.exec(path)) !== null) {
      const cleaned = (match[1] || "").trim().replace(/^this\./, "");
      if (!cleaned) continue;
      const [root] = cleaned.split(".");
      if (root) deps.add(root);
    }
  }
  return Array.from(deps);
}
export function hasPath(obj: unknown): obj is { path: string } {
  return (
    typeof obj === "object" &&
    obj !== null &&
    "path" in obj &&
    typeof (obj as { path: unknown }).path === "string"
  );
}