import type {
  AiIndex,
  ApiEndpointDoc,
  ApiEnvelope,
  ClaimDTO,
  CloudRegionSummary,
  ConnectivityOverview,
  CoverageReport,
  DownloadDataset,
  EntityHistory,
  ExploreQuery,
  ExploreResponse,
  NearbyInfrastructure,
  OperatorComparison,
  PowerOverview,
  Pulse,
  SourceCoverage,
  TimeMachine,
  WatchlistItem,
  CountryDetail,
  CountrySummary,
  Dashboard,
  EventDTO,
  FacilityDetail,
  FacilityFilters,
  FacilitySummary,
  IxpSummary,
  MapResponse,
  MetroDetail,
  MetroSummary,
  OperatorDetail,
  OperatorSummary,
  ProjectDetail,
  ProjectSummary,
  Ranking,
  SearchResponse,
} from "@dci/core";
import type { CloudRegionDetail, IxpDetail, PipelineAggregates, SitemapEntry, SitemapKind, SourceDetail, SourceWithCounts } from "@/lib/dto";

/**
 * Typed API client over the v1 contract (packages/core/src/api-types.ts).
 * Server: `API_URL_INTERNAL ?? NEXT_PUBLIC_API_URL` + `/api/v1`. Client: `NEXT_PUBLIC_API_URL`.
 * `apiGet` NEVER throws — pages render skeletons/empty states from `{ ok:false }`.
 */

export const REVALIDATE = { dashboard: 60, list: 120, detail: 300, live: 30, map: 0 } as const;
export const TIMEOUT_MS = 8000;

export function serverApiBase(): string {
  const base = process.env.API_URL_INTERNAL ?? process.env.NEXT_PUBLIC_API_URL ?? "http://127.0.0.1:8311";
  return `${base.replace(/\/$/, "")}/api/v1`;
}

export function clientApiBase(): string {
  if (typeof window === "undefined") return serverApiBase();
  const base = process.env.NEXT_PUBLIC_API_URL ?? "";
  return `${base.replace(/\/$/, "")}/api/v1`;
}

export type ApiResult<T> = { ok: true; data: T; meta: ApiEnvelope<T>["meta"]; sources: ApiEnvelope<T>["sources"]; status: number } | { ok: false; data: null; meta?: undefined; sources?: undefined; error: string; status: number };

export type Query = Record<string, string | number | boolean | undefined | null>;

export function buildQuery(q?: Query): string {
  if (!q) return "";
  const sp = new URLSearchParams();
  for (const [k, v] of Object.entries(q)) {
    if (v === undefined || v === null || v === "" || v === false) continue;
    sp.set(k, v === true ? "1" : String(v));
  }
  const s = sp.toString();
  return s ? `?${s}` : "";
}

interface GetOptions {
  revalidate?: number;
  timeoutMs?: number;
  /** override the base (client hooks pass clientApiBase()) */
  base?: string;
  signal?: AbortSignal;
  tags?: string[];
}

export async function apiGet<T>(path: string, query?: Query, opts: GetOptions = {}): Promise<ApiResult<T>> {
  const base = opts.base ?? serverApiBase();
  const url = `${base}${path.startsWith("/") ? path : `/${path}`}${buildQuery(query)}`;
  const ctrl = new AbortController();
  const timer = setTimeout(() => ctrl.abort(new Error("timeout")), opts.timeoutMs ?? TIMEOUT_MS);
  if (opts.signal) opts.signal.addEventListener("abort", () => ctrl.abort(opts.signal?.reason), { once: true });
  try {
    const init: RequestInit & { next?: { revalidate?: number | false; tags?: string[] } } = {
      headers: { accept: "application/json" },
      signal: ctrl.signal,
    };
    if (typeof window === "undefined") {
      const rv = opts.revalidate ?? REVALIDATE.list;
      init.next = rv > 0 ? { revalidate: rv, tags: opts.tags } : { revalidate: 0 };
      if (rv === 0) init.cache = "no-store";
    }
    const res = await fetch(url, init);
    if (!res.ok) return { ok: false, data: null, error: `HTTP ${res.status}`, status: res.status };
    const json = (await res.json()) as ApiEnvelope<T> | T;
    if (json && typeof json === "object" && "data" in (json as object)) {
      const env = json as ApiEnvelope<T>;
      return { ok: true, data: env.data, meta: env.meta, sources: env.sources, status: res.status };
    }
    return { ok: true, data: json as T, meta: undefined, sources: undefined, status: res.status };
  } catch (e) {
    const msg = e instanceof Error ? (e.name === "AbortError" ? "timeout" : e.message) : "network error";
    return { ok: false, data: null, error: msg, status: 0 };
  } finally {
    clearTimeout(timer);
  }
}

/* ------------------------------------------------------------------ server helpers (typed) */

export interface Paged<T> {
  items: T[];
  total: number;
  page: number;
  perPage: number;
}

function paged<T>(r: ApiResult<T[] | { items: T[]; total?: number }>, fallbackPage = 1, fallbackPer = 50): Paged<T> {
  if (!r.ok || !r.data) return { items: [], total: 0, page: fallbackPage, perPage: fallbackPer };
  const items = Array.isArray(r.data) ? r.data : (r.data.items ?? []);
  const total = (r.meta?.total as number | undefined) ?? (Array.isArray(r.data) ? items.length : (r.data.total ?? items.length));
  return { items, total, page: (r.meta?.page as number | undefined) ?? fallbackPage, perPage: (r.meta?.perPage as number | undefined) ?? fallbackPer };
}

export const api = {
  health: () => apiGet<{ status: string }>("/health", undefined, { revalidate: 0, timeoutMs: 2500 }),
  dashboard: () => apiGet<Dashboard>("/dashboard", undefined, { revalidate: REVALIDATE.dashboard, tags: ["dashboard"] }),

  facilities: async (f: FacilityFilters) => {
    const r = await apiGet<FacilitySummary[] | { items: FacilitySummary[]; total?: number }>("/datacenters", f as Query, { revalidate: REVALIDATE.list });
    return { ...paged<FacilitySummary>(r, f.page ?? 1, f.per_page ?? 50), ok: r.ok, error: r.ok ? undefined : r.error };
  },
  facility: (slug: string) => apiGet<FacilityDetail>(`/datacenters/${encodeURIComponent(slug)}`, undefined, { revalidate: REVALIDATE.detail }),

  operators: async (q?: Query) => {
    const r = await apiGet<OperatorSummary[] | { items: OperatorSummary[]; total?: number }>("/operators", q, { revalidate: REVALIDATE.list });
    return paged<OperatorSummary>(r);
  },
  countries: async (q?: Query) => {
    const r = await apiGet<CountrySummary[] | { items: CountrySummary[]; total?: number }>("/countries", q, { revalidate: REVALIDATE.list });
    return paged<CountrySummary>(r);
  },
  metros: async (q?: Query) => {
    const r = await apiGet<MetroSummary[] | { items: MetroSummary[]; total?: number }>("/metros", q, { revalidate: REVALIDATE.list });
    return paged<MetroSummary>(r);
  },
  projects: async (q?: Query) => {
    const r = await apiGet<ProjectSummary[] | { items: ProjectSummary[]; total?: number }>("/projects", q, { revalidate: REVALIDATE.list });
    return paged<ProjectSummary>(r);
  },
  cloudRegions: async (q?: Query) => {
    const r = await apiGet<CloudRegionSummary[] | { items: CloudRegionSummary[]; total?: number }>("/cloud-regions", q, { revalidate: REVALIDATE.list });
    return paged<CloudRegionSummary>(r);
  },
  ixps: async (q?: Query) => {
    const r = await apiGet<IxpSummary[] | { items: IxpSummary[]; total?: number }>("/ixps", q, { revalidate: REVALIDATE.list });
    return paged<IxpSummary>(r);
  },

  rankings: async () => {
    const r = await apiGet<Ranking[]>("/rankings", undefined, { revalidate: REVALIDATE.list });
    return r.ok && Array.isArray(r.data) ? r.data : [];
  },
  ranking: (key: string, q?: Query) => apiGet<Ranking>(`/rankings/${encodeURIComponent(key)}`, q, { revalidate: REVALIDATE.list }),

  events: async (q?: Query) => {
    const r = await apiGet<EventDTO[] | { items: EventDTO[]; total?: number }>("/events", q, { revalidate: REVALIDATE.live });
    return { ...paged<EventDTO>(r, Number(q?.page ?? 1), Number(q?.per_page ?? 50)), ok: r.ok, error: r.ok ? undefined : r.error };
  },

  search: (q: string, extra?: Query) => apiGet<SearchResponse>("/search", { q, ...extra }, { revalidate: REVALIDATE.list }),

  map: (q: Query) => apiGet<MapResponse>("/map", q, { revalidate: REVALIDATE.map }),

  /* ---- entity details (facilities paginated with ?fPage on operator / country / metro) */
  operator: (slug: string, q?: Query) => apiGet<OperatorDetail>(`/operators/${encodeURIComponent(slug)}`, q, { revalidate: REVALIDATE.detail }),
  country: (slug: string, q?: Query) => apiGet<CountryDetail>(`/countries/${encodeURIComponent(slug)}`, q, { revalidate: REVALIDATE.detail }),
  metro: (slug: string, q?: Query) => apiGet<MetroDetail>(`/metros/${encodeURIComponent(slug)}`, q, { revalidate: REVALIDATE.detail }),
  project: (slug: string) => apiGet<ProjectDetail>(`/projects/${encodeURIComponent(slug)}`, undefined, { revalidate: REVALIDATE.detail }),
  projectPipeline: () => apiGet<PipelineAggregates>("/projects/pipeline", undefined, { revalidate: REVALIDATE.list }),
  cloudRegion: (slug: string) => apiGet<CloudRegionDetail>(`/cloud-regions/${encodeURIComponent(slug)}`, undefined, { revalidate: REVALIDATE.detail }),
  ixp: (slug: string) => apiGet<IxpDetail>(`/ixps/${encodeURIComponent(slug)}`, undefined, { revalidate: REVALIDATE.detail }),
  sources: async (q?: Query) => {
    const r = await apiGet<SourceWithCounts[] | { items: SourceWithCounts[]; total?: number }>("/sources", q, { revalidate: REVALIDATE.list });
    return paged<SourceWithCounts>(r);
  },
  source: (id: string) => apiGet<SourceDetail>(`/sources/${encodeURIComponent(id)}`, undefined, { revalidate: REVALIDATE.detail }),
  sitemap: (kind: SitemapKind, page = 1) => apiGet<SitemapEntry[]>(`/sitemap/${kind}`, { page }, { revalidate: 600 }),

  /* ---- API 2.0 (2026-09-12): evidence, history, graph, intelligence */
  facilityHistory: (slug: string) => apiGet<EntityHistory>(`/datacenters/${encodeURIComponent(slug)}/history`, undefined, { revalidate: REVALIDATE.detail }),
  facilityClaims: (slug: string) => apiGet<ClaimDTO[]>(`/datacenters/${encodeURIComponent(slug)}/claims`, undefined, { revalidate: REVALIDATE.detail }),
  projectHistory: (slug: string) => apiGet<EntityHistory>(`/projects/${encodeURIComponent(slug)}/history`, undefined, { revalidate: REVALIDATE.detail }),
  projectClaims: (slug: string) => apiGet<ClaimDTO[]>(`/projects/${encodeURIComponent(slug)}/claims`, undefined, { revalidate: REVALIDATE.detail }),
  nearby: (q: { lat: number; lng: number; radius_km?: number; types?: string }) => apiGet<NearbyInfrastructure>("/nearby", q, { revalidate: REVALIDATE.detail }),
  pulse: (window: "24h" | "7d" | "30d" = "7d") => apiGet<Pulse>("/pulse", { window }, { revalidate: REVALIDATE.dashboard, tags: ["pulse"] }),
  compareOperators: (slugs: string[]) => apiGet<OperatorComparison>("/compare/operators", { slugs: slugs.join(",") }, { revalidate: REVALIDATE.list }),
  explore: (q: ExploreQuery) => apiGet<ExploreResponse>("/explore", q as Query, { revalidate: REVALIDATE.list }),
  coverage: () => apiGet<CoverageReport>("/coverage", undefined, { revalidate: REVALIDATE.list }),
  coverageSources: () => apiGet<SourceCoverage[]>("/coverage/sources", undefined, { revalidate: REVALIDATE.list }),
  aiIndex: () => apiGet<AiIndex>("/ai-infrastructure", undefined, { revalidate: REVALIDATE.list }),
  power: () => apiGet<PowerOverview>("/power", undefined, { revalidate: REVALIDATE.list }),
  connectivity: () => apiGet<ConnectivityOverview>("/connectivity", undefined, { revalidate: REVALIDATE.list }),
  timeMachine: () => apiGet<TimeMachine>("/time-machine", undefined, { revalidate: REVALIDATE.list }),
  downloadDatasets: () => apiGet<DownloadDataset[]>("/download/datasets", undefined, { revalidate: REVALIDATE.list }),
  docsMeta: () => apiGet<ApiEndpointDoc[]>("/docs-meta", undefined, { revalidate: 600 }),
  watchlist: () => apiGet<WatchlistItem[]>("/watchlist", undefined, { revalidate: 0 }),
  watchlistFeed: (q?: Query) => apiGet<EventDTO[]>("/watchlist/feed", q, { revalidate: 0 }),
};

/** Event-list query for /live and the home module. */
export interface EventQuery {
  type?: string;
  country?: string;
  operator?: string;
  min_significance?: number;
  since?: string;
  page?: number;
  per_page?: number;
}