import { sanitizeErrorMessage } from "../utils/error.ts";

type JsonRecord = Record<string, unknown>;
type UsageQuota = {
  used: number;
  total: number;
  remaining?: number;
  remainingPercentage?: number;
  resetAt: string | null;
  unlimited: boolean;
  displayName?: string;
  details?: Array<{ name: string; used: number }>;
  currency?: string;
};

const OPENCODE_GO_QUOTA_URL =
  process.env.OMNIROUTE_OPENCODE_GO_QUOTA_URL ?? "https://api.z.ai/api/monitor/usage/quota/limit";
const OPENCODE_GO_DASHBOARD_BASE_URL =
  process.env.OMNIROUTE_OPENCODE_GO_DASHBOARD_URL ?? "https://opencode.ai/workspace";
const OPENCODE_GO_QUOTA_TOTALS = { session: 12, weekly: 30, mcp_monthly: 60 } as const;
const OPENCODE_GO_QUOTA_ORDER = ["session", "weekly", "mcp_monthly"] as const;
const OPENCODE_GO_SCRAPED_NUMBER = String.raw`(-?\d+(?:\.\d+)?)`;
const OLLAMA_CLOUD_USAGE_URL =
  process.env.OMNIROUTE_OLLAMA_CLOUD_USAGE_URL ?? "https://ollama.com/settings";
const OLLAMA_CLOUD_SESSION_COOKIE = "__Secure-session";

type OpenCodeGoQuotaName = (typeof OPENCODE_GO_QUOTA_ORDER)[number];
type DashboardWindow = { usagePercent: number; resetAt: string | null };
type OpenCodeGoDashboardUsage = Partial<Record<OpenCodeGoQuotaName, DashboardWindow>>;
type OpenCodeGoDashboardConfig =
  | { state: "configured"; workspaceId: string; authCookie: string }
  | { state: "incomplete"; missing: string }
  | { state: "none" };
type OllamaCloudUsage = {
  session?: DashboardWindow;
  weekly?: DashboardWindow;
  planTier?: string | null;
};
type OllamaCloudConfig =
  | { state: "configured"; cookie: string }
  | { state: "invalid"; error: string }
  | { state: "none" };

function toRecord(value: unknown): JsonRecord {
  return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonRecord) : {};
}

function toNumber(value: unknown, fallback = 0): number {
  const parsed =
    typeof value === "number"
      ? value
      : typeof value === "string" && value.trim().length > 0
        ? Number(value)
        : Number.NaN;
  return Number.isFinite(parsed) ? parsed : fallback;
}

function toPercentage(value: unknown): number {
  return Math.max(0, Math.min(100, toNumber(value, 0)));
}

function toTitleCase(value: string): string {
  return value
    .trim()
    .split(/[\s_-]+/)
    .filter(Boolean)
    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
    .join(" ");
}

function roundCurrency(value: number): number {
  return Math.round(value * 100) / 100;
}

function safeToIsoString(time: number): string | null {
  if (!Number.isFinite(time) || time < 0 || time > 8.64e15) return null;
  try {
    return new Date(time).toISOString();
  } catch {
    return null;
  }
}

function parseResetTime(resetValue: unknown): string | null {
  const numeric = toNumber(resetValue, Number.NaN);
  if (Number.isFinite(numeric) && numeric > 0) return safeToIsoString(numeric);
  if (typeof resetValue !== "string" || !resetValue.trim()) return null;
  const parsed = Date.parse(resetValue);
  return Number.isFinite(parsed) ? safeToIsoString(parsed) : null;
}

function getProviderSpecificString(data: JsonRecord | undefined, keys: string[]): string {
  const obj = toRecord(data);
  for (const key of keys) {
    const value = obj[key];
    if (typeof value === "string" && value.trim()) return value.trim();
  }
  return "";
}

function resolveOpenCodeGoDashboardConfig(
  providerSpecificData?: JsonRecord
): OpenCodeGoDashboardConfig {
  const workspaceId =
    process.env.OMNIROUTE_OPENCODE_GO_WORKSPACE_ID?.trim() ||
    process.env.OPENCODE_GO_WORKSPACE_ID?.trim() ||
    getProviderSpecificString(providerSpecificData, [
      "openCodeGoWorkspaceId",
      "opencodeGoWorkspaceId",
      "workspaceId",
    ]);
  const authCookie =
    process.env.OMNIROUTE_OPENCODE_GO_AUTH_COOKIE?.trim() ||
    process.env.OPENCODE_GO_AUTH_COOKIE?.trim() ||
    getProviderSpecificString(providerSpecificData, [
      "openCodeGoAuthCookie",
      "opencodeGoAuthCookie",
      "authCookie",
    ]);

  if (!workspaceId && !authCookie) return { state: "none" };
  if (workspaceId && authCookie) return { state: "configured", workspaceId, authCookie };
  return {
    state: "incomplete",
    missing: workspaceId ? "OPENCODE_GO_AUTH_COOKIE" : "OPENCODE_GO_WORKSPACE_ID",
  };
}

function normalizeOpenCodeGoAuthCookie(value: string): string {
  return value
    .trim()
    .replace(/^auth=/i, "")
    .trim();
}

function buildBearerAuthorization(value: string): string {
  const token = value
    .trim()
    .replace(/^Bearer\s+/i, "")
    .trim();
  return token ? `Bearer ${token}` : "";
}

function getOpenCodeGoTokenQuotaName(
  limit: JsonRecord,
  existingQuotas: Record<string, UsageQuota>
): "session" | "weekly" {
  const unit = toNumber(limit.unit, 0);
  const number = toNumber(limit.number, 0);
  if (unit === 3 && number === 5) return "session";
  if (unit === 6 && number === 1) return "weekly";
  if ((unit === 4 && number === 7) || (unit === 3 && number >= 24 * 7)) return "weekly";
  return existingQuotas.session ? "weekly" : "session";
}

function buildOpenCodeGoDollarQuota(
  quotaName: OpenCodeGoQuotaName,
  percentage: unknown,
  resetAt: string | null,
  usedOverride?: unknown,
  details?: UsageQuota["details"]
): UsageQuota {
  const total = OPENCODE_GO_QUOTA_TOTALS[quotaName];
  const percentUsed = toPercentage(percentage);
  const rawUsed = toNumber(usedOverride, Number.NaN);
  const used = roundCurrency(
    Number.isFinite(rawUsed) ? Math.max(0, Math.min(total, rawUsed)) : (total * percentUsed) / 100
  );
  const remaining = roundCurrency(Math.max(0, total - used));
  return {
    used,
    total,
    remaining,
    remainingPercentage:
      total > 0 ? Math.max(0, Math.min(100, Math.round((remaining / total) * 100))) : 100,
    resetAt,
    unlimited: false,
    displayName:
      quotaName === "session" ? "5-hour rolling" : quotaName === "weekly" ? "Weekly" : "Monthly",
    currency: "USD",
    details,
  };
}

function orderOpenCodeGoQuotas(quotas: Record<string, UsageQuota>): Record<string, UsageQuota> {
  const ordered: Record<string, UsageQuota> = {};
  for (const key of OPENCODE_GO_QUOTA_ORDER) if (quotas[key]) ordered[key] = quotas[key];
  for (const [key, quota] of Object.entries(quotas)) if (!ordered[key]) ordered[key] = quota;
  return ordered;
}

function parseOpenCodeGoSsrWindow(html: string, field: string): DashboardWindow | null {
  for (const candidate of [
    {
      usageIndex: 1,
      resetIndex: 2,
      pattern: String.raw`${field}:\$R\[\d+\]=\{[^}]*usagePercent:${OPENCODE_GO_SCRAPED_NUMBER}[^}]*resetInSec:${OPENCODE_GO_SCRAPED_NUMBER}[^}]*\}`,
    },
    {
      usageIndex: 2,
      resetIndex: 1,
      pattern: String.raw`${field}:\$R\[\d+\]=\{[^}]*resetInSec:${OPENCODE_GO_SCRAPED_NUMBER}[^}]*usagePercent:${OPENCODE_GO_SCRAPED_NUMBER}[^}]*\}`,
    },
  ]) {
    const match = new RegExp(candidate.pattern).exec(html);
    if (!match) continue;
    const usagePercent = toNumber(match[candidate.usageIndex], Number.NaN);
    const resetInSec = toNumber(match[candidate.resetIndex], Number.NaN);
    if (Number.isFinite(usagePercent) && Number.isFinite(resetInSec)) {
      return {
        usagePercent,
        resetAt: safeToIsoString(Date.now() + Math.max(0, resetInSec) * 1000),
      };
    }
  }
  return null;
}

function parseOpenCodeGoHumanReset(value: string): number | null {
  const text = value.toLowerCase().replace(/\s+/g, " ").trim();
  if (["reset-now", "reset now", "now", "resets now"].includes(text)) return 0;
  const days = text.match(/(\d+(?:\.\d+)?)\s*days?/);
  const hours = text.match(/(\d+(?:\.\d+)?)\s*hours?/);
  const minutes = text.match(/(\d+(?:\.\d+)?)\s*minutes?/);
  const seconds = text.match(/(\d+(?:\.\d+)?)\s*seconds?/);
  if (!days && !hours && !minutes && !seconds) return null;
  return (
    toNumber(days?.[1], 0) * 86_400 +
    toNumber(hours?.[1], 0) * 3_600 +
    toNumber(minutes?.[1], 0) * 60 +
    toNumber(seconds?.[1], 0)
  );
}

function parseOpenCodeGoDashboardHtml(html: string): OpenCodeGoDashboardUsage | null {
  const usage: OpenCodeGoDashboardUsage = {
    session: parseOpenCodeGoSsrWindow(html, "rollingUsage") ?? undefined,
    weekly: parseOpenCodeGoSsrWindow(html, "weeklyUsage") ?? undefined,
    mcp_monthly: parseOpenCodeGoSsrWindow(html, "monthlyUsage") ?? undefined,
  };
  if (usage.session || usage.weekly || usage.mcp_monthly) return usage;

  for (const content of html.split(/data-slot="usage-item"/).slice(1)) {
    const label = content
      .match(/data-slot="usage-label">([^<]+)</)?.[1]
      ?.trim()
      .toLowerCase();
    const usagePercent = toNumber(
      content.match(/data-slot="usage-value">[^0-9]*(\d+(?:\.\d+)?)/)?.[1],
      Number.NaN
    );
    const resetMatch = content.match(/data-slot="(reset-time|reset-now)">([\s\S]*?)<\/span>/);
    if (!label || !Number.isFinite(usagePercent) || !resetMatch) continue;
    const resetInSec =
      resetMatch[1] === "reset-now"
        ? 0
        : parseOpenCodeGoHumanReset(
            // Strip any HTML comment, INCLUDING an unterminated one (React SSR emits
            // <!--$--> / <!--/--> hydration markers). The `(?:-->|$)` arm consumes a
            // trailing "<!--" with no closing "-->" too, so no partial "<!--" can survive
            // (js/incomplete-multi-character-sanitization).
            resetMatch[2].replace(/<!--[\s\S]*?(?:-->|$)/g, "").replace(/Resets?\s*in\s*/i, "")
          );
    if (resetInSec === null || !Number.isFinite(resetInSec)) continue;
    const window = {
      usagePercent,
      resetAt: safeToIsoString(Date.now() + Math.max(0, resetInSec) * 1000),
    };
    if (label.includes("rolling")) usage.session = window;
    else if (label.includes("weekly")) usage.weekly = window;
    else if (label.includes("monthly")) usage.mcp_monthly = window;
  }
  return usage.session || usage.weekly || usage.mcp_monthly ? usage : null;
}

async function fetchOpenCodeGoDashboardUsage(
  config: Extract<OpenCodeGoDashboardConfig, { state: "configured" }>
) {
  const url = `${OPENCODE_GO_DASHBOARD_BASE_URL.replace(/\/+$/, "")}/${encodeURIComponent(
    config.workspaceId
  )}/go`;
  const response = await fetch(url, {
    headers: {
      Accept: "text/html",
      Cookie: `auth=${normalizeOpenCodeGoAuthCookie(config.authCookie)}`,
      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/152.0",
    },
    signal: AbortSignal.timeout(10_000),
  });
  if (!response.ok)
    return { usage: null, message: `OpenCode Go dashboard error (${response.status}).` };
  const usage = parseOpenCodeGoDashboardHtml(await response.text());
  return {
    usage,
    message: usage ? undefined : "OpenCode Go dashboard response did not contain quota windows.",
  };
}

export async function getOpenCodeGoUsage(apiKey: string, providerSpecificData?: JsonRecord) {
  const dashboardConfig = resolveOpenCodeGoDashboardConfig(providerSpecificData);
  if (dashboardConfig.state === "incomplete") {
    return {
      message: `OpenCode Go dashboard quota config is incomplete. Missing ${dashboardConfig.missing}.`,
    };
  }
  if (dashboardConfig.state === "configured") {
    try {
      const dashboard = await fetchOpenCodeGoDashboardUsage(dashboardConfig);
      if (!dashboard.usage) {
        return { message: dashboard.message || "OpenCode Go dashboard quota data unavailable." };
      }
      const quotas: Record<string, UsageQuota> = {};
      for (const quotaName of OPENCODE_GO_QUOTA_ORDER) {
        const usage = dashboard.usage[quotaName];
        if (usage) {
          quotas[quotaName] = buildOpenCodeGoDollarQuota(
            quotaName,
            usage.usagePercent,
            usage.resetAt
          );
        }
      }
      return { plan: "OpenCode Go", quotas: orderOpenCodeGoQuotas(quotas) };
    } catch (error) {
      return { message: `OpenCode Go dashboard quota error: ${sanitizeErrorMessage(error)}` };
    }
  }

  const token = apiKey.trim().replace(/^Bearer\s+/i, "");
  if (!token) {
    return {
      message:
        "OpenCode Go quota requires OPENCODE_GO_WORKSPACE_ID and OPENCODE_GO_AUTH_COOKIE. " +
        "The API key can be used for chat/models, but OpenCode Go does not expose quota via API key.",
    };
  }

  try {
    const res = await fetch(OPENCODE_GO_QUOTA_URL, {
      headers: {
        Authorization: buildBearerAuthorization(token),
        "Accept-Language": "en-US,en",
        "Content-Type": "application/json",
        Accept: "application/json",
      },
    });
    if (!res.ok) {
      if (res.status === 401 || res.status === 403) {
        return {
          message:
            "OpenCode Go API key is valid for chat/models but cannot read quota from the Z.AI quota API. " +
            "Set OPENCODE_GO_WORKSPACE_ID and OPENCODE_GO_AUTH_COOKIE to enable dashboard quota scraping.",
        };
      }
      return {
        message:
          `OpenCode Go quota API error (${res.status}). ` +
          "Set OMNIROUTE_OPENCODE_GO_QUOTA_URL to a working endpoint, or follow " +
          "https://github.com/anomalyco/opencode/issues/16017 for upstream status.",
      };
    }

    let json: unknown;
    try {
      json = await res.json();
    } catch {
      return { message: "OpenCode Go quota response parsing failed." };
    }
    const root = toRecord(json);
    if (
      toNumber(root.code, 200) === 401 ||
      toNumber(root.code, 200) === 403 ||
      root.success === false
    ) {
      return {
        message:
          "OpenCode Go API key is valid for chat/models but cannot read quota from the Z.AI quota API. " +
          "Set OPENCODE_GO_WORKSPACE_ID and OPENCODE_GO_AUTH_COOKIE to enable dashboard quota scraping.",
      };
    }

    const data = toRecord(root.data);
    const quotas: Record<string, UsageQuota> = {};
    for (const limit of Array.isArray(data.limits) ? data.limits : []) {
      const src = toRecord(limit);
      const type = String(src.type || "").toUpperCase();
      const resetAt = parseResetTime(src.nextResetTime);
      if (type === "TOKENS_LIMIT" || type === "TOKEN_LIMIT") {
        const quotaName = getOpenCodeGoTokenQuotaName(src, quotas);
        quotas[quotaName] = buildOpenCodeGoDollarQuota(
          quotaName,
          src.percentage,
          resetAt,
          undefined,
          Array.isArray(src.models)
            ? src.models.map((model) => {
                const modelInfo = toRecord(model);
                return {
                  name: String(modelInfo.model || modelInfo.modelCode || "usage"),
                  used: toNumber(modelInfo.percentage, 0),
                };
              })
            : undefined
        );
      } else if (type === "TIME_LIMIT" || type === "TIME_USAGE_LIMIT") {
        quotas.mcp_monthly = buildOpenCodeGoDollarQuota(
          "mcp_monthly",
          src.percentage,
          resetAt,
          src.currentValue,
          Array.isArray(src.usageDetails)
            ? src.usageDetails.map((item) => {
                const detail = toRecord(item);
                return {
                  name: String(detail.modelCode || detail.name || "usage"),
                  used: toNumber(detail.usage, 0),
                };
              })
            : undefined
        );
      }
    }

    const levelRaw =
      typeof data.planName === "string"
        ? data.planName
        : typeof data.level === "string"
          ? data.level
          : "";
    const planLabel = toTitleCase(levelRaw.replace(/\s*plan$/i, ""));
    return {
      plan: planLabel
        ? /^opencode\s+go\b/i.test(planLabel)
          ? planLabel
          : `OpenCode Go ${planLabel}`
        : null,
      quotas: orderOpenCodeGoQuotas(quotas),
    };
  } catch (error) {
    return { message: `OpenCode Go quota API error: ${sanitizeErrorMessage(error)}` };
  }
}

function resolveOllamaCloudConfig(providerSpecificData?: JsonRecord): OllamaCloudConfig {
  const cookie =
    process.env.OMNIROUTE_OLLAMA_USAGE_COOKIE?.trim() ||
    process.env.OLLAMA_USAGE_COOKIE?.trim() ||
    process.env.OLLAMA_CLOUD_USAGE_COOKIE?.trim() ||
    getProviderSpecificString(providerSpecificData, [
      "ollamaUsageCookie",
      "ollamaCloudUsageCookie",
      "ollamaCloudCookie",
      "usageCookie",
      "cookie",
    ]);
  if (!cookie) return { state: "none" };
  if (cookie.includes("\r") || cookie.includes("\n")) {
    return { state: "invalid", error: "Ollama Cloud cookie contains invalid CRLF characters." };
  }
  return { state: "configured", cookie };
}

function normalizeOllamaCloudCookie(value: string): string {
  const trimmed = value.trim();
  return trimmed.toLowerCase().startsWith(`${OLLAMA_CLOUD_SESSION_COOKIE.toLowerCase()}=`)
    ? trimmed.slice(OLLAMA_CLOUD_SESSION_COOKIE.length + 1).trim()
    : trimmed;
}

function extractOllamaUsagePercent(trackHtml: string): number | null {
  const tagHeader = trackHtml.match(/^[^>]*/)?.[0] ?? "";
  const ariaMatch = tagHeader.match(/(\d+(?:\.\d+)?)%\s*used/);
  if (ariaMatch) {
    const pct = toNumber(ariaMatch[1], Number.NaN);
    if (Number.isFinite(pct) && pct >= 0 && pct <= 100) return pct;
  }
  const style = tagHeader.match(/style="([^"]*)"/)?.[1] ?? "";
  const pct = toNumber(style.match(/(?:^|;)\s*width\s*:\s*([0-9.]+)%/)?.[1], Number.NaN);
  return Number.isFinite(pct) && pct >= 0 && pct <= 100 ? pct : null;
}

function parseOllamaCloudSettingsHtml(html: string): OllamaCloudUsage | null {
  const parts = html.split(/\bdata-usage-track\b/);
  if (parts.length < 2) return null;
  const extractTime = (text: string): string | null => {
    const match = text.match(/class="[^"]*local-time[^"]*"[^>]*data-time="([^"]*)"/);
    return match?.[1] || null;
  };
  const sessionPercent = extractOllamaUsagePercent(parts[1]);
  const weeklyPercent = parts[2] ? extractOllamaUsagePercent(parts[2]) : null;
  if (sessionPercent === null && weeklyPercent === null) return null;
  return {
    ...(sessionPercent !== null
      ? { session: { usagePercent: sessionPercent, resetAt: extractTime(parts[1]) } }
      : {}),
    ...(weeklyPercent !== null
      ? { weekly: { usagePercent: weeklyPercent, resetAt: extractTime(parts[2]) } }
      : {}),
    planTier: html.match(/class="[^"]*capitalize[^"]*"[^>]*>([^<]*)</)?.[1]?.trim() || null,
  };
}

async function fetchOllamaCloudUsageFromSettings(
  config: Extract<OllamaCloudConfig, { state: "configured" }>
) {
  const response = await fetch(OLLAMA_CLOUD_USAGE_URL, {
    redirect: "manual",
    headers: {
      Accept: "text/html",
      Cookie: `${OLLAMA_CLOUD_SESSION_COOKIE}=${normalizeOllamaCloudCookie(config.cookie)}`,
      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/152.0",
    },
    signal: AbortSignal.timeout(10_000),
  });
  if (response.status >= 300 && response.status < 400) {
    return { usage: null, message: "Ollama Cloud authentication expired. Refresh the cookie." };
  }
  if (!response.ok)
    return { usage: null, message: `Ollama Cloud settings error (${response.status}).` };
  const usage = parseOllamaCloudSettingsHtml(await response.text());
  return {
    usage,
    message: usage ? undefined : "Ollama Cloud settings page did not contain usage quota tracks.",
  };
}

export async function getOllamaCloudUsage(providerSpecificData?: JsonRecord) {
  const config = resolveOllamaCloudConfig(providerSpecificData);
  if (config.state === "none") {
    return {
      message:
        "Ollama Cloud quota requires OLLAMA_USAGE_COOKIE. Copy the __Secure-session cookie from ollama.com/settings.",
    };
  }
  if (config.state === "invalid") return { message: config.error };

  try {
    const result = await fetchOllamaCloudUsageFromSettings(config);
    if (!result.usage) return { message: result.message || "Ollama Cloud quota data unavailable." };
    const quotas: Record<string, UsageQuota> = {};
    for (const key of ["session", "weekly"] as const) {
      const quota = result.usage[key];
      if (!quota) continue;
      const pct = toPercentage(quota.usagePercent);
      quotas[key] = {
        used: pct,
        total: 100,
        remaining: Math.max(0, 100 - pct),
        remainingPercentage: Math.max(0, 100 - pct),
        resetAt: quota.resetAt,
        unlimited: false,
        displayName: key === "session" ? "Session" : "Weekly",
      };
    }
    return {
      plan: result.usage.planTier ? `Ollama Cloud ${result.usage.planTier}` : "Ollama Cloud",
      quotas,
    };
  } catch (error) {
    return { message: `Ollama Cloud quota error: ${sanitizeErrorMessage(error)}` };
  }
}