import type { UsageStats } from "@/lib/types"; type UnknownRecord = Record<string, unknown>; function record(value: unknown): UnknownRecord {  return value && typeof value === "object" ? (value as UnknownRecord) : {};} function array(value: unknown): UnknownRecord[] {  return Array.isArray(value) ? value.map(record) : [];} function num(value: unknown, fallback = 0): number {  if (value === null || value === undefined || value === "") return fallback;  const parsed = Number(value);  return Number.isFinite(parsed) ? parsed : fallback;} function nullableNum(value: unknown): number | null {  if (value === null || value === undefined || value === "") return null;  const parsed = Number(value);  return Number.isFinite(parsed) ? parsed : null;} function text(value: unknown, fallback: string): string {  return typeof value === "string" && value.length > 0 ? value : fallback;} function normalizeControllerUsage(value: unknown): UsageStats["controller"] {  const controller = record(value);  if (Object.keys(controller).length === 0) return undefined;  const totals = record(controller.totals);  const latency = record(controller.latency);  const recent = record(controller.recent_activity);  const functionCalls = record(controller.function_calls);  const functionTotals = record(functionCalls.totals);  const functionLatency = record(functionCalls.latency);   return {    totals: {      total_requests: num(totals.total_requests),      successful_requests: num(totals.successful_requests),      failed_requests: num(totals.failed_requests),      success_rate: num(totals.success_rate),    },    latency: {      avg_ms: nullableNum(latency.avg_ms),      max_ms: nullableNum(latency.max_ms),    },    recent_activity: {      last_hour_requests: num(recent.last_hour_requests),      last_24h_requests: num(recent.last_24h_requests),      last_24h_failed_requests: num(recent.last_24h_failed_requests),    },    by_path: array(controller.by_path).map((path) => ({      method: text(path.method, ""),      path: text(path.path, ""),      requests: num(path.requests),      successful: num(path.successful),      failed: num(path.failed),      success_rate: num(path.success_rate),      avg_duration_ms: nullableNum(path.avg_duration_ms),      max_duration_ms: nullableNum(path.max_duration_ms),    })),    by_status: array(controller.by_status).map((status) => ({      status: num(status.status),      requests: num(status.requests),    })),    recent_errors: array(controller.recent_errors).map((error) => ({      method: text(error.method, ""),      path: text(error.path, ""),      status: num(error.status),      error_class: text(error.error_class, "") || null,      error_message: text(error.error_message, "") || null,      created_at: text(error.created_at, ""),    })),    function_calls:      Object.keys(functionCalls).length === 0        ? undefined        : {            totals: {              total_calls: num(functionTotals.total_calls),              successful_calls: num(functionTotals.successful_calls),              failed_calls: num(functionTotals.failed_calls),              success_rate: num(functionTotals.success_rate),            },            latency: {              avg_ms: nullableNum(functionLatency.avg_ms),              max_ms: nullableNum(functionLatency.max_ms),            },            by_function: array(functionCalls.by_function).map((entry) => ({              function_name: text(entry.function_name, ""),              calls: num(entry.calls),              successful: num(entry.successful),              failed: num(entry.failed),              success_rate: num(entry.success_rate),              avg_duration_ms: nullableNum(entry.avg_duration_ms),              max_duration_ms: nullableNum(entry.max_duration_ms),            })),            recent_errors: array(functionCalls.recent_errors).map((error) => ({              function_name: text(error.function_name, ""),              error_class: text(error.error_class, "") || null,              error_message: text(error.error_message, "") || null,              created_at: text(error.created_at, ""),            })),          },  };} export function normalizeUsageStats(input: UsageStats | null | undefined): UsageStats {  const s = record(input);  const totals = record(s.totals);  const latency = record(s.latency);  const ttft = record(s.ttft);  const tokensPerRequest = record(s.tokens_per_request);  const cache = record(s.cache);  const weekOverWeek = record(s.week_over_week);  const thisWeek = record(weekOverWeek.this_week);  const lastWeek = record(weekOverWeek.last_week);  const changePct = record(weekOverWeek.change_pct);  const recent = record(s.recent_activity);   return {    totals: {      total_tokens: num(totals.total_tokens),      prompt_tokens: num(totals.prompt_tokens),      completion_tokens: num(totals.completion_tokens),      total_requests: num(totals.total_requests),      successful_requests: num(totals.successful_requests),      failed_requests: num(totals.failed_requests),      success_rate: num(totals.success_rate),      unique_sessions: num(totals.unique_sessions),      unique_users: num(totals.unique_users),    },    latency: {      avg_ms: nullableNum(latency.avg_ms),      p50_ms: nullableNum(latency.p50_ms),      p95_ms: nullableNum(latency.p95_ms),      p99_ms: nullableNum(latency.p99_ms),      min_ms: nullableNum(latency.min_ms),      max_ms: nullableNum(latency.max_ms),    },    ttft: {      avg_ms: nullableNum(ttft.avg_ms),      p50_ms: nullableNum(ttft.p50_ms),      p95_ms: nullableNum(ttft.p95_ms),      p99_ms: nullableNum(ttft.p99_ms),    },    tokens_per_request: {      avg: num(tokensPerRequest.avg),      avg_prompt: num(tokensPerRequest.avg_prompt),      avg_completion: num(tokensPerRequest.avg_completion),      max: num(tokensPerRequest.max),      p50: num(tokensPerRequest.p50),      p95: num(tokensPerRequest.p95),    },    cache: {      hits: num(cache.hits),      misses: num(cache.misses),      hit_tokens: num(cache.hit_tokens),      miss_tokens: num(cache.miss_tokens),      hit_rate: num(cache.hit_rate),    },    week_over_week: {      this_week: {        requests: num(thisWeek.requests),        tokens: num(thisWeek.tokens),        successful: num(thisWeek.successful),      },      last_week: {        requests: num(lastWeek.requests),        tokens: num(lastWeek.tokens),        successful: num(lastWeek.successful),      },      change_pct: {        requests: nullableNum(changePct.requests),        tokens: nullableNum(changePct.tokens),      },    },    recent_activity: {      last_hour_requests: num(recent.last_hour_requests),      last_24h_requests: num(recent.last_24h_requests),      prev_24h_requests: num(recent.prev_24h_requests),      last_24h_tokens: num(recent.last_24h_tokens),      change_24h_pct: nullableNum(recent.change_24h_pct),    },    peak_days: array(s.peak_days).map((day) => ({      date: text(day.date, ""),      requests: num(day.requests),      tokens: num(day.tokens),    })),    peak_hours: array(s.peak_hours).map((hour) => ({      hour: num(hour.hour),      requests: num(hour.requests),    })),    by_model: array(s.by_model).map((model, index) => ({      model: text(model.model, `unknown-${index + 1}`),      requests: num(model.requests),      successful: num(model.successful),      success_rate: num(model.success_rate),      total_tokens: num(model.total_tokens),      prompt_tokens: num(model.prompt_tokens),      completion_tokens: num(model.completion_tokens),      avg_tokens: num(model.avg_tokens),      avg_latency_ms: nullableNum(model.avg_latency_ms),      p50_latency_ms: nullableNum(model.p50_latency_ms),      avg_ttft_ms: nullableNum(model.avg_ttft_ms),      tokens_per_sec: nullableNum(model.tokens_per_sec),      prefill_tps: nullableNum(model.prefill_tps),      generation_tps: nullableNum(model.generation_tps),    })),    daily: array(s.daily).map((day) => ({      date: text(day.date, ""),      requests: num(day.requests),      successful: num(day.successful),      success_rate: num(day.success_rate),      total_tokens: num(day.total_tokens),      prompt_tokens: num(day.prompt_tokens),      completion_tokens: num(day.completion_tokens),      avg_latency_ms: num(day.avg_latency_ms),    })),    daily_by_model: array(s.daily_by_model).map((day, index) => ({      date: text(day.date, ""),      model: text(day.model, `unknown-${index + 1}`),      requests: num(day.requests),      successful: num(day.successful),      success_rate: num(day.success_rate),      total_tokens: num(day.total_tokens),      prompt_tokens: num(day.prompt_tokens),      completion_tokens: num(day.completion_tokens),    })),    hourly_pattern: array(s.hourly_pattern).map((hour) => ({      hour: num(hour.hour),      requests: num(hour.requests),      successful: num(hour.successful),      tokens: num(hour.tokens),    })),    controller: normalizeControllerUsage(s.controller),  };}