sailfork / t3code-github / apps/ mobile/ src/ features/ usage/ UsageLimitsSection.tsx

import * as Dialog from "../../components/ui/Dialog";
import { RegistryContext, useAtomMount, useAtomValue } from "@effect/atom-react";
import { normalizeProviderAccentColor } from "@t3tools/client-runtime/state/provider-instance-display";
import {
  AuthProvidersManageScope,
  type EnvironmentId,
  type ProviderConsumeResetCreditOutcome,
  type ProviderConsumeResetCreditInput,
  type ServerProvider,
  type ServerProviderResetCredits,
  type ServerProviderUsageWindow,
} from "@t3tools/contracts";
import {
  formatDuration,
  formatResetsIn,
  limitsNotice,
  paceOf,
  paceRemainingPercent,
  remainingPercent,
} from "@t3tools/shared/usageLimits";
import { type ReactNode, useContext, useRef, useState } from "react";
import { Atom } from "effect/reactivity";
import { Linking, Pressable, View } from "react-native";

import { AppText as Text } from "../../components/ui/AppText";
import { ProviderIcon } from "../../components/ProviderIcon";
import { environmentPresentations } from "../../state/presentation";
import { serverEnvironment } from "../../state/server";
import { readEnvironmentScope, useEnvironmentScope } from "../../state/session";
import { useAtomCommand } from "../../state/use-atom-command";
import { useNowMinuteMs } from "../../lib/clock";
import {
  environmentIdsKey,
  limitsAutoRefreshSetAtom,
  limitsRefreshFailuresAtom,
  refreshEnvironmentLimits,
} from "./usageLimitsRefresh";
import { usageProviderKind, useProviderColors } from "./usageProviders";

const PACE_LABEL = { ahead: "ahead of pace", on: "on pace", under: "under pace" } as const;

type Driver = ServerProvider["driver"];

function useBarColor(driver: Driver): string | null {
  const colors = useProviderColors();
  const kind = usageProviderKind(driver);
  return kind ? colors[kind] : null;
}

function WindowRow(props: {
  readonly window: ServerProviderUsageWindow;
  readonly color: string | null;
  readonly now: number;
}) {
  const { window, now } = props;
  const remaining = remainingPercent(window);
  const timeLeft = paceRemainingPercent(window, now);
  const pace = paceOf(window, now);
  const resetsIn = formatResetsIn(window, now);
  const [barWidth, setBarWidth] = useState(0);
  const tickX =
    timeLeft === null || barWidth < 6
      ? null
      : Math.min(Math.max((barWidth * timeLeft) / 100, 3), barWidth - 3);
  const bar = (
    <View
      className="h-1.5 flex-row overflow-hidden rounded-full bg-subtle"
      style={barWidth > 0 ? { width: barWidth } : undefined}
    >
      <View
        className={
          remaining <= 10
            ? "h-full rounded-full bg-red-500"
            : remaining <= 30
              ? "h-full rounded-full bg-amber-500"
              : "h-full rounded-full bg-foreground"
        }
        style={[
          { flex: remaining },
          remaining > 30 && props.color ? { backgroundColor: props.color } : null,
        ]}
      />
      <View style={{ flex: 100 - remaining }} />
    </View>
  );
  return (
    <View className="gap-1">
      <View className="flex-row items-baseline justify-between gap-3">
        <Text className="text-sm text-foreground">{window.label}</Text>
        <Text className="text-sm font-t3-medium tabular-nums text-foreground">
          {remaining}% left
        </Text>
      </View>
      <View
        className="h-3 justify-center"
        onLayout={(event) => setBarWidth(event.nativeEvent.layout.width)}
      >
        {tickX === null ? (
          bar
        ) : (
          <View className="h-1.5">
            {/* Clip the same full-width bar so neither fill proportions nor corner radii change. */}
            {(
              [
                [0, tickX - 3],
                [tickX + 3, barWidth],
              ] as const
            ).map(([start, end]) => (
              <View
                key={start}
                className="absolute top-0 bottom-0 overflow-hidden"
                style={{ left: start, width: end - start }}
              >
                <View style={{ marginLeft: -start }}>{bar}</View>
              </View>
            ))}
          </View>
        )}
        {tickX !== null ? (
          <View
            className="absolute top-px bottom-px w-0.5 rounded-full bg-foreground"
            style={{ left: tickX - 1 }}
          />
        ) : null}
      </View>
      {pace || resetsIn ? (
        <View className="flex-row justify-between gap-3">
          <Text className="text-xs text-foreground-tertiary">{pace ? PACE_LABEL[pace] : ""}</Text>
          <Text className="text-xs tabular-nums text-foreground-tertiary">{resetsIn ?? ""}</Text>
        </View>
      ) : null}
    </View>
  );
}

function AccountInstanceLabel({ value }: { readonly value: string }) {
  const [revealed, setRevealed] = useState(false);
  if (!value.includes("@")) {
    return (
      <Text className="shrink text-xs text-foreground-tertiary" numberOfLines={1}>
        · {value}
      </Text>
    );
  }
  return (
    <Pressable
      className="shrink active:opacity-60"
      accessibilityRole="button"
      accessibilityLabel={revealed ? "Hide account label" : "Reveal account label"}
      onPress={() => setRevealed((current) => !current)}
    >
      <Text className="text-xs text-foreground-tertiary" numberOfLines={1}>
        · {revealed ? value : "••••••@••••••"}
      </Text>
    </Pressable>
  );
}

export function AccountLimits(props: {
  readonly driver: Driver;
  readonly accentColor?: string | undefined;
  readonly label: string;
  readonly instanceLabel: string;
  readonly detail: string | undefined;
  readonly limits: ServerProvider["usageLimits"];
  readonly now: number;
  readonly first: boolean;
  readonly dense?: boolean;
  readonly trailing?: ReactNode;
  readonly footer?: ReactNode;
}) {
  const { limits, now, dense = false } = props;
  const providerColor = useBarColor(props.driver);
  const color = normalizeProviderAccentColor(props.accentColor) ?? providerColor;
  if (!limits) return null;
  const notice = limitsNotice(limits);
  const externalUsage = limits.externalUsage;
  const padding = dense ? "px-4 py-3" : "p-4";
  return (
    <View
      className={
        props.first ? `gap-3 ${padding}` : `gap-3 border-t border-border-subtle ${padding}`
      }
    >
      <View className="flex-row items-center gap-2">
        <ProviderIcon provider={props.driver} size={16} />
        <View className="min-w-0 flex-1 flex-row items-baseline gap-2">
          <Text className="text-base font-t3-medium text-foreground">{props.label}</Text>
          {props.instanceLabel !== props.label ? (
            <AccountInstanceLabel key={props.instanceLabel} value={props.instanceLabel} />
          ) : null}
          {props.detail ? (
            <Text className="shrink text-sm text-foreground-muted" numberOfLines={1}>
              · {props.detail}
            </Text>
          ) : null}
        </View>
        {props.trailing}
      </View>
      {notice ? (
        <Text className="text-sm text-foreground-muted">{notice}</Text>
      ) : (
        <View className="gap-3">
          {limits.windows.map((window) => (
            <WindowRow key={window.id} window={window} color={color} now={now} />
          ))}
        </View>
      )}
      {externalUsage ? (
        <Pressable
          accessibilityRole="link"
          className="min-h-11 justify-center"
          onPress={() => void Linking.openURL(externalUsage.url).catch(() => undefined)}
        >
          <Text className="text-sm font-t3-medium text-primary">Manage usage</Text>
        </Pressable>
      ) : null}
      {props.footer}
    </View>
  );
}

const OUTCOME_TEXT: Record<ProviderConsumeResetCreditOutcome, string> = {
  reset: "Reset applied. Your windows have cleared.",
  nothingToReset: "Nothing to reset right now.",
  noCredit: "No reset credit left.",
  alreadyRedeemed: "That credit was already redeemed.",
};

export function ResetCredits(props: {
  readonly environmentId: EnvironmentId;
  readonly input: ProviderConsumeResetCreditInput;
  readonly credits: ServerProviderResetCredits;
  readonly now: number;
  readonly dense?: boolean;
}) {
  const { environmentId, input, credits, now, dense = false } = props;
  const canManageProviders = useEnvironmentScope(environmentId, AuthProvidersManageScope);
  const consume = useAtomCommand(serverEnvironment.consumeResetCredit, {
    reportFailure: false,
  });
  const [busy, setBusy] = useState(false);
  const [status, setStatus] = useState<string | null>(null);
  if (dense && credits.availableCount === 0 && status === null) return null;

  const expiresIn = credits.nextExpiresAt
    ? formatDuration(Date.parse(credits.nextExpiresAt) - now)
    : null;
  const summary =
    credits.availableCount === 0
      ? "No reset credits banked"
      : `${credits.availableCount} ${credits.availableCount === 1 ? "reset credit" : "reset credits"} banked${
          expiresIn ? ` · next expires in ${expiresIn}` : ""
        }`;

  const redeem = async () => {
    if (!readEnvironmentScope(environmentId, AuthProvidersManageScope)) return;
    setBusy(true);
    setStatus(null);
    const result = await consume({ environmentId, input });
    setBusy(false);
    if (result._tag === "Success") {
      setStatus(result.value.warning ?? OUTCOME_TEXT[result.value.outcome]);
      return;
    }
    setStatus(
      "error" in result.cause && result.cause.error instanceof Error
        ? result.cause.error.message
        : "Could not use the reset credit.",
    );
  };

  const confirm = () => {
    if (!readEnvironmentScope(environmentId, AuthProvidersManageScope)) return;
    Dialog.alert(
      "Use a reset credit?",
      "This redeems one credit on your account and clears the current rate-limit windows. It cannot be undone.",
      [
        { text: "Cancel", style: "cancel" },
        { text: "Use credit", onPress: () => void redeem() },
      ],
    );
  };

  return (
    <View className="flex-row flex-wrap items-center gap-x-3 gap-y-1">
      <Text className="text-xs tabular-nums text-foreground-tertiary">{summary}</Text>
      {credits.availableCount > 0 ? (
        <Pressable
          accessibilityRole="button"
          accessibilityState={{ disabled: busy || !canManageProviders }}
          disabled={busy || !canManageProviders}
          onPress={confirm}
          className={
            dense
              ? "rounded-full bg-subtle-strong px-2.5 py-1 disabled:opacity-[0.45]"
              : "min-h-[44px] justify-center rounded-full bg-subtle-strong px-3 py-1.5 disabled:opacity-[0.45]"
          }
        >
          <Text
            className={
              dense
                ? "text-xs font-t3-medium text-foreground"
                : "text-sm font-t3-medium text-foreground"
            }
          >
            {busy ? "Using…" : "Use reset"}
          </Text>
        </Pressable>
      ) : null}
      {!canManageProviders ? (
        <Text className="text-xs text-foreground-tertiary">
          This connection cannot manage provider accounts.
        </Text>
      ) : null}
      {status ? <Text className="text-sm text-foreground">{status}</Text> : null}
    </View>
  );
}

const IDLE_ATOM = Atom.make(undefined);

export function useRefreshLimits(
  selectedEnvironmentIds: ReadonlySet<EnvironmentId> | null = null,
  active = false,
) {
  const registry = useContext(RegistryContext);
  const presentations = useAtomValue(environmentPresentations.presentationsAtom);
  const now = useNowMinuteMs();
  const [refreshing, setRefreshing] = useState(false);
  const refreshingRef = useRef(false);
  const selected = [...presentations].filter(
    ([environmentId]) =>
      selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId),
  );
  const connectedIds = selected
    .filter(([, presentation]) => presentation.connection.phase === "connected")
    .map(([environmentId]) => environmentId);
  const connectedKey = environmentIdsKey(connectedIds);
  useAtomMount(active && connectedKey !== "" ? limitsAutoRefreshSetAtom(connectedKey) : IDLE_ATOM);
  const failedIds = new Set(
    useAtomValue(limitsRefreshFailuresAtom(environmentIdsKey(selected.map(([id]) => id)))),
  );
  const failedLabels = selected
    .filter(([environmentId]) => failedIds.has(environmentId))
    .map(([, presentation]) => presentation.entry.target.label);

  const refresh = (afterPending: boolean) =>
    Promise.all(
      connectedIds.map((environmentId) =>
        refreshEnvironmentLimits(registry, environmentId, { afterPending }),
      ),
    );
  // Android RefreshControl needs a true-to-false cycle to stop, even with nothing to probe.
  const refreshManually = async () => {
    if (refreshingRef.current) return;
    refreshingRef.current = true;
    setRefreshing(true);
    await refresh(false).finally(() => {
      refreshingRef.current = false;
      setRefreshing(false);
    });
  };
  return {
    now,
    refreshing,
    failedLabels,
    refresh: refreshManually,
    refreshAfterEnable: () => refresh(true),
  };
}