vmall/apps/mobile/utils/payment.ts

import type { Payment } from "@vmall/shared";

const LAST_PAYMENT_ID_KEY = "vmall.lastPaymentId";
const CHECKOUT_IDEMPOTENCY_KEY = "vmall.checkout.idem";
const ATTEMPT_KEY_PREFIX = "vmall.pay.attempt.";

export function rememberPaymentId(paymentId: string): void {
  if (!import.meta.client || !paymentId) return;
  localStorage.setItem(LAST_PAYMENT_ID_KEY, paymentId);
}

export function rememberedPaymentId(): string {
  if (!import.meta.client) return "";
  return localStorage.getItem(LAST_PAYMENT_ID_KEY) ?? "";
}

export function paymentIdFromQuery(value: unknown): string {
  if (typeof value === "string" && value.trim()) return value;
  if (Array.isArray(value)) {
    const first = value.find((item): item is string => typeof item === "string" && item.trim() !== "");
    if (first) return first;
  }
  return rememberedPaymentId();
}

export function newIdempotencyKey(): string {
  if (import.meta.client && typeof crypto.randomUUID === "function") return crypto.randomUUID();
  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
}

export function checkoutIdempotencyRecord(): { key: string; hash: string } | null {
  if (!import.meta.client) return null;
  const raw = localStorage.getItem(CHECKOUT_IDEMPOTENCY_KEY);
  if (!raw) return null;
  try {
    const parsed: unknown = JSON.parse(raw);
    if (
      parsed &&
      typeof parsed === "object" &&
      "key" in parsed &&
      "hash" in parsed &&
      typeof parsed.key === "string" &&
      typeof parsed.hash === "string"
    ) {
      return { key: parsed.key, hash: parsed.hash };
    }
  } catch {
    localStorage.removeItem(CHECKOUT_IDEMPOTENCY_KEY);
  }
  return null;
}

export function storeCheckoutIdempotency(record: { key: string; hash: string }): void {
  if (!import.meta.client) return;
  localStorage.setItem(CHECKOUT_IDEMPOTENCY_KEY, JSON.stringify(record));
}

export function clearCheckoutIdempotency(): void {
  if (!import.meta.client) return;
  localStorage.removeItem(CHECKOUT_IDEMPOTENCY_KEY);
}

export function attemptIdempotencyKey(paymentId: string, channelId: string): string {
  if (!import.meta.client) return newIdempotencyKey();
  const storageKey = `${ATTEMPT_KEY_PREFIX}${encodeURIComponent(paymentId)}.${encodeURIComponent(channelId)}`;
  const existing = localStorage.getItem(storageKey);
  if (existing) return existing;
  const key = newIdempotencyKey();
  localStorage.setItem(storageKey, key);
  return key;
}

export function rotateAttemptIdempotencyKey(paymentId: string, channelId: string): void {
  if (!import.meta.client) return;
  localStorage.removeItem(`${ATTEMPT_KEY_PREFIX}${encodeURIComponent(paymentId)}.${encodeURIComponent(channelId)}`);
}

/** Whether the payment has an unresolved collection attempt. */
export function paymentHasUnresolvedAttempt(payment: Payment): boolean {
  return payment.status === "unapplied" && payment.attempts.some(
    (attempt) => ["created", "pending", "unknown"].includes(attempt.status),
  );
}

export function stableStringify(value: unknown): string {
  if (value === undefined) return "null";
  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
  const record = value as Record<string, unknown>;
  return `{${Object.keys(record)
    .sort()
    .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
    .join(",")}}`;
}