import type {
  CompatibilityReport,
  ConfigData,
  GPU,
  Metrics,
  ProcessInfo,
  UsageStats,
  VRAMCalculation,
} from "../types";
import { encodePathSegments, type ApiCore, type RequestOptions } from "./core";

const MB = 1024 * 1024;
const GPU_BOOLEAN_KEYS = [
  "memory_shared",
  "memory_usage_available",
  "utilization_available",
  "temperature_available",
  "power_available",
] as const;

function finiteNumber(value: unknown): number | null {
  return typeof value === "number" && Number.isFinite(value) ? value : null;
}

function legacyMb(value: unknown): number | null {
  const bytes = finiteNumber(value);
  return bytes !== null && bytes > 0 ? bytes / MB : null;
}

function assignGpuMetadata(gpu: GPU, raw: Record<string, unknown>): void {
  if (typeof raw["id"] === "string") gpu.id = raw["id"];
  const powerDraw = finiteNumber(raw["power_draw"]);
  if (powerDraw !== null) gpu.power_draw = powerDraw;
  const powerLimit = finiteNumber(raw["power_limit"]);
  if (powerLimit !== null) gpu.power_limit = powerLimit;
  for (const key of GPU_BOOLEAN_KEYS) {
    const value = raw[key];
    if (typeof value === "boolean") gpu[key] = value;
  }
}

export function normalizeGpuAliases(list: unknown): GPU[] {
  if (!Array.isArray(list)) return [];
  const gpus: GPU[] = [];
  for (const entry of list) {
    if (!entry || typeof entry !== "object") continue;
    const raw = entry as Record<string, unknown>;
    const gpu: GPU = {
      index: finiteNumber(raw["index"]) ?? 0,
      name: typeof raw["name"] === "string" ? raw["name"] : "GPU",
      memory_total_mb: finiteNumber(raw["memory_total_mb"]) ?? legacyMb(raw["memory_total"]) ?? 0,
      memory_used_mb: finiteNumber(raw["memory_used_mb"]) ?? legacyMb(raw["memory_used"]) ?? 0,
      memory_free_mb: finiteNumber(raw["memory_free_mb"]) ?? legacyMb(raw["memory_free"]) ?? 0,
      utilization_pct:
        finiteNumber(raw["utilization_pct"]) ?? finiteNumber(raw["utilization"]) ?? 0,
      temp_c: finiteNumber(raw["temp_c"]) ?? finiteNumber(raw["temperature"]) ?? 0,
    };
    assignGpuMetadata(gpu, raw);
    gpus.push(gpu);
  }
  return gpus;
}

export function createSystemApi(core: ApiCore) {
  return {
    launch: (recipeId: string): Promise<{ success: boolean; pid?: number; message: string }> =>
      core.request(`/launch/${encodePathSegments(recipeId)}`, {
        method: "POST",
        timeout: 360_000,
        retries: 0,
      }),

    evict: (): Promise<{ success: boolean; evicted_pid?: number }> =>
      core.request("/evict", { method: "POST" }),

    waitReady: (timeout = 300): Promise<{ ready: boolean; elapsed: number; error?: string }> =>
      core.request(`/wait-ready?timeout=${timeout}`, {
        timeout: (timeout + 15) * 1000,
        retries: 0,
      }),

    getOpenAIModels: (): Promise<{
      data: Array<{ id: string; root?: string; max_model_len?: number }>;
    }> => core.request("/v1/models"),

    tokenizeChatCompletions: (data: {
      model: string;
      messages: Record<string, unknown>[];
      tools?: Record<string, unknown>[];
    }): Promise<{ input_tokens?: number; breakdown?: { messages?: number; tools?: number } }> =>
      core.request("/v1/tokenize-chat-completions", {
        method: "POST",
        body: JSON.stringify(data),
      }),

    countTextTokens: (data: { model: string; text: string }): Promise<{ num_tokens?: number }> =>
      core.request("/v1/count-tokens", { method: "POST", body: JSON.stringify(data) }),

    getGPUs: async (options?: RequestOptions): Promise<{ gpus: GPU[] }> => {
      const payload = await core.request<{ gpus?: unknown }>("/gpus", options);
      return { gpus: normalizeGpuAliases(payload.gpus) };
    },

    calculateVRAM: (data: {
      model: string;
      context_length: number;
      tp_size: number;
      kv_dtype: string;
    }): Promise<VRAMCalculation> =>
      core.request("/vram-calculator", { method: "POST", body: JSON.stringify(data) }),

    getMetrics: (): Promise<Metrics> => core.request("/v1/metrics/vllm"),

    runBenchmark: (
      promptTokens = 1000,
    ): Promise<{
      success?: boolean;
      error?: string;
      model_id?: string;
      benchmark?: {
        prompt_tokens: number;
        completion_tokens: number;
        total_time_s: number;
        prefill_tps: number;
        generation_tps: number;
        ttft_ms: number;
      };
      peak_metrics?: {
        prefill_tps: number;
        generation_tps: number;
        ttft_ms: number;
        total_tokens: number;
        total_requests: number;
      };
    }> =>
      core.request(`/benchmark?prompt_tokens=${promptTokens}`, {
        method: "POST",
      }),

    getPeakMetrics: (): Promise<{
      metrics?: Array<{
        model_id: string;
        prefill_tps: number;
        generation_tps: number;
        ttft_ms: number;
        best_session_id?: string | null;
        best_session_prefill_tps?: number | null;
        best_session_generation_tps?: number | null;
        best_session_ttft_ms?: number | null;
        total_tokens: number;
        total_requests: number;
      }>;
      error?: string;
    }> => core.request("/peak-metrics", { retries: 0 }),

    getUsageStats: (): Promise<UsageStats> => core.request("/usage", { retries: 0 }),

    getStatus: async (
      options?: RequestOptions,
    ): Promise<{
      running: boolean;
      process: ProcessInfo | null;
      inference_port: number;
      launching: string | null;
    }> => {
      const data = await core.request<{
        running: boolean;
        process: ProcessInfo | null;
        inference_port: number;
        launching?: string | null;
      }>("/status", options);

      return {
        running: data.running ?? !!data.process,
        process: data.process ?? null,
        inference_port: data.inference_port || 8000,
        launching: typeof data.launching === "string" && data.launching ? data.launching : null,
      };
    },

    getSystemConfig: (options?: RequestOptions): Promise<ConfigData> =>
      core.request("/config", options),

    getCompatibility: (options?: RequestOptions): Promise<CompatibilityReport> =>
      core.request("/compat", options),
  };
}