第十六章　多账户 Profile 系统

// apps/frontend/src/shared/types/unified-account.ts（概念化）

type UnifiedAccount = {
  id: string;          // 'oauth:profile-id' 或 'api:profile-id'
  type: 'oauth' | 'api';
  displayName: string;

  // 可用性状态
  isAuthenticated: boolean;
  isAvailable: boolean;
  isRateLimited: boolean;
  rateLimitType?: 'session' | 'weekly';

  // 用量指标（OAuth 账户专有）
  weeklyPercent?: number;   // 当前周用量百分比
  sessionPercent?: number;  // 当前会话用量百分比
};

// apps/frontend/src/main/claude-profile/profile-scorer.ts（简化）

function scoreUnifiedAccount(
  account: UnifiedAccount,
  priorityIndex: number,
  settings: ClaudeAutoSwitchSettings
): ScoredUnifiedAccount {
  let score = 100;

  // 门 1：认证状态（最关键）
  if (!account.isAuthenticated) {
    score = -1000;  // 未认证，基本不可用
    return { account, score, priorityIndex, isAvailable: false };
  }

  // 门 2：Rate Limit 状态
  if (account.isRateLimited) {
    if (account.rateLimitType === 'weekly') {
      score = -500;  // 周限额更严重（重置慢）
    } else {
      score = -200;  // 会话限额，较快恢复
    }
  }

  // 门 3：用量阈值（默认：Session 95%，Weekly 99%）
  if (account.weeklyPercent !== undefined &&
      account.weeklyPercent >= settings.weeklyThreshold) {
    isOverThreshold = true;
  }
  if (account.sessionPercent !== undefined &&
      account.sessionPercent >= settings.sessionThreshold) {
    isOverThreshold = true;
  }

  // 用量越高，分数越低（即使未达阈值也有惩罚）
  score -= (account.weeklyPercent ?? 0) * 0.3;
  score -= (account.sessionPercent ?? 0) * 0.1;

  const isAvailable = score > 0 && !account.isRateLimited && !isOverThreshold;
  return { account, score, priorityIndex, isAvailable };
}

// 降级评分：从 100 开始扣分
function calculateFallbackScore(profile, settings): number {
  let score = 100;

  if (!isProfileAuthenticated(profile)) {
    score -= 1000;  // 未认证最差
  }

  const rateLimitStatus = isProfileRateLimited(profile);
  if (rateLimitStatus.limited) {
    if (rateLimitStatus.type === 'weekly') {
      score -= 500;  // 周限额扣 500
    } else {
      score -= 200;  // 会话限额扣 200
    }

    // 越快重置的账户，降级得分越高
    if (rateLimitStatus.resetAt) {
      const hoursUntilReset = (resetAt - now) / 3600000;
      score += Math.max(0, 50 - hoursUntilReset); // 1小时内重置：+49分
    }
  }

  // 用量惩罚
  score -= profile.usage.weeklyUsagePercent * 0.3;
  score -= profile.usage.sessionUsagePercent * 0.1;

  return score;
}

// apps/frontend/src/main/claude-profile/token-refresh.ts

// 主动刷新阈值：到期前 30 分钟
const PROACTIVE_REFRESH_THRESHOLD_MS = 30 * 60 * 1000;

export function isTokenExpiredOrNearExpiry(
  expiresAt: number | null,
  thresholdMs = PROACTIVE_REFRESH_THRESHOLD_MS
): boolean {
  // 不知道过期时间 → 保守假设已过期（宁可多刷新，不能用过期 token）
  if (expiresAt === null) return true;

  const expiryThreshold = expiresAt - thresholdMs;
  return Date.now() >= expiryThreshold;
}

export async function refreshOAuthToken(
  refreshToken: string,
  configDir?: string
): Promise<TokenRefreshResult> {
  const MAX_REFRESH_RETRIES = 2;
  const RETRY_DELAY_BASE_MS = 1000;

  for (let attempt = 0; attempt <= MAX_REFRESH_RETRIES; attempt++) {
    if (attempt > 0) {
      // 指数退避：1s, 2s
      const delay = RETRY_DELAY_BASE_MS * 2 ** (attempt - 1);
      await new Promise(resolve => setTimeout(resolve, delay));
    }

    const body = new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: refreshToken,
      client_id: CLAUDE_CODE_CLIENT_ID  // 公开客户端 ID
    });

    const response = await fetch(ANTHROPIC_TOKEN_ENDPOINT, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: body.toString()
    });

    if (!response.ok) {
      const errorData = await response.json();
      const errorCode = errorData.error || `http_${response.status}`;

      // 不可重试的永久错误：立即返回
      if (errorCode === 'invalid_grant' || errorCode === 'invalid_client') {
        // 清除缓存中的过期凭据，防止无限循环
        clearKeychainCache(configDir);
        return { success: false, error: ..., errorCode };
      }

      // 临时错误：继续重试
      continue;
    }

    // 成功：立即写入 Keychain（旧 token 已被撤销！）
    const data = await response.json();
    // ... 存储新 token
  }
}

// 内存缓存：避免每次都读 Keychain（可能需要用户授权弹窗）
const keychainCache = new Map<string, FullCredentials>();

export async function getFullCredentialsFromKeychain(
  configDir: string
): Promise<FullCredentials | null> {
  // 先查缓存
  const cached = keychainCache.get(configDir);
  if (cached) return cached;

  // 从 OS Keychain 读取
  const credentials = await readFromKeychain(configDir);
  if (credentials) {
    keychainCache.set(configDir, credentials);
  }
  return credentials;
}

// Token 刷新后清除缓存，确保下次读到新 token
export function clearKeychainCache(configDir?: string): void {
  if (configDir) {
    keychainCache.delete(configDir);
  } else {
    keychainCache.clear(); // 错误恢复时清空所有缓存
  }
}

export function shouldProactivelySwitch(
  currentAccount: UnifiedAccount,
  settings: ClaudeAutoSwitchSettings
): boolean {
  // API 账户无限制，不需要切换
  if (currentAccount.type === 'api') return false;

  // 已经 rate limited，应该立即切换（被动切换处理）
  if (currentAccount.isRateLimited) return false;

  // 用量超过阈值：主动切换
  const weeklyClose = (currentAccount.weeklyPercent ?? 0) >= settings.weeklyThreshold;
  const sessionClose = (currentAccount.sessionPercent ?? 0) >= settings.sessionThreshold;

  return weeklyClose || sessionClose;
}

// lab16/account-selector.ts

export interface Account {
  id: string;
  name: string;
  isAuthenticated: boolean;
  isRateLimited: boolean;
  weeklyUsagePercent: number;  // 0-100
  sessionUsagePercent: number; // 0-100
}

export interface SelectionSettings {
  weeklyThreshold: number;    // 默认 99
  sessionThreshold: number;   // 默认 95
}

/**
 * 检查账户是否可用
 * 返回 { available: true } 或 { available: false, reason: string }
 */
export function checkAvailability(
  account: Account,
  settings: SelectionSettings
): { available: boolean; reason?: string } {
  // TODO Part A: 实现三重门检查
  // 1. 未认证 → 不可用
  // 2. Rate limited → 不可用
  // 3. 用量 >= 阈值 → 不可用（注意是 >=，不是 >）
  return { available: false };
}

/**
 * 降级评分（所有账户都不可用时用）
 * 分数越高越好
 */
export function calculateFallbackScore(account: Account): number {
  // TODO Part A:
  // - 从 100 开始
  // - 未认证：-1000
  // - Rate limited：-200（会话级）
  // - 用量越高，扣分越多
  return 0;
}

// lab16/account-selector.ts（续）

/**
 * 从账户列表中选择最优账户
 *
 * @param accounts - 所有账户列表
 * @param priorityOrder - 用户配置的优先级顺序（account ID 列表）
 * @param settings - 用量阈值设置
 * @param excludeId - 要排除的账户 ID（通常是当前失败的账户）
 * @returns 最优账户，如果都不可用则返回"最不坏"的
 */
export function selectBestAccount(
  accounts: Account[],
  priorityOrder: string[],
  settings: SelectionSettings,
  excludeId?: string
): Account | null {
  // TODO Part B:
  // 1. 过滤掉 excludeId
  // 2. 按 priorityOrder 排序（不在列表里的排最后）
  // 3. 找第一个通过 checkAvailability 的账户
  // 4. 如果没有：用 calculateFallbackScore 找最高分的作为降级选项
  return null;
}

// 验证：
const accounts: Account[] = [
  { id: 'a', name: 'Account A', isAuthenticated: true, isRateLimited: true,  weeklyUsagePercent: 50, sessionUsagePercent: 30 },
  { id: 'b', name: 'Account B', isAuthenticated: true, isRateLimited: false, weeklyUsagePercent: 20, sessionUsagePercent: 10 },
  { id: 'c', name: 'Account C', isAuthenticated: true, isRateLimited: false, weeklyUsagePercent: 96, sessionUsagePercent: 80 },
];
const settings: SelectionSettings = { weeklyThreshold: 95, sessionThreshold: 90 };
const priority = ['c', 'b', 'a']; // 用户配置 C 优先，但 C 超阈值

const result = selectBestAccount(accounts, priority, settings);
// 应选 B（C 超阈值不可用，A rate limited，B 可用且是候选中优先级最高的可用账户）
console.log(result?.id); // → 'b'

// lab16/token-utils.ts

const PROACTIVE_THRESHOLD_MS = 30 * 60 * 1000; // 30 分钟

/**
 * 检查 token 是否已过期或即将过期
 * @param expiresAt - 过期时间戳（ms），null 表示未知
 * @param thresholdMs - 提前刷新的时间窗口（默认 30 分钟）
 */
export function isTokenNearExpiry(
  expiresAt: number | null,
  thresholdMs: number = PROACTIVE_THRESHOLD_MS
): boolean {
  // TODO Part C: 实现检测逻辑
  // - null → 保守假设过期（返回 true）
  // - 距过期 <= thresholdMs → 返回 true
  return true;
}

/**
 * 格式化剩余时间，用于日志
 */
export function formatTimeRemaining(expiresAt: number | null): string {
  // TODO Part C:
  // - null → 'unknown'
  // - 已过期 → 'expired'
  // - >= 1小时 → '2h 30m'
  // - < 1小时 → '45m'
  return 'unknown';
}

// 验证：
const future30min = Date.now() + 30 * 60 * 1000;
const future1h = Date.now() + 60 * 60 * 1000;
const past = Date.now() - 1000;

console.log(isTokenNearExpiry(null));        // → true
console.log(isTokenNearExpiry(future30min)); // → true（刚好在阈值边界）
console.log(isTokenNearExpiry(future1h));    // → false
console.log(isTokenNearExpiry(past));        // → true（已过期）

console.log(formatTimeRemaining(future1h));  // → '1h 0m'（或类似）
console.log(formatTimeRemaining(null));      // → 'unknown'