import type { ControllerUsageStatsSchema, UsageStatsSchema } from "./usage-schema";

type UnknownRecord = Record<string, unknown>;

const objectOrEmpty = (value: unknown): UnknownRecord =>
  value !== null && typeof value === "object" && !Array.isArray(value)
    ? (value as UnknownRecord)
    : {};

const nonEmptyObject = (value: unknown): UnknownRecord | undefined => {
  const object = objectOrEmpty(value);
  return Object.keys(object).length > 0 ? object : undefined;
};

const rows = (value: unknown): UnknownRecord[] =>
  Array.isArray(value) ? value.map(objectOrEmpty) : [];

const finiteNumber = (value: unknown, fallback = 0): number => {
  try {
    const number = Number(value);
    return Number.isFinite(number) ? number : fallback;
  } catch {
    return fallback;
  }
};

const nullableNumber = (value: unknown): number | null => {
  if (value === null || value === undefined || value === "") return null;
  const number = finiteNumber(value, NaN);
  return Number.isFinite(number) ? number : null;
};

const stringValue = (value: unknown, fallback = ""): string =>
  typeof value === "string" && value.length > 0 ? value : fallback;

const nullableString = (value: unknown): string | null => stringValue(value) || null;

const fields = <const Key extends string, Value>(
  source: UnknownRecord,
  keys: readonly Key[],
  decode: (value: unknown) => Value,
): Record<Key, Value> =>
  Object.fromEntries(keys.map((key) => [key, decode(source[key])])) as Record<Key, Value>;

const numbers = <const Key extends string>(
  source: UnknownRecord,
  keys: readonly Key[],
): Record<Key, number> => fields(source, keys, finiteNumber);

const nullableNumbers = <const Key extends string>(
  source: UnknownRecord,
  keys: readonly Key[],
): Record<Key, number | null> => fields(source, keys, nullableNumber);

const strings = <const Key extends string>(
  source: UnknownRecord,
  keys: readonly Key[],
): Record<Key, string> => fields(source, keys, stringValue);

const projector = <Output>(decode: (value: unknown) => Output): ((value: unknown) => Output) =>
  decode;

export const normalizeControllerUsage = projector((value) => {
  const controller = nonEmptyObject(value);
  if (!controller) return undefined;
  const totals = objectOrEmpty(controller["totals"]);
  const latency = objectOrEmpty(controller["latency"]);
  const recent = objectOrEmpty(controller["recent_activity"]);
  const functionCalls = nonEmptyObject(controller["function_calls"]);

  return {
    totals: numbers(totals, [
      "total_requests",
      "successful_requests",
      "failed_requests",
      "success_rate",
    ]),
    latency: nullableNumbers(latency, ["avg_ms", "max_ms"]),
    recent_activity: numbers(recent, [
      "last_hour_requests",
      "last_24h_requests",
      "last_24h_failed_requests",
    ]),
    by_path: rows(controller["by_path"]).map((path) => ({
      ...strings(path, ["method", "path"]),
      ...numbers(path, ["requests", "successful", "failed", "success_rate"]),
      ...nullableNumbers(path, ["avg_duration_ms", "max_duration_ms"]),
    })),
    by_status: rows(controller["by_status"]).map((status) =>
      numbers(status, ["status", "requests"]),
    ),
    recent_errors: rows(controller["recent_errors"]).map((error) => ({
      ...strings(error, ["method", "path"]),
      status: finiteNumber(error["status"]),
      error_class: nullableString(error["error_class"]),
      error_message: nullableString(error["error_message"]),
      created_at: stringValue(error["created_at"]),
    })),
    ...(functionCalls
      ? {
          function_calls: {
            totals: numbers(objectOrEmpty(functionCalls["totals"]), [
              "total_calls",
              "successful_calls",
              "failed_calls",
              "success_rate",
            ]),
            latency: nullableNumbers(objectOrEmpty(functionCalls["latency"]), ["avg_ms", "max_ms"]),
            by_function: rows(functionCalls["by_function"]).map((entry) => ({
              function_name: stringValue(entry["function_name"]),
              ...numbers(entry, ["calls", "successful", "failed", "success_rate"]),
              ...nullableNumbers(entry, ["avg_duration_ms", "max_duration_ms"]),
            })),
            recent_errors: rows(functionCalls["recent_errors"]).map((error) => ({
              function_name: stringValue(error["function_name"]),
              error_class: nullableString(error["error_class"]),
              error_message: nullableString(error["error_message"]),
              created_at: stringValue(error["created_at"]),
            })),
          },
        }
      : {}),
  };
});

export const normalizeUsageStats = projector((input) => {
  const usage = objectOrEmpty(input);
  const weekOverWeek = objectOrEmpty(usage["week_over_week"]);
  const recent = objectOrEmpty(usage["recent_activity"]);
  const controller = normalizeControllerUsage(usage["controller"]);

  return {
    totals: numbers(objectOrEmpty(usage["totals"]), [
      "total_tokens",
      "prompt_tokens",
      "completion_tokens",
      "total_requests",
      "successful_requests",
      "failed_requests",
      "success_rate",
      "unique_sessions",
      "unique_users",
    ]),
    latency: nullableNumbers(objectOrEmpty(usage["latency"]), [
      "avg_ms",
      "p50_ms",
      "p95_ms",
      "p99_ms",
      "min_ms",
      "max_ms",
    ]),
    ttft: nullableNumbers(objectOrEmpty(usage["ttft"]), ["avg_ms", "p50_ms", "p95_ms", "p99_ms"]),
    tokens_per_request: numbers(objectOrEmpty(usage["tokens_per_request"]), [
      "avg",
      "avg_prompt",
      "avg_completion",
      "max",
      "p50",
      "p95",
    ]),
    cache: numbers(objectOrEmpty(usage["cache"]), [
      "hits",
      "misses",
      "hit_tokens",
      "miss_tokens",
      "hit_rate",
    ]),
    week_over_week: {
      this_week: numbers(objectOrEmpty(weekOverWeek["this_week"]), [
        "requests",
        "tokens",
        "successful",
      ]),
      last_week: numbers(objectOrEmpty(weekOverWeek["last_week"]), [
        "requests",
        "tokens",
        "successful",
      ]),
      change_pct: nullableNumbers(objectOrEmpty(weekOverWeek["change_pct"]), [
        "requests",
        "tokens",
      ]),
    },
    recent_activity: {
      ...numbers(recent, [
        "last_hour_requests",
        "last_24h_requests",
        "prev_24h_requests",
        "last_24h_tokens",
      ]),
      change_24h_pct: nullableNumber(recent["change_24h_pct"]),
    },
    peak_days: rows(usage["peak_days"]).map((day) => ({
      date: stringValue(day["date"]),
      ...numbers(day, ["requests", "tokens"]),
    })),
    peak_hours: rows(usage["peak_hours"]).map((hour) => numbers(hour, ["hour", "requests"])),
    by_model: rows(usage["by_model"]).map((model, index) => ({
      model: stringValue(model["model"], `unknown-${index + 1}`),
      ...numbers(model, [
        "requests",
        "successful",
        "success_rate",
        "total_tokens",
        "prompt_tokens",
        "completion_tokens",
        "avg_tokens",
      ]),
      ...nullableNumbers(model, [
        "avg_latency_ms",
        "p50_latency_ms",
        "avg_ttft_ms",
        "tokens_per_sec",
        "prefill_tps",
        "generation_tps",
      ]),
    })),
    daily: rows(usage["daily"]).map((day) => ({
      date: stringValue(day["date"]),
      ...numbers(day, [
        "requests",
        "successful",
        "success_rate",
        "total_tokens",
        "prompt_tokens",
        "completion_tokens",
        "avg_latency_ms",
      ]),
    })),
    daily_by_model: rows(usage["daily_by_model"]).map((day, index) => ({
      date: stringValue(day["date"]),
      model: stringValue(day["model"], `unknown-${index + 1}`),
      ...numbers(day, [
        "requests",
        "successful",
        "success_rate",
        "total_tokens",
        "prompt_tokens",
        "completion_tokens",
      ]),
    })),
    hourly_pattern: rows(usage["hourly_pattern"]).map((hour) =>
      numbers(hour, ["hour", "requests", "successful", "tokens"]),
    ),
    ...(controller ? { controller } : {}),
  };
});

export type ControllerUsageStats = typeof ControllerUsageStatsSchema.Type;
export type UsageStats = typeof UsageStatsSchema.Type;

export const usageRate = (successful: unknown, total: unknown): number => {
  const count = finiteNumber(total);
  return count ? (finiteNumber(successful) / count) * 100 : 0;
};

export const usageAverage = (value: unknown, total: unknown): number => {
  const count = finiteNumber(total);
  return count ? Math.round(finiteNumber(value) / count) : 0;
};