import {
  apiCallErrorMessage,
  isRecord,
  managementApi,
  normalizeAuthIndex,
  readString,
} from './managementApi';
import { authFileName } from './authFiles';
import { antigravityProjectFor, codexMetadataFor, isPaidXaiFile } from './quotaMetadata';
import { quotaResetFor, quotaResetInstant } from './quotaTime';
import { getCurrentLocale, translate, type AppLocale } from '../i18n';

const quotaText = (
  key: Parameters<typeof translate>[1],
  variables?: Parameters<typeof translate>[2],
) => translate(getCurrentLocale(), key, variables);

export type AuthFile = Record<string, unknown>;
export type QuotaProvider = 'claude' | 'codex' | 'kimi' | 'xai' | 'antigravity';
export type QuotaStatus = 'idle' | 'loading' | 'success' | 'error';
export type QuotaRow = {
  label: string;
  remainingPercent: number | null;
  reset?: string;
  resetAtMs?: number;
  detail?: string;
};
export type QuotaState = {
  status: QuotaStatus;
  rows: QuotaRow[];
  error?: string;
  plan?: string;
  resetCredits?: number;
  resetCreditsApplicable?: number;
  resetCreditsError?: string;
  resetCreditsEarliestExpiry?: string;
  subscriptionActiveUntil?: string;
  serverTimeOffsetMs?: number;
  fetchedAt?: number;
  pendingAction?: 'reset';
  actionResult?: { action: 'reset'; status: 'success' | 'refresh-error' | 'error'; error?: string };
};

export const idleQuota = (): QuotaState => ({ status: 'idle', rows: [] });

const endpointByProvider: Record<QuotaProvider, string> = {
  claude: 'https://api.anthropic.com/api/oauth/usage',
  codex: 'https://chatgpt.com/backend-api/wham/usage',
  kimi: 'https://api.kimi.com/coding/v1/usages',
  xai: 'https://cli-chat-proxy.grok.com/v1/billing',
  antigravity: 'https://daily-cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary',
};

const CLAUDE_PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
const XAI_WEEKLY_URL = 'https://cli-chat-proxy.grok.com/v1/billing?format=credits';
const CODEX_RESET_CREDITS_URL =
  'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
const CODEX_RESET_CREDITS_CONSUME_URL =
  'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume';
const ANTIGRAVITY_CODE_ASSIST_URL =
  'https://daily-cloudcode-pa.googleapis.com/v1internal:loadCodeAssist';

const headersByProvider: Record<QuotaProvider, Record<string, string>> = {
  claude: {
    Authorization: 'Bearer $TOKEN$',
    'Content-Type': 'application/json',
    'anthropic-beta': 'oauth-2025-04-20',
  },
  codex: {
    Authorization: 'Bearer $TOKEN$',
    'Content-Type': 'application/json',
    'User-Agent': 'codex-tui/0.149.1 (Mac OS 26.5.2; arm64) iTerm.app/3.6.11 (codex-tui; 0.149.1)',
  },
  kimi: { Authorization: 'Bearer $TOKEN$' },
  xai: {
    Authorization: 'Bearer $TOKEN$',
    'x-xai-token-auth': 'xai-grok-cli',
    'x-grok-client-version': '0.2.91',
    accept: '*/*',
    'user-agent': 'grok-pager/0.2.91 grok-shell/0.2.91 (macos; aarch64)',
  },
  antigravity: {
    Authorization: 'Bearer $TOKEN$',
    'Content-Type': 'application/json',
    'User-Agent': 'antigravity/cli/1.0.13 (aidev_client; os_type=darwin; arch=arm64)',
  },
};

export const providerForFile = (file: AuthFile): QuotaProvider | null => {
  const value = readString(file, 'provider', 'type', 'account_type').toLowerCase().replace(/_/g, '-');
  if (value === 'x-ai' || value === 'grok') return 'xai';
  if (value === 'anthropic') return 'claude';
  if (value === 'anti-gravity') return 'antigravity';
  return ['claude', 'codex', 'kimi', 'xai', 'antigravity'].includes(value)
    ? (value as QuotaProvider)
    : null;
};

export const fileName = authFileName;

export const quotaKey = (file: AuthFile) =>
  `${fileName(file)}::${normalizeAuthIndex(file.auth_index ?? file.authIndex)}`;

const parseBody = (value: unknown): unknown => {
  if (typeof value !== 'string') return value;
  try {
    return JSON.parse(value);
  } catch {
    return value;
  }
};

const numberValue = (value: unknown): number | null => {
  if (isRecord(value) && 'val' in value) return numberValue(value.val);
  if (typeof value !== 'number' && typeof value !== 'string') return null;
  if (typeof value === 'string' && !value.trim()) return null;
  const parsed = typeof value === 'number' ? value : Number(value);
  return Number.isFinite(parsed) ? parsed : null;
};

const clampPercent = (value: unknown): number | null => {
  const parsed = numberValue(value);
  if (parsed === null) return null;
  return Math.max(0, Math.min(100, parsed));
};

const remainingFromUsedPercent = (value: unknown): number | null => {
  const used = clampPercent(value);
  return used === null ? null : Math.max(0, Math.min(100, 100 - used));
};

const quotaFraction = (value: unknown): number | null => {
  if (typeof value === 'string' && value.trim().endsWith('%')) {
    const parsed = Number(value.trim().slice(0, -1));
    return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed / 100)) : null;
  }
  const parsed = numberValue(value);
  return parsed === null ? null : Math.max(0, Math.min(1, parsed));
};

const formatDateTime = (date: Date): string | undefined => {
  if (Number.isNaN(date.getTime())) return undefined;
  return new Intl.DateTimeFormat(getCurrentLocale(), {
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    hour12: false,
  }).format(date);
};

export const formatQuotaTimestamp = (value: string | undefined, locale: AppLocale = 'zh-CN'): string => {
  if (!value) return '—';
  const ms = quotaResetInstant(value);
  if (ms === undefined) return '—';
  const date = new Date(ms);
  return new Intl.DateTimeFormat(locale, {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    hour12: false,
  }).format(date);
};

const absoluteResetLabel = (value: unknown): string | undefined => {
  const ms = quotaResetInstant(value);
  return ms === undefined ? undefined : formatDateTime(new Date(ms));
};

const relativeResetLabel = (value: unknown): string | undefined => {
  const seconds = numberValue(value);
  if (seconds === null || seconds <= 0) return undefined;
  const minutes = Math.max(1, Math.ceil(seconds / 60));
  const days = Math.floor(minutes / 1440);
  const hours = Math.floor(minutes / 60);
  const remainingHours = Math.floor((minutes % 1440) / 60);
  const remainingMinutes = minutes % 60;
  if (days > 0) {
    return remainingHours > 0
      ? quotaText('quota.service.relative.daysHours', { days, hours: remainingHours })
      : quotaText('quota.service.relative.days', { days });
  }
  if (hours > 0) {
    return remainingMinutes > 0
      ? quotaText('quota.service.relative.hoursMinutes', { hours, minutes: remainingMinutes })
      : quotaText('quota.service.relative.hours', { hours });
  }
  return quotaText('quota.service.relative.minutes', { minutes });
};

const formatUsdFromCents = (value: number | null) =>
  value === null
    ? undefined
    : new Intl.NumberFormat(getCurrentLocale(), { style: 'currency', currency: 'USD' }).format(value / 100);

const codexResetLabel = (window: Record<string, unknown>): string | undefined =>
  absoluteResetLabel(window.reset_at ?? window.resetAt)
  ?? relativeResetLabel(window.reset_after_seconds ?? window.resetAfterSeconds);

const FIVE_HOUR_SECONDS = 18_000;
const WEEK_SECONDS = 604_800;
const MIN_MONTH_SECONDS = 28 * 86_400;
const MAX_MONTH_SECONDS = 31 * 86_400;

const formatWindowDuration = (seconds: number | null): string => {
  if (seconds === null || seconds <= 0) return quotaText('quota.service.duration.unknown');
  const day = 86_400;
  const hour = 3_600;
  const minute = 60;
  if (seconds % day === 0) return quotaText('quota.service.duration.days', { count: seconds / day });
  if (seconds % hour === 0) return quotaText('quota.service.duration.hours', { count: seconds / hour });
  if (seconds % minute === 0) return quotaText('quota.service.duration.minutes', { count: seconds / minute });
  return quotaText('quota.service.duration.seconds', { count: seconds });
};

const codexWindowLabel = (
  duration: number | null,
  prefix: string,
  kind: 'primary' | 'secondary',
) => {
  if (duration === FIVE_HOUR_SECONDS) return `${prefix}${quotaText('quota.service.limit.fiveHours')}`;
  if (duration === WEEK_SECONDS) return `${prefix}${quotaText('quota.service.limit.week')}`;
  if (duration !== null && duration >= MIN_MONTH_SECONDS && duration <= MAX_MONTH_SECONDS) {
    return `${prefix}${quotaText('quota.service.limit.month')}`;
  }
  if (duration !== null) {
    return `${prefix}${quotaText('quota.service.limit.duration', { duration: formatWindowDuration(duration) })}`;
  }
  if (kind === 'primary') return `${prefix}${quotaText('quota.service.limit.fiveHours')}`;
  return `${prefix}${quotaText('quota.service.limit.week')}`;
};

const codexWindowRows = (value: Record<string, unknown>): QuotaRow[] => {
  const windows: Array<{
    raw: unknown;
    kind: 'primary' | 'secondary';
    prefix: string;
    source: Record<string, unknown>;
  }> = [];
  const addRateLimit = (rawRateLimit: unknown, prefix: string) => {
    if (!isRecord(rawRateLimit)) return;
    const entries: typeof windows = [
      { raw: rawRateLimit.primary_window ?? rawRateLimit.primaryWindow, kind: 'primary', prefix, source: rawRateLimit },
      { raw: rawRateLimit.secondary_window ?? rawRateLimit.secondaryWindow, kind: 'secondary', prefix, source: rawRateLimit },
    ];
    const order = ({ raw, kind }: typeof entries[number]) => {
      const duration = isRecord(raw) ? numberValue(raw.limit_window_seconds ?? raw.limitWindowSeconds) : null;
      if (duration === FIVE_HOUR_SECONDS) return 0;
      if (duration === WEEK_SECONDS || (duration !== null && duration >= MIN_MONTH_SECONDS && duration <= MAX_MONTH_SECONDS)) return 1;
      return kind === 'primary' ? 0 : 1;
    };
    windows.push(...entries.sort((a, b) => order(a) - order(b)));
  };

  addRateLimit(value.rate_limit ?? value.rateLimit, '');
  addRateLimit(
    value.code_review_rate_limit ?? value.codeReviewRateLimit,
    `${quotaText('quota.service.codeReview')} `,
  );
  const additional = value.additional_rate_limits ?? value.additionalRateLimits;
  if (Array.isArray(additional)) {
    additional.forEach((item, index) => {
      if (!isRecord(item)) return;
      const name = readString(item, 'limit_name', 'limitName', 'metered_feature', 'meteredFeature')
        || quotaText('quota.service.additional', { index: index + 1 });
      addRateLimit(item.rate_limit ?? item.rateLimit, `${name} `);
    });
  }

  return windows.map(({ raw, kind, prefix, source }): QuotaRow | null => {
    if (!isRecord(raw)) return null;
    const duration = numberValue(raw.limit_window_seconds ?? raw.limitWindowSeconds);
    const reached = source.limit_reached === true || source.limitReached === true || source.allowed === false;
    const resetAtMs = quotaResetFor(raw, ['reset_at', 'resetAt'], ['reset_after_seconds', 'resetAfterSeconds']);
    return {
      label: codexWindowLabel(duration, prefix, kind),
      remainingPercent: remainingFromUsedPercent(raw.used_percent ?? raw.usedPercent)
        ?? (reached && resetAtMs !== undefined ? 0 : null),
      reset: codexResetLabel(raw),
      resetAtMs,
    };
  }).filter((row): row is QuotaRow => row !== null);
};

export const codexResetCreditsFor = (payload: unknown): number | undefined => {
  const value = parseBody(payload);
  if (!isRecord(value)) return undefined;
  const credits = isRecord(value.rate_limit_reset_credits)
    ? value.rate_limit_reset_credits
    : isRecord(value.rateLimitResetCredits)
      ? value.rateLimitResetCredits
      : null;
  const count = numberValue(credits?.available_count ?? credits?.availableCount);
  return count === null ? undefined : Math.max(0, Math.floor(count));
};

export const codexResetCreditDetailsFor = (
  payload: unknown,
  nowMs = Date.now(),
): { availableCount?: number; applicableAvailableCount?: number; earliestExpiry?: string } => {
  const value = parseBody(payload);
  if (!isRecord(value)) return {};
  const credits = Array.isArray(value.credits)
    ? value.credits
      .filter(isRecord)
      .filter((credit) =>
        readString(credit, 'reset_type', 'resetType') === 'codex_rate_limits'
        && readString(credit, 'status') === 'available',
      )
    : [];
  const availableCount = numberValue(value.available_count ?? value.availableCount);
  const applicableCount = numberValue(value.applicable_available_count ?? value.applicableAvailableCount);
  const validCredits = credits.filter((credit) => {
    const expiry = quotaResetInstant(credit.expires_at ?? credit.expiresAt);
    return expiry !== undefined && expiry > nowMs;
  });
  const earliestExpiry = validCredits
    .map((credit) => readString(credit, 'expires_at', 'expiresAt'))
    .map((expiresAt) => ({ expiresAt, expiresAtMs: quotaResetInstant(expiresAt) ?? NaN }))
    .filter((credit) =>
      credit.expiresAt
      && Number.isFinite(credit.expiresAtMs)
      && credit.expiresAtMs > nowMs,
    )
    .sort((left, right) => left.expiresAtMs - right.expiresAtMs)[0]?.expiresAt;

  return {
    // An empty detail list is not an explicit zero; keep the usage-summary fallback.
    availableCount: availableCount === null
      ? validCredits.length || undefined
      : Math.max(0, Math.floor(availableCount)),
    ...(applicableCount === null ? {} : { applicableAvailableCount: Math.max(0, Math.floor(applicableCount)) }),
    earliestExpiry,
  };
};

export const quotaRowsFor = (provider: QuotaProvider, payload: unknown): QuotaRow[] => {
  const value = parseBody(payload);
  if (!isRecord(value)) return [];

  if (provider === 'codex') return codexWindowRows(value);

  if (provider === 'claude') {
    const labels: Record<string, string> = {
      five_hour: quotaText('quota.service.window.fiveHour'),
      seven_day: quotaText('quota.service.window.sevenDay'),
      seven_day_oauth_apps: quotaText('quota.service.window.sevenDayOAuth'),
      seven_day_opus: quotaText('quota.service.window.sevenDayOpus'),
      seven_day_sonnet: quotaText('quota.service.window.sevenDaySonnet'),
      seven_day_cowork: quotaText('quota.service.window.sevenDayCowork'),
      iguana_necktie: quotaText('quota.service.window.sevenDayFable'),
    };
    const fableCandidates = (Array.isArray(value.limits) ? value.limits : []).filter(isRecord)
      .filter((limit) => {
        const scope = isRecord(limit.scope) ? limit.scope : null;
        const name = readString(scope?.model, 'display_name', 'displayName').toLowerCase();
        return readString(limit, 'kind').toLowerCase() === 'weekly_scoped'
          && ['fable', 'fable 5'].includes(name) && numberValue(limit.percent) !== null;
      });
    const fable = fableCandidates.find((limit) => limit.is_active === true) ?? fableCandidates[0];
    const rows = Object.entries(labels)
      .filter(([key]) => key !== 'iguana_necktie' || !fable)
      .map(([key]): QuotaRow | null => {
        const raw = value[key];
        if (!isRecord(raw) || !('utilization' in raw)) return null;
        return {
          label: labels[key],
          remainingPercent: remainingFromUsedPercent(raw.utilization),
          reset: absoluteResetLabel(raw.resets_at ?? raw.resetsAt),
          resetAtMs: quotaResetFor(raw, ['resets_at', 'resetsAt']),
        };
      })
      .filter((row): row is QuotaRow => row !== null);
    if (fable) rows.push({
      label: quotaText('quota.service.window.sevenDayFable'),
      remainingPercent: remainingFromUsedPercent(fable.percent),
      reset: absoluteResetLabel(fable.resets_at ?? fable.resetsAt),
      resetAtMs: quotaResetFor(fable, ['resets_at', 'resetsAt']),
    });
    const extraUsage = isRecord(value.extra_usage)
      ? value.extra_usage
      : isRecord(value.extraUsage)
        ? value.extraUsage
        : null;
    if (extraUsage && booleanValue(extraUsage.is_enabled ?? extraUsage.isEnabled) === true) {
      const monthlyLimit = numberValue(extraUsage.monthly_limit ?? extraUsage.monthlyLimit);
      const usedCredits = numberValue(extraUsage.used_credits ?? extraUsage.usedCredits);
      const computedRemaining = monthlyLimit !== null && monthlyLimit > 0 && usedCredits !== null
        ? ((monthlyLimit - usedCredits) / monthlyLimit) * 100
        : null;
      const usedLabel = formatUsdFromCents(usedCredits);
      const limitLabel = formatUsdFromCents(monthlyLimit);
      rows.push({
        label: quotaText('quota.service.extraUsage'),
        remainingPercent:
          remainingFromUsedPercent(extraUsage.utilization)
          ?? clampPercent(computedRemaining),
        detail: usedLabel && limitLabel
          ? quotaText('quota.service.usedOf', { used: usedLabel, limit: limitLabel })
          : undefined,
      });
    }
    return rows;
  }

  if (provider === 'kimi') {
    const items: unknown[] = Array.isArray(value.limits) ? [...value.limits] : [];
    if (isRecord(value.usage)) {
      items.push({ ...value.usage, label: readString(value.usage, 'name', 'title') || quotaText('quota.service.weekly') });
    }
    return items
      .map((raw, index): QuotaRow | null => {
        if (!isRecord(raw)) return null;
        const detail = isRecord(raw.detail) ? raw.detail : raw;
        const limit = numberValue(detail.limit);
        const used = numberValue(detail.used);
        const remaining = numberValue(detail.remaining);
        const usedValue = used ?? (limit !== null && remaining !== null ? limit - remaining : null);
        if (usedValue === null && limit === null) return null;
        const window = isRecord(raw.window) ? raw.window : null;
        const duration = numberValue(window?.duration ?? raw.duration ?? detail.duration);
        const unit = (readString(window, 'timeUnit', 'time_unit')
          || readString(raw, 'timeUnit', 'time_unit')
          || readString(detail, 'timeUnit', 'time_unit')).toLowerCase().replace(/^time_unit_/, '');
        const durationText = duration !== null && duration > 0
          ? unit.startsWith('week')
            ? quotaText('quota.service.duration.days', { count: duration * 7 })
            : unit.startsWith('day')
              ? quotaText('quota.service.duration.days', { count: duration })
              : unit.startsWith('hour')
                ? quotaText('quota.service.duration.hours', { count: duration })
                : unit.startsWith('second')
                  ? quotaText('quota.service.duration.seconds', { count: duration })
                  : duration % 60 === 0
                    ? quotaText('quota.service.duration.hours', { count: duration / 60 })
                    : quotaText('quota.service.duration.minutes', { count: duration })
          : '';
        const durationLabel = durationText
          ? quotaText('quota.service.window.duration', { duration: durationText })
          : '';
        return {
          label:
            readString(raw, 'label', 'name', 'title', 'scope')
            || readString(detail, 'name', 'title', 'scope')
            || durationLabel
            || quotaText('quota.service.limit.numbered', { index: index + 1 }),
          remainingPercent: clampPercent(
            limit !== null && limit > 0
              ? (Math.max(0, limit - (usedValue ?? 0)) / limit) * 100
              : (usedValue ?? 0) > 0
                ? 0
                : null,
          ),
          reset:
            absoluteResetLabel(
              detail.reset_at ?? detail.resetAt ?? detail.reset_time ?? detail.resetTime,
            )
            ?? relativeResetLabel(detail.reset_in ?? detail.resetIn ?? detail.ttl),
          resetAtMs: quotaResetFor(detail, ['reset_at', 'resetAt', 'reset_time', 'resetTime'], ['reset_in', 'resetIn', 'ttl']),
          detail: limit === null ? undefined : `${usedValue ?? 0} / ${limit}`,
        };
      })
      .filter((row): row is QuotaRow => row !== null);
  }

  if (provider === 'xai') {
    if (value.mode === 'paid-info') return [{
      label: quotaText('quota.service.xaiPaidAccount'),
      remainingPercent: null,
      detail: quotaText('quota.service.xaiPaidQuotaUnavailable'),
    }];
    const payloads = isRecord(value.weekly) || isRecord(value.monthly)
      ? [value.weekly, value.monthly]
      : [value];
    const rows: QuotaRow[] = [];

    payloads.forEach((payload) => {
      if (!isRecord(payload)) return;
      const config = isRecord(payload.config) ? payload.config : payload;
      const currentPeriod = isRecord(config.current_period)
        ? config.current_period
        : isRecord(config.currentPeriod)
          ? config.currentPeriod
          : null;
      const periodType = readString(currentPeriod, 'type').toLowerCase();
      const weeklyUsed = numberValue(config.credit_usage_percent ?? config.creditUsagePercent);

      const productItems = config.product_usage ?? config.productUsage;
      if (weeklyUsed !== null || periodType.includes('week') || (Array.isArray(productItems) && productItems.length > 0)) {
        rows.push({
          label: quotaText('quota.service.weekly'),
          remainingPercent: remainingFromUsedPercent(weeklyUsed),
          reset: absoluteResetLabel(currentPeriod?.end),
          resetAtMs: currentPeriod ? quotaResetFor(currentPeriod, ['end']) : undefined,
        });
        const productUsage = Array.isArray(config.product_usage)
          ? config.product_usage
          : Array.isArray(config.productUsage)
            ? config.productUsage
            : [];
        productUsage.forEach((item, index) => {
          if (!isRecord(item)) return;
          rows.push({
            label: readString(item, 'product')
              || quotaText('quota.service.product.numbered', { index: index + 1 }),
            remainingPercent: remainingFromUsedPercent(
              item.usage_percent ?? item.usagePercent,
            ),
            reset: absoluteResetLabel(currentPeriod?.end),
            resetAtMs: currentPeriod ? quotaResetFor(currentPeriod, ['end']) : undefined,
          });
        });
      }

      const limit = numberValue(config.monthly_limit ?? config.monthlyLimit);
      const used = numberValue(config.used);
      const includedUsed = used === null
        ? null
        : limit !== null && limit > 0
          ? Math.min(used, limit)
          : used;
      if (limit !== null || used !== null) {
        const remaining = limit !== null && limit > 0 && includedUsed !== null
          ? ((limit - includedUsed) / limit) * 100
          : null;
        rows.push({
          label: quotaText('quota.service.monthlyIncluded'),
          remainingPercent: clampPercent(remaining),
          reset: absoluteResetLabel(config.billing_period_end ?? config.billingPeriodEnd),
          resetAtMs: quotaResetFor(config, ['billing_period_end', 'billingPeriodEnd']),
          detail: limit !== null
            ? `${formatUsdFromCents(Math.max(0, limit - (includedUsed ?? 0)))} / ${formatUsdFromCents(limit)}`
            : undefined,
        });
      }

      const onDemandCap = numberValue(config.on_demand_cap ?? config.onDemandCap);
      const explicitOnDemandUsed = numberValue(config.on_demand_used ?? config.onDemandUsed);
      const onDemandUsed = explicitOnDemandUsed
        ?? (used !== null && limit !== null ? Math.max(0, used - limit) : null);
      if (onDemandCap !== null && onDemandCap > 0) {
        rows.push({
          label: quotaText('quota.service.onDemand'),
          remainingPercent: clampPercent(
            onDemandUsed === null ? null : ((onDemandCap - onDemandUsed) / onDemandCap) * 100,
          ),
          reset: absoluteResetLabel(config.billing_period_end ?? config.billingPeriodEnd),
          resetAtMs: quotaResetFor(config, ['billing_period_end', 'billingPeriodEnd']),
          detail: `${formatUsdFromCents(Math.max(0, onDemandCap - (onDemandUsed ?? 0)))} / ${formatUsdFromCents(onDemandCap)}`,
        });
      }
    });

    const seen = new Set<string>();
    return rows.filter((row) => {
      const key = `${row.label}::${row.reset ?? ''}`;
      if (seen.has(key)) return false;
      seen.add(key);
      return true;
    });
  }

  const nested = parseBody(value.body);
  const summary = !Array.isArray(value.groups) && isRecord(nested) ? nested : value;
  const groups = Array.isArray(summary.groups) ? summary.groups : [];
  return groups.flatMap((group) => {
    if (!isRecord(group) || !Array.isArray(group.buckets)) return [];
    const order = (bucket: unknown) => {
      const window = readString(bucket, 'window').toLowerCase();
      return ['5h', 'five-hour', 'five_hour'].includes(window) ? 0 : ['weekly', 'week'].includes(window) ? 1 : 2;
    };
    const buckets = [...group.buckets].sort((a, b) => order(a) - order(b));
    const groupLabel = readString(group, 'display_name', 'displayName')
      || quotaText('quota.service.quota');
    const groupDescription = readString(group, 'description');
    return buckets
      .map((bucket, index): QuotaRow | null => {
        if (!isRecord(bucket)) return null;
        const remaining = quotaFraction(bucket.remaining_fraction ?? bucket.remainingFraction);
        if (remaining === null) return null;
        const bucketLabel = readString(bucket, 'display_name', 'displayName', 'window');
        const label = bucketLabel && (buckets.length > 1 || bucketLabel !== groupLabel)
          ? `${groupLabel} · ${bucketLabel}`
          : groupLabel;
        return {
          label: label || quotaText('quota.service.quota.numbered', { index: index + 1 }),
          remainingPercent: remaining * 100,
          reset: absoluteResetLabel(bucket.reset_time ?? bucket.resetTime),
          resetAtMs: quotaResetFor(bucket, ['reset_time', 'resetTime']),
          detail: readString(bucket, 'description') || groupDescription || undefined,
        };
      })
      .filter((row): row is QuotaRow => row !== null);
  });
};

const resolveProjectId = async (file: AuthFile): Promise<string> => {
  const direct = antigravityProjectFor(file);
  if (direct) return direct;
  try {
    const payload = parseBody(await managementApi.get('/auth-files/download', { name: fileName(file) }));
    return isRecord(payload) ? antigravityProjectFor(payload) : '';
  } catch {
    return '';
  }
};

const resolveCodexAccountId = (file: AuthFile): string => codexMetadataFor(file).accountId;

const xaiUserIdFromRecord = (record: Record<string, unknown>): string => {
  const nestedRecords = [record, record.metadata, record.attributes]
    .filter(isRecord);
  for (const source of nestedRecords) {
    const direct = readString(source, 'sub', 'subject', 'user_id', 'userId');
    if (direct) return direct;
    for (const container of [source.oauth, source.user]) {
      if (!isRecord(container)) continue;
      const nested = readString(container, 'sub', 'subject', 'user_id', 'userId', 'id');
      if (nested) return nested;
    }
  }
  return '';
};

const resolveXaiUserId = (file: AuthFile): string =>
  xaiUserIdFromRecord(file);

const requestQuotaPayload = async (
  authIndex: string,
  url: string,
  header: Record<string, string>,
  method: 'GET' | 'POST' = 'GET',
  data?: string,
  timeoutMs?: number,
  responseClock?: { serverTimeOffsetMs?: number },
) => {
  const response = await managementApi.post<Record<string, unknown>>('/api-call', {
    authIndex,
    method,
    url,
    header,
    data,
  }, { timeoutMs });
  const status = Number(response.status_code ?? response.statusCode ?? 0);
  if (status < 200 || status >= 300) {
    throw new Error(apiCallErrorMessage(response));
  }
  if (responseClock) {
    const header = isRecord(response.header) ? response.header : {};
    const raw = Object.entries(header).find(([key]) => key.toLowerCase() === 'date')?.[1];
    const serverTime = quotaResetInstant(Array.isArray(raw) ? raw[0] : raw);
    responseClock.serverTimeOffsetMs = serverTime === undefined ? undefined : serverTime - Date.now();
  }
  return parseBody(response.body ?? response.bodyText);
};

const callXaiQuota = async (file: AuthFile): Promise<unknown> => {
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) throw new Error(quotaText('quota.service.error.missingAuthIndex'));
  if (isPaidXaiFile(file)) return { mode: 'paid-info', plan_type: 'Paid' };
  const header = { ...headersByProvider.xai };
  const userId = await resolveXaiUserId(file);
  if (userId) header['x-userid'] = userId;
  const [weekly, monthly] = await Promise.allSettled([
    requestQuotaPayload(authIndex, XAI_WEEKLY_URL, header),
    requestQuotaPayload(authIndex, endpointByProvider.xai, header),
  ]);
  const payload = {
    weekly: weekly.status === 'fulfilled' ? weekly.value : null,
    monthly: monthly.status === 'fulfilled' ? monthly.value : null,
  };
  if (quotaRowsFor('xai', payload).length > 0) return payload;
  const billingError = weekly.status === 'rejected' && monthly.status === 'rejected'
    ? weekly.reason : new Error(quotaText('quota.service.error.unrecognized'));
  throw billingError;
};

const booleanValue = (value: unknown): boolean | null => {
  if (typeof value === 'boolean') return value;
  if (typeof value === 'number') return Number.isFinite(value) ? value !== 0 : null;
  if (typeof value === 'string') {
    const normalized = value.trim().toLowerCase();
    if (['true', '1', 'yes', 'y', 'on'].includes(normalized)) return true;
    if (['false', '0', 'no', 'n', 'off'].includes(normalized)) return false;
  }
  return null;
};

const resolveClaudePlan = (payload: unknown): string | undefined => {
  if (!isRecord(payload)) return undefined;
  const account = isRecord(payload.account) ? payload.account : null;
  const organization = isRecord(payload.organization) ? payload.organization : null;
  if (booleanValue(account?.has_claude_max) === true) return 'Max';
  if (booleanValue(account?.has_claude_pro) === true) return 'Pro';
  if (
    readString(organization, 'organization_type').toLowerCase() === 'claude_team'
    && readString(organization, 'subscription_status').toLowerCase() === 'active'
  ) return 'Team';
  if (
    booleanValue(account?.has_claude_max) === false
    && booleanValue(account?.has_claude_pro) === false
  ) return 'Free';
  return undefined;
};

const loadClaudePlan = async (file: AuthFile): Promise<string | undefined> => {
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) return undefined;
  try {
    return resolveClaudePlan(
      await requestQuotaPayload(authIndex, CLAUDE_PROFILE_URL, headersByProvider.claude),
    );
  } catch {
    return undefined;
  }
};

const loadAntigravityPlan = async (file: AuthFile): Promise<string | undefined> => {
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) return undefined;
  try {
    const payload = await requestQuotaPayload(
      authIndex,
      ANTIGRAVITY_CODE_ASSIST_URL,
      headersByProvider.antigravity,
      'POST',
      JSON.stringify({ metadata: { ideType: 'ANTIGRAVITY' } }),
    );
    if (!isRecord(payload)) return undefined;
    const currentTier = isRecord(payload.currentTier)
      ? payload.currentTier
      : isRecord(payload.current_tier)
        ? payload.current_tier
        : null;
    const paidTier = isRecord(payload.paidTier)
      ? payload.paidTier
      : isRecord(payload.paid_tier)
        ? payload.paid_tier
        : null;
    const effectiveTier = readString(paidTier, 'id') ? paidTier : currentTier;
    const tierId = readString(effectiveTier, 'id').toLowerCase();
    const tierName = readString(effectiveTier, 'name');
    const knownPlans: Record<string, string> = {
      'free-tier': 'Free',
      'g1-pro-tier': 'Pro',
      'g1-ultra-tier': 'Ultra',
      'g1-ultra-lite-tier': 'Ultra Lite',
    };
    return knownPlans[tierId] || tierName || tierId || undefined;
  } catch {
    return undefined;
  }
};

async function callUpstreamQuota(
  file: AuthFile,
  provider: QuotaProvider,
  resolvedCodexAccountId?: string,
  responseClock?: { serverTimeOffsetMs?: number },
): Promise<unknown> {
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) throw new Error(quotaText('quota.service.error.missingAuthIndex'));
  const header = { ...headersByProvider[provider] };
  if (provider === 'codex') {
    const accountId = resolvedCodexAccountId ?? await resolveCodexAccountId(file);
    if (accountId) header['Chatgpt-Account-Id'] = accountId;
  }
  const project = provider === 'antigravity' ? await resolveProjectId(file) : '';
  if (provider === 'antigravity' && !project) {
    throw new Error(quotaText('quota.service.error.missingProject'));
  }
  const urls = provider === 'antigravity'
    ? [endpointByProvider.antigravity, 'https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:retrieveUserQuotaSummary', 'https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary']
    : [endpointByProvider[provider]];
  let lastError = '';
  let hadSuccessfulResponse = false;
  for (const url of urls) {
    try {
      const payload = await requestQuotaPayload(
        authIndex,
        url,
        header,
        provider === 'antigravity' ? 'POST' : 'GET',
        project ? JSON.stringify({ project }) : undefined,
        undefined,
        provider === 'antigravity' ? responseClock : undefined,
      );
      if (provider === 'antigravity') {
        hadSuccessfulResponse = true;
        if (quotaRowsFor('antigravity', payload).length === 0) {
          lastError = quotaText('quota.service.error.antigravityEmpty');
          continue;
        }
      }
      return payload;
    } catch (error) {
      lastError = error instanceof Error ? error.message : String(error);
    }
  }
  throw new Error(
    lastError || quotaText(
      hadSuccessfulResponse
        ? 'quota.service.error.upstreamEmpty'
        : 'quota.service.error.noResponse',
    ),
  );
}

const callCodexResetCredits = async (
  file: AuthFile,
  accountId: string,
): Promise<ReturnType<typeof codexResetCreditDetailsFor>> => {
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) throw new Error(quotaText('quota.service.error.missingResetAuthIndex'));
  const header: Record<string, string> = {
    ...headersByProvider.codex,
    Accept: 'application/json',
    'OpenAI-Beta': 'codex-1',
    Originator: 'Codex Desktop',
  };
  if (accountId) header['Chatgpt-Account-Id'] = accountId;
  const payload = await requestQuotaPayload(authIndex, CODEX_RESET_CREDITS_URL, header, 'GET', undefined, 8_000);
  if (!isRecord(payload) || !['credits', 'available_count', 'availableCount', 'applicable_available_count', 'applicableAvailableCount'].some((key) => key in payload)) {
    throw new Error(quotaText('quota.service.error.resetCreditsInvalid'));
  }
  return codexResetCreditDetailsFor(payload);
};

async function loadQuotaSnapshot(file: AuthFile): Promise<QuotaState> {
  const provider = providerForFile(file);
  if (!provider) {
    return {
      status: 'error',
      rows: [],
      error: quotaText('quota.service.error.unsupportedProvider'),
    };
  }
  try {
    if (booleanValue(file.disabled) === true) throw new Error(quotaText('quota.fileDisabled'));
    const codexMetadata = provider === 'codex' ? codexMetadataFor(file) : undefined;
    const codexAccountId = codexMetadata?.accountId || '';
    const responseClock: { serverTimeOffsetMs?: number } = {};
    const payloadPromise = provider === 'xai'
      ? callXaiQuota(file)
      : callUpstreamQuota(file, provider, codexAccountId, responseClock);
    const planPromise = provider === 'claude'
      ? loadClaudePlan(file)
      : provider === 'antigravity'
        ? loadAntigravityPlan(file)
        : Promise.resolve(undefined);
    let resetCreditsError: string | undefined;
    const resetCreditsPromise = provider === 'codex'
      ? callCodexResetCredits(file, codexAccountId).catch((error) => {
        resetCreditsError = error instanceof Error ? error.message : String(error);
        return null;
      })
      : Promise.resolve(null);
    const [payload, detectedPlan, resetCreditDetails] = await Promise.all([
      payloadPromise,
      planPromise,
      resetCreditsPromise,
    ]);
    const rows = quotaRowsFor(provider, payload);
    if (rows.length === 0) {
      return {
        status: 'error',
        rows: [],
        error: quotaText('quota.service.error.unrecognized'),
      };
    }
    const resetCredits = provider === 'codex'
      ? resetCreditDetails?.availableCount ?? codexResetCreditsFor(payload)
      : undefined;
    const usageCreditDetails = provider === 'codex' && isRecord(payload)
      ? codexResetCreditDetailsFor(payload.rate_limit_reset_credits ?? payload.rateLimitResetCredits)
      : {};
    return {
      status: 'success',
      rows,
      plan: detectedPlan
        ?? (readString(isRecord(payload) ? payload : {}, 'plan_type', 'planType') || codexMetadata?.plan),
      subscriptionActiveUntil: codexMetadata?.subscriptionActiveUntil,
      resetCreditsError,
      resetCreditsApplicable: usageCreditDetails.applicableAvailableCount
        ?? resetCreditDetails?.applicableAvailableCount ?? resetCredits,
      resetCredits,
      resetCreditsEarliestExpiry: resetCreditDetails?.earliestExpiry,
      serverTimeOffsetMs: responseClock.serverTimeOffsetMs,
      fetchedAt: Date.now(),
    };
  } catch (error) {
    return {
      status: 'error',
      rows: [],
      error: error instanceof Error ? error.message : String(error),
    };
  }
}

const createRedeemRequestId = () => {
  if (typeof globalThis.crypto?.randomUUID === 'function') return globalThis.crypto.randomUUID();
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (character) => {
    const random = Math.floor(Math.random() * 16);
    const value = character === 'x' ? random : (random & 0x3) | 0x8;
    return value.toString(16);
  });
};

async function consumeCodexResetCreditSnapshot(file: AuthFile): Promise<QuotaState> {
  if (providerForFile(file) !== 'codex') {
    throw new Error(quotaText('quota.service.error.codexResetOnly'));
  }
  if (booleanValue(file.disabled) === true) throw new Error(quotaText('quota.fileDisabled'));
  const authIndex = normalizeAuthIndex(file.auth_index ?? file.authIndex);
  if (!authIndex) throw new Error(quotaText('quota.service.error.missingConsumeAuthIndex'));
  const header = {
    ...headersByProvider.codex,
  };
  const accountId = await resolveCodexAccountId(file);
  if (accountId) header['Chatgpt-Account-Id'] = accountId;
  await requestQuotaPayload(
    authIndex,
    CODEX_RESET_CREDITS_CONSUME_URL,
    header,
    'POST',
    JSON.stringify({ redeem_request_id: createRedeemRequestId() }),
  );
  return loadQuotaSnapshot(file);
}

const quotaRequests = new Map<string, Promise<QuotaState>>();
const quotaMutationRequests = new Map<string, Promise<QuotaState>>();

export function loadQuota(file: AuthFile): Promise<QuotaState> {
  const key = quotaKey(file);
  const reset = quotaMutationRequests.get(key);
  if (reset) return reset.catch((error): QuotaState => ({
    status: 'error', rows: [], error: error instanceof Error ? error.message : String(error),
  }));
  const existing = quotaRequests.get(key);
  if (existing) return existing;
  const request = loadQuotaSnapshot(file).finally(() => {
    if (quotaRequests.get(key) === request) quotaRequests.delete(key);
  });
  quotaRequests.set(key, request);
  return request;
}

function runQuotaMutation(file: AuthFile, mutate: () => Promise<QuotaState>): Promise<QuotaState> {
  const key = quotaKey(file);
  const existing = quotaMutationRequests.get(key);
  if (existing) return existing;
  const request = (async () => {
    await quotaRequests.get(key);
    return mutate();
  })().finally(() => {
    if (quotaMutationRequests.get(key) === request) quotaMutationRequests.delete(key);
  });
  quotaMutationRequests.set(key, request);
  return request;
}

export function consumeCodexResetCredit(file: AuthFile): Promise<QuotaState> {
  return runQuotaMutation(file, () => consumeCodexResetCreditSnapshot(file));
}