import type { HttpClient } from "@market-atlas/connector-sdk";
import { redactUrl, schemaFingerprint } from "@market-atlas/connector-sdk";

/**
 * Discovery prototype (network-level, no browser yet): fetches a public page unauthenticated,
 * inventories the data endpoints it references (JSON/XHR URLs, WebSocket URLs, SSE, embedded
 * JSON state such as __NEXT_DATA__), and scores which ones look like market-data feeds.
 * Output is a *candidate* report for the rights-review workflow — never an activated connector.
 */
export interface DiscoveryReport {
  url: string;
  status: number;
  content_type: string | null;
  bytes: number;
  websocket_urls: string[];
  sse_urls: string[];
  json_endpoints: Array<{ url: string; score: number; hints: string[] }>;
  embedded_state: Array<{ kind: string; fingerprint: string; price_like_fields: string[]; symbol_like_fields: string[]; sample_keys: string[] }>;
  instrument_hints: string[];
  notes: string[];
}

const PRICE_KEYS = /^(last|lastprice|last_price|price|lp|px|close|c|regularmarketprice|current_price|bid|ask|mid|value|rate)$/i;
const SYMBOL_KEYS = /^(symbol|sym|ticker|s|code|instrument|isin|pair|product_id|instid)$/i;
const TS_KEYS = /^(ts|t|time|timestamp|datetime|eventtime|updated|last_trade_time)$/i;

export async function runDiscovery(url: string, http: HttpClient): Promise<DiscoveryReport> {
  const res = await http.getText(url, { timeoutMs: 20_000, conditional: false, headers: { accept: "text/html,application/json;q=0.9,*/*;q=0.8" } });
  const html = res.text;
  const notes: string[] = [];
  const wsUrls = uniq([...html.matchAll(/wss?:\/\/[^\s"'<>\\)]+/g)].map((m) => redactUrl(m[0])));
  const sse = uniq([...html.matchAll(/EventSource\((["'`])([^"'`]+)\1/g)].map((m) => m[2]!));
  const urls = uniq([...html.matchAll(/https?:\/\/[^\s"'<>\\)]+/g)].map((m) => m[0]))
    .filter((u) => /api|quote|price|market|ticker|chart|data|feed|graphql|json|v\d\//i.test(u) && !/\.(png|jpg|jpeg|gif|svg|css|woff2?|ico)(\?|$)/i.test(u))
    .map((u) => redactUrl(u));
  const jsonEndpoints = urls
    .map((u) => {
      const hints: string[] = [];
      let score = 0;
      if (/quote|price|ticker|last/i.test(u)) (score += 40), hints.push("quote/price keyword");
      if (/graphql/i.test(u)) (score += 20), hints.push("GraphQL");
      if (/\.json(\?|$)|format=json/i.test(u)) (score += 15), hints.push("JSON");
      if (/api\.|\/api\//i.test(u)) (score += 15), hints.push("API path");
      if (/chart|history|candles|bars/i.test(u)) (score += 10), hints.push("historical/chart");
      if (/symbol=|ticker=|sym=/i.test(u)) (score += 20), hints.push("symbol parameter");
      return { url: u, score, hints };
    })
    .filter((e) => e.score > 0)
    .sort((a, b) => b.score - a.score)
    .slice(0, 40);

  const embedded: DiscoveryReport["embedded_state"] = [];
  const stateBlocks: Array<[string, RegExp]> = [
    ["__NEXT_DATA__", /<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/i],
    ["__NUXT__", /window\.__NUXT__\s*=\s*([\s\S]*?);\s*<\/script>/i],
    ["__INITIAL_STATE__", /window\.__INITIAL_STATE__\s*=\s*([\s\S]*?);\s*<\/script>/i],
    ["__PRELOADED_STATE__", /window\.__PRELOADED_STATE__\s*=\s*([\s\S]*?);\s*<\/script>/i],
    ["ld+json", /<script type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/i],
  ];
  for (const [kind, re] of stateBlocks) {
    const m = html.match(re);
    if (!m?.[1]) continue;
    try {
      const obj = JSON.parse(m[1]);
      const keys = new Set<string>();
      const priceLike = new Set<string>();
      const symbolLike = new Set<string>();
      walk(obj, "", 0, (path, key, val) => {
        keys.add(key);
        if (PRICE_KEYS.test(key) && (typeof val === "number" || (typeof val === "string" && /^-?\d+(\.\d+)?$/.test(val)))) priceLike.add(path);
        if (SYMBOL_KEYS.test(key) && typeof val === "string") symbolLike.add(path);
      });
      embedded.push({ kind, fingerprint: schemaFingerprint(obj), price_like_fields: [...priceLike].slice(0, 20), symbol_like_fields: [...symbolLike].slice(0, 20), sample_keys: [...keys].slice(0, 60) });
    } catch {
      notes.push(`${kind} block present but not parseable as JSON`);
    }
  }
  if (res.headers["content-type"]?.includes("application/json")) {
    try {
      const obj = JSON.parse(html);
      const priceLike = new Set<string>();
      const symbolLike = new Set<string>();
      const tsLike = new Set<string>();
      walk(obj, "", 0, (path, key, val) => {
        if (PRICE_KEYS.test(key) && typeof val !== "object") priceLike.add(path);
        if (SYMBOL_KEYS.test(key) && typeof val === "string") symbolLike.add(path);
        if (TS_KEYS.test(key)) tsLike.add(path);
      });
      embedded.push({ kind: "response-json", fingerprint: schemaFingerprint(obj), price_like_fields: [...priceLike], symbol_like_fields: [...symbolLike], sample_keys: [...tsLike].map((t) => `ts:${t}`) });
      notes.push("URL returns JSON directly — candidate XHR/FETCH connector");
    } catch {
      /* ignore */
    }
  }
  const instrumentHints = uniq([...html.matchAll(/\b(?:NASDAQ|NYSE|TSX|LSE|XETRA|BINANCE|COINBASE):([A-Z.\-]{1,12})\b/g)].map((m) => m[0])).slice(0, 20);
  if (wsUrls.length) notes.push("WebSocket endpoints referenced — verify subscription protocol and terms before use");
  if (!wsUrls.length && !jsonEndpoints.length && !embedded.length) notes.push("No data endpoints found statically; the page may load data via bundled JavaScript (browser-based discovery required)");
  notes.push("Rights status must be classified manually (RIGHTS_REVIEW) before any connector reaches staging.");
  return {
    url: redactUrl(url),
    status: res.status,
    content_type: res.headers["content-type"] ?? null,
    bytes: html.length,
    websocket_urls: wsUrls,
    sse_urls: sse,
    json_endpoints: jsonEndpoints,
    embedded_state: embedded,
    instrument_hints: instrumentHints,
    notes,
  };
}

function walk(v: unknown, path: string, depth: number, fn: (path: string, key: string, val: unknown) => void) {
  if (depth > 8 || v == null) return;
  if (Array.isArray(v)) {
    for (const item of v.slice(0, 5)) walk(item, `${path}[]`, depth + 1, fn);
    return;
  }
  if (typeof v === "object") {
    for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
      const p = path ? `${path}.${k}` : k;
      fn(p, k, val);
      walk(val, p, depth + 1, fn);
    }
  }
}

const uniq = <T>(xs: T[]) => [...new Set(xs)];