// bcrypt でのパスワードハッシュ化
import bcrypt from 'bcrypt';
 
// ハッシュ化（登録時）
const BCRYPT_ROUNDS = 12; // コストファクター
 
async function hashPassword(password: string): Promise<string> {
  // bcrypt は自動でソルトを生成
  // $2b$12$[22文字のソルト][31文字のハッシュ]
  return bcrypt.hash(password, BCRYPT_ROUNDS);
}
 
// 検証（ログイン時）
async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}
 
// Argon2id でのパスワードハッシュ化
import argon2 from 'argon2';
 
async function hashPasswordArgon2(password: string): Promise<string> {
  return argon2.hash(password, {
    type: argon2.argon2id,    // Argon2id（推奨バリアント）
    memoryCost: 65536,        // 64MB のメモリ使用
    timeCost: 3,              // 3回の反復
    parallelism: 4,           // 4並列
  });
}
 
async function verifyPasswordArgon2(password: string, hash: string): Promise<boolean> {
  return argon2.verify(hash, password);
}
 
// ハッシュ関数の自動判別（マイグレーション対応）
async function verifyPasswordAuto(password: string, hash: string): Promise<{
  valid: boolean;
  needsRehash: boolean;
}> {
  let valid: boolean;
  let needsRehash = false;
 
  if (hash.startsWith('$argon2')) {
    valid = await argon2.verify(hash, password);
    needsRehash = argon2.needsRehash(hash, {
      type: argon2.argon2id,
      memoryCost: 65536,
      timeCost: 3,
      parallelism: 4,
    });
  } else if (hash.startsWith('$2')) {
    valid = await bcrypt.compare(password, hash);
    // bcrypt から Argon2 への移行を示す
    needsRehash = true;
  } else {
    throw new Error('Unknown hash format');
  }
 
  return { valid, needsRehash };
}
 
// ログイン時のハッシュ自動アップグレード
async function loginWithHashUpgrade(email: string, password: string) {
  const user = await prisma.user.findUnique({ where: { email } });
  if (!user?.password) return null;
 
  const { valid, needsRehash } = await verifyPasswordAuto(password, user.password);
  if (!valid) return null;
 
  // ハッシュのアップグレード（バックグラウンドで実行）
  if (needsRehash) {
    const newHash = await hashPasswordArgon2(password);
    await prisma.user.update({
      where: { id: user.id },
      data: { password: newHash },
    });
  }
 
  return user;
}

// NIST準拠のパスワードバリデーション
import { z } from 'zod';
 
// 漏洩パスワードチェック（Have I Been Pwned API）
async function isPasswordBreached(password: string): Promise<boolean> {
  const hash = crypto.createHash('sha1').update(password).digest('hex').toUpperCase();
  const prefix = hash.substring(0, 5);
  const suffix = hash.substring(5);
 
  // k-Anonymity: プレフィックスのみ送信（パスワード自体は送信しない）
  const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`);
  const text = await res.text();
 
  // レスポンスからサフィックスを検索
  return text.split('\n').some((line) => {
    const [hashSuffix, count] = line.split(':');
    return hashSuffix.trim() === suffix;
  });
}
 
// パスワード強度の計算
function calculatePasswordStrength(password: string): {
  score: number; // 0-4
  feedback: string[];
} {
  const feedback: string[] = [];
  let score = 0;
 
  // 長さ
  if (password.length >= 8) score += 1;
  if (password.length >= 12) score += 1;
  if (password.length >= 16) score += 1;
  if (password.length < 8) feedback.push('8文字以上にしてください');
 
  // 文字種の多様性
  const hasLower = /[a-z]/.test(password);
  const hasUpper = /[A-Z]/.test(password);
  const hasDigit = /[0-9]/.test(password);
  const hasSymbol = /[^a-zA-Z0-9]/.test(password);
  const charTypes = [hasLower, hasUpper, hasDigit, hasSymbol].filter(Boolean).length;
  if (charTypes >= 3) score += 1;
 
  // 繰り返し文字
  if (/(.)\1{2,}/.test(password)) {
    feedback.push('同じ文字の繰り返しを避けてください');
  }
 
  // 一般的なパターン
  const commonPatterns = [
    /^123456/,
    /^password/i,
    /^qwerty/i,
    /^abcdef/i,
  ];
  if (commonPatterns.some((p) => p.test(password))) {
    score = Math.max(0, score - 2);
    feedback.push('一般的なパスワードパターンを避けてください');
  }
 
  return { score: Math.min(4, Math.max(0, score)), feedback };
}
 
// 登録フォームのバリデーション
const registerSchema = z.object({
  name: z.string().min(1, '名前を入力してください').max(100),
  email: z.string().email('有効なメールアドレスを入力してください'),
  password: z.string()
    .min(8, 'パスワードは8文字以上必要です')
    .max(128, 'パスワードは128文字以下にしてください')
    .refine(
      (val) => !/(.)\1{2,}/.test(val),
      '同じ文字を3回以上連続して使用できません'
    ),
  confirmPassword: z.string(),
}).refine((data) => data.password === data.confirmPassword, {
  message: 'パスワードが一致しません',
  path: ['confirmPassword'],
});

// 登録 Server Action
'use server';
import bcrypt from 'bcrypt';
import crypto from 'crypto';
 
async function register(formData: FormData) {
  // 1. バリデーション
  const parsed = registerSchema.safeParse({
    name: formData.get('name'),
    email: formData.get('email'),
    password: formData.get('password'),
    confirmPassword: formData.get('confirmPassword'),
  });
 
  if (!parsed.success) {
    return { error: parsed.error.flatten().fieldErrors };
  }
 
  const { name, email, password } = parsed.data;
 
  // 2. 漏洩パスワードチェック
  const breached = await isPasswordBreached(password);
  if (breached) {
    return {
      error: {
        password: ['このパスワードは漏洩データベースに含まれています。別のパスワードを使用してください'],
      },
    };
  }
 
  // 3. メールの重複チェック
  const existingUser = await prisma.user.findUnique({ where: { email } });
  if (existingUser) {
    // ユーザー列挙攻撃を防止するため、同じメッセージを返す
    // 既存ユーザーには「このメールは既に登録されています」メールを送信
    if (existingUser.emailVerified) {
      await sendEmail({
        to: email,
        subject: 'アカウント登録の試行',
        html: `
          <p>${email} で既にアカウントが登録されています。</p>
          <p>ログインは <a href="${process.env.APP_URL}/login">こちら</a> から。</p>
          <p>パスワードをお忘れの場合は <a href="${process.env.APP_URL}/forgot-password">リセット</a> してください。</p>
        `,
      });
    }
    return { success: true, message: '確認メールを送信しました' };
  }
 
  // 4. パスワードハッシュ化
  const hashedPassword = await bcrypt.hash(password, 12);
 
  // 5. ユーザー作成
  const user = await prisma.user.create({
    data: {
      name,
      email,
      password: hashedPassword,
      role: 'viewer',
      emailVerified: null, // 未確認
    },
  });
 
  // 6. メール確認トークン生成
  const verificationToken = crypto.randomBytes(32).toString('hex');
  const hashedToken = crypto.createHash('sha256').update(verificationToken).digest('hex');
 
  await prisma.verificationToken.create({
    data: {
      identifier: email,
      token: hashedToken,
      expires: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24時間
    },
  });
 
  // 7. 確認メール送信
  await sendEmail({
    to: email,
    subject: 'メールアドレスの確認',
    html: `
      <h1>メールアドレスの確認</h1>
      <p>${name} さん、ご登録ありがとうございます。</p>
      <p>以下のリンクをクリックしてメールアドレスを確認してください：</p>
      <a href="${process.env.APP_URL}/verify-email?token=${verificationToken}">
        メールアドレスを確認
      </a>
      <p>このリンクは24時間有効です。</p>
      <p>このメールに心当たりがない場合は無視してください。</p>
    `,
  });
 
  return { success: true, message: '確認メールを送信しました' };
}

// タイミング攻撃対策
async function loginSafe(email: string, password: string) {
  const user = await prisma.user.findUnique({ where: { email } });
 
  if (!user?.password) {
    // ユーザーが存在しなくても bcrypt.compare を実行
    // → レスポンス時間を均一にしてタイミング攻撃を防止
    await bcrypt.compare(password, '$2b$12$dummy.hash.for.timing.protection');
    return { error: 'メールアドレスまたはパスワードが正しくありません' };
  }
 
  const isValid = await bcrypt.compare(password, user.password);
  if (!isValid) {
    return { error: 'メールアドレスまたはパスワードが正しくありません' };
  }
 
  return { user };
}

// メール確認処理
async function verifyEmail(token: string) {
  const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
  const verificationToken = await prisma.verificationToken.findFirst({
    where: {
      token: hashedToken,
      expires: { gt: new Date() },
    },
  });
 
  if (!verificationToken) {
    return { error: '無効または期限切れのリンクです' };
  }
 
  // トランザクションでメールを確認済みに更新 + トークン削除
  await prisma.$transaction([
    prisma.user.update({
      where: { email: verificationToken.identifier },
      data: { emailVerified: new Date() },
    }),
    prisma.verificationToken.delete({
      where: { id: verificationToken.id },
    }),
  ]);
 
  return { success: true };
}
 
// メール確認の再送信
async function resendVerificationEmail(email: string) {
  const user = await prisma.user.findUnique({ where: { email } });
 
  // ユーザーが存在しない or 既に確認済みでも同じレスポンス
  if (!user || user.emailVerified) {
    return { message: '確認メールを送信しました（メールが登録されている場合）' };
  }
 
  // レート制限: 同じメールへの再送は1時間に3回まで
  const recentTokens = await prisma.verificationToken.count({
    where: {
      identifier: email,
      expires: { gt: new Date(Date.now() - 60 * 60 * 1000) },
    },
  });
 
  if (recentTokens >= 3) {
    return { message: '確認メールを送信しました（メールが登録されている場合）' };
  }
 
  // 既存トークンを削除
  await prisma.verificationToken.deleteMany({
    where: { identifier: email },
  });
 
  // 新しいトークン生成
  const verificationToken = crypto.randomBytes(32).toString('hex');
  const hashedToken = crypto.createHash('sha256').update(verificationToken).digest('hex');
 
  await prisma.verificationToken.create({
    data: {
      identifier: email,
      token: hashedToken,
      expires: new Date(Date.now() + 24 * 60 * 60 * 1000),
    },
  });
 
  await sendEmail({
    to: email,
    subject: 'メールアドレスの確認',
    html: `
      <h1>メールアドレスの確認</h1>
      <p>以下のリンクをクリックしてメールアドレスを確認してください：</p>
      <a href="${process.env.APP_URL}/verify-email?token=${verificationToken}">
        メールアドレスを確認
      </a>
      <p>このリンクは24時間有効です。</p>
    `,
  });
 
  return { message: '確認メールを送信しました（メールが登録されている場合）' };
}
 
// メール確認ページ
async function VerifyEmailPage({ searchParams }: { searchParams: { token?: string } }) {
  if (!searchParams.token) {
    return <p>無効なリンクです。</p>;
  }
 
  const result = await verifyEmail(searchParams.token);
 
  if (result.error) {
    return (
      <div>
        <h1>確認に失敗しました</h1>
        <p>{result.error}</p>
        <Link href="/resend-verification">確認メールを再送信</Link>
      </div>
    );
  }
 
  return (
    <div>
      <h1>メールアドレスが確認されました</h1>
      <Link href="/login">ログインする</Link>
    </div>
  );
}

// 多層レート制限の設計
// Layer 1: グローバルレート制限（IP ベース）
// Layer 2: アカウントレート制限（メールベース）
// Layer 3: アカウントロック（DB ベース）
 
interface RateLimitResult {
  allowed: boolean;
  remaining: number;
  resetAt: Date;
  retryAfter?: number; // 秒
}
 
class LoginRateLimiter {
  constructor(private redis: Redis) {}
 
  // Layer 1: IP ベースのレート制限
  async checkIPLimit(ip: string): Promise<RateLimitResult> {
    const key = `login:ip:${ip}`;
    const limit = 20;     // 15分間に20回まで
    const window = 900;   // 15分
 
    const current = await this.redis.incr(key);
    if (current === 1) {
      await this.redis.expire(key, window);
    }
 
    const ttl = await this.redis.ttl(key);
 
    return {
      allowed: current <= limit,
      remaining: Math.max(0, limit - current),
      resetAt: new Date(Date.now() + ttl * 1000),
      retryAfter: current > limit ? ttl : undefined,
    };
  }
 
  // Layer 2: メールベースのレート制限
  async checkEmailLimit(email: string): Promise<RateLimitResult> {
    const key = `login:email:${email}`;
    const limit = 5;      // 15分間に5回まで
    const window = 900;   // 15分
 
    const current = await this.redis.incr(key);
    if (current === 1) {
      await this.redis.expire(key, window);
    }
 
    const ttl = await this.redis.ttl(key);
 
    return {
      allowed: current <= limit,
      remaining: Math.max(0, limit - current),
      resetAt: new Date(Date.now() + ttl * 1000),
      retryAfter: current > limit ? ttl : undefined,
    };
  }
 
  // 成功時にカウントをリセット
  async resetOnSuccess(email: string): Promise<void> {
    await this.redis.del(`login:email:${email}`);
  }
}
 
// ログイン処理（Auth.js Credentials プロバイダー）
async function authorize(credentials: { email: string; password: string }, req: Request) {
  const { email, password } = credentials;
  const ip = getClientIP(req);
 
  // Layer 1: IP レート制限
  const ipLimit = await rateLimiter.checkIPLimit(ip);
  if (!ipLimit.allowed) {
    throw new Error(`Too many requests. Try again in ${ipLimit.retryAfter} seconds.`);
  }
 
  // Layer 2: メールレート制限
  const emailLimit = await rateLimiter.checkEmailLimit(email);
  if (!emailLimit.allowed) {
    throw new Error(`Too many login attempts. Try again in ${emailLimit.retryAfter} seconds.`);
  }
 
  // ユーザー取得
  const user = await prisma.user.findUnique({ where: { email } });
 
  if (!user?.password) {
    // タイミング攻撃対策: ダミーの bcrypt 比較
    await bcrypt.compare(password, '$2b$12$dummy.hash.for.timing.attack.prevention.only');
    return null;
  }
 
  // Layer 3: アカウントロックチェック
  if (user.lockedUntil && user.lockedUntil > new Date()) {
    const remainingMinutes = Math.ceil((user.lockedUntil.getTime() - Date.now()) / 60000);
    throw new Error(`Account is locked. Try again in ${remainingMinutes} minutes.`);
  }
 
  // パスワード検証
  const isValid = await bcrypt.compare(password, user.password);
 
  if (!isValid) {
    // 失敗回数を記録
    const failedAttempts = (user.failedLoginAttempts || 0) + 1;
    const updateData: any = { failedLoginAttempts: failedAttempts };
 
    // 10回失敗でアカウントロック
    if (failedAttempts >= 10) {
      updateData.lockedUntil = new Date(Date.now() + 30 * 60 * 1000); // 30分
 
      // アカウントロック通知
      await sendSecurityNotification(user.id, 'account_locked');
    }
 
    await prisma.user.update({
      where: { id: user.id },
      data: updateData,
    });
 
    return null;
  }
 
  // メール未確認チェック
  if (!user.emailVerified) {
    throw new Error('Please verify your email before logging in.');
  }
 
  // ログイン成功: 失敗カウントリセット
  await prisma.user.update({
    where: { id: user.id },
    data: {
      failedLoginAttempts: 0,
      lockedUntil: null,
      lastLoginAt: new Date(),
      lastLoginIp: ip,
    },
  });
 
  // レート制限カウントリセット
  await rateLimiter.resetOnSuccess(email);
 
  // 新しいデバイスからのログイン検知
  const knownDevice = await isKnownDevice(user.id, req);
  if (!knownDevice) {
    await sendSecurityNotification(user.id, 'new_device');
    await recordDevice(user.id, req);
  }
 
  return {
    id: user.id,
    email: user.email,
    name: user.name,
    image: user.image,
    role: user.role,
  };
}

// デバイスフィンガープリント（簡易版）
interface DeviceFingerprint {
  userAgent: string;
  ipPrefix: string; // /24 サブネット
  acceptLanguage: string;
}
 
function generateDeviceFingerprint(req: Request): string {
  const fp: DeviceFingerprint = {
    userAgent: req.headers.get('user-agent') || '',
    ipPrefix: getClientIP(req).split('.').slice(0, 3).join('.'), // /24
    acceptLanguage: req.headers.get('accept-language') || '',
  };
 
  return crypto
    .createHash('sha256')
    .update(JSON.stringify(fp))
    .digest('hex')
    .substring(0, 16);
}
 
async function isKnownDevice(userId: string, req: Request): Promise<boolean> {
  const fingerprint = generateDeviceFingerprint(req);
 
  const device = await prisma.knownDevice.findFirst({
    where: {
      userId,
      fingerprint,
      lastSeenAt: { gt: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) }, // 90日以内
    },
  });
 
  return !!device;
}
 
async function recordDevice(userId: string, req: Request): Promise<void> {
  const fingerprint = generateDeviceFingerprint(req);
 
  await prisma.knownDevice.upsert({
    where: { userId_fingerprint: { userId, fingerprint } },
    create: {
      userId,
      fingerprint,
      userAgent: req.headers.get('user-agent') || '',
      ipAddress: getClientIP(req),
      lastSeenAt: new Date(),
    },
    update: {
      lastSeenAt: new Date(),
      ipAddress: getClientIP(req),
    },
  });
}

// パスワードリセット要求
'use server';
 
async function requestPasswordReset(email: string) {
  // レート制限
  const key = `password_reset:${email}`;
  const attempts = await redis.get(key);
  if (attempts && parseInt(attempts) >= 3) {
    // 常に同じメッセージ（ユーザー列挙防止）
    return { message: 'メールアドレスが登録されていればリセットメールを送信しました' };
  }
  await redis.incr(key);
  await redis.expire(key, 3600); // 1時間
 
  // ユーザーの存在に関わらず同じレスポンス
  const user = await prisma.user.findUnique({ where: { email } });
 
  if (user) {
    // 既存のリセットトークンを削除
    await prisma.passwordResetToken.deleteMany({
      where: { userId: user.id },
    });
 
    const token = crypto.randomBytes(32).toString('hex');
    const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
    await prisma.passwordResetToken.create({
      data: {
        userId: user.id,
        token: hashedToken,
        expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 1時間
      },
    });
 
    await sendEmail({
      to: email,
      subject: 'パスワードリセット',
      html: `
        <h1>パスワードリセット</h1>
        <p>以下のリンクからパスワードをリセットしてください（1時間有効）:</p>
        <a href="${process.env.APP_URL}/reset-password?token=${token}">
          パスワードをリセット
        </a>
        <p>このリクエストに心当たりがない場合は無視してください。</p>
        <p>パスワードは変更されません。</p>
      `,
    });
  }
 
  // 常に同じメッセージ（ユーザー列挙防止）
  return { message: 'メールアドレスが登録されていればリセットメールを送信しました' };
}
 
// パスワードリセット実行
async function resetPassword(token: string, newPassword: string) {
  // バリデーション
  if (newPassword.length < 8 || newPassword.length > 128) {
    return { error: 'パスワードは8文字以上128文字以下にしてください' };
  }
 
  // 漏洩チェック
  const breached = await isPasswordBreached(newPassword);
  if (breached) {
    return { error: 'このパスワードは漏洩データベースに含まれています' };
  }
 
  const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
  const resetToken = await prisma.passwordResetToken.findFirst({
    where: {
      token: hashedToken,
      expiresAt: { gt: new Date() },
    },
    include: { user: true },
  });
 
  if (!resetToken) {
    return { error: '無効または期限切れのリンクです' };
  }
 
  // 新しいパスワードが前のパスワードと同じでないかチェック
  const isSame = await bcrypt.compare(newPassword, resetToken.user.password!);
  if (isSame) {
    return { error: '前のパスワードとは異なるパスワードを設定してください' };
  }
 
  const hashedPassword = await bcrypt.hash(newPassword, 12);
 
  await prisma.$transaction([
    // パスワード更新
    prisma.user.update({
      where: { id: resetToken.userId },
      data: {
        password: hashedPassword,
        failedLoginAttempts: 0,
        lockedUntil: null,
        passwordChangedAt: new Date(),
      },
    }),
    // トークン削除
    prisma.passwordResetToken.deleteMany({
      where: { userId: resetToken.userId },
    }),
    // 全セッション無効化（パスワード変更後は全デバイスからログアウト）
    prisma.session.deleteMany({
      where: { userId: resetToken.userId },
    }),
  ]);
 
  // パスワード変更通知メール
  await sendEmail({
    to: resetToken.user.email!,
    subject: 'パスワードが変更されました',
    html: `
      <p>パスワードが正常に変更されました。</p>
      <p>日時: ${new Date().toLocaleString('ja-JP', { timeZone: 'Asia/Tokyo' })}</p>
      <p>この変更に心当たりがない場合は、直ちに
        <a href="${process.env.APP_URL}/forgot-password">パスワードをリセット</a>
        するか、サポートにご連絡ください。
      </p>
    `,
  });
 
  return { success: true };
}

// パスワード変更（要現在のパスワード）
'use server';
 
const changePasswordSchema = z.object({
  currentPassword: z.string().min(1),
  newPassword: z.string().min(8).max(128),
  confirmPassword: z.string(),
}).refine((data) => data.newPassword === data.confirmPassword, {
  message: 'パスワードが一致しません',
  path: ['confirmPassword'],
}).refine((data) => data.currentPassword !== data.newPassword, {
  message: '現在のパスワードと異なるパスワードを設定してください',
  path: ['newPassword'],
});
 
async function changePassword(formData: FormData) {
  const session = await auth();
  if (!session) throw new Error('Unauthorized');
 
  const parsed = changePasswordSchema.safeParse({
    currentPassword: formData.get('currentPassword'),
    newPassword: formData.get('newPassword'),
    confirmPassword: formData.get('confirmPassword'),
  });
 
  if (!parsed.success) {
    return { error: parsed.error.flatten().fieldErrors };
  }
 
  // 漏洩チェック
  const breached = await isPasswordBreached(parsed.data.newPassword);
  if (breached) {
    return { error: { newPassword: ['このパスワードは漏洩データベースに含まれています'] } };
  }
 
  const user = await prisma.user.findUnique({
    where: { id: session.user.id },
  });
 
  // 現在のパスワードを検証
  const isValid = await bcrypt.compare(parsed.data.currentPassword, user!.password!);
  if (!isValid) {
    return { error: { currentPassword: ['現在のパスワードが正しくありません'] } };
  }
 
  // 新しいパスワードで更新
  const hashedPassword = await bcrypt.hash(parsed.data.newPassword, 12);
 
  await prisma.$transaction([
    prisma.user.update({
      where: { id: session.user.id },
      data: {
        password: hashedPassword,
        passwordChangedAt: new Date(),
      },
    }),
    // 現在のセッション以外を無効化
    prisma.session.deleteMany({
      where: {
        userId: session.user.id,
        id: { not: session.sessionId },
      },
    }),
  ]);
 
  // 通知
  await sendSecurityNotification(session.user.id, 'password_change');
 
  return { success: true };
}

// 重要なアカウントイベントの通知
async function sendSecurityNotification(
  userId: string,
  event: 'login' | 'password_change' | 'email_change' | 'new_device' | 'account_locked'
) {
  const user = await prisma.user.findUnique({ where: { id: userId } });
  if (!user?.email) return;
 
  const messages = {
    login: {
      subject: '新しいログインがありました',
      body: '新しいデバイスからログインがありました。',
    },
    password_change: {
      subject: 'パスワードが変更されました',
      body: 'パスワードが正常に変更されました。',
    },
    email_change: {
      subject: 'メールアドレスが変更されました',
      body: 'アカウントのメールアドレスが変更されました。',
    },
    new_device: {
      subject: '新しいデバイスからのアクセス',
      body: '認識されていないデバイスからアクセスがありました。',
    },
    account_locked: {
      subject: 'アカウントがロックされました',
      body: 'ログイン試行の失敗が多数あり、アカウントが一時的にロックされました。30分後に自動解除されます。',
    },
  };
 
  const { subject, body } = messages[event];
 
  // 監査ログ
  await prisma.securityEvent.create({
    data: {
      userId,
      event,
      timestamp: new Date(),
      metadata: { notificationSent: true },
    },
  });
 
  await sendEmail({
    to: user.email,
    subject,
    html: `
      <p>${body}</p>
      <p>日時: ${new Date().toLocaleString('ja-JP', { timeZone: 'Asia/Tokyo' })}</p>
      <p>心当たりがない場合は、直ちにパスワードを変更してください。</p>
      <a href="${process.env.APP_URL}/settings/security">セキュリティ設定</a>
    `,
  });
}

// Prisma スキーマ（認証関連の完全版）
// schema.prisma
 
/*
model User {
  id                   String    @id @default(cuid())
  email                String    @unique
  name                 String?
  password             String?   // ソーシャルログインユーザーは null
  image                String?
  role                 String    @default("viewer")
  emailVerified        DateTime?
  failedLoginAttempts  Int       @default(0)
  lockedUntil          DateTime?
  lastLoginAt          DateTime?
  lastLoginIp          String?
  passwordChangedAt    DateTime?
  createdAt            DateTime  @default(now())
  updatedAt            DateTime  @updatedAt
 
  sessions             Session[]
  accounts             Account[]
  verificationTokens   VerificationToken[]
  passwordResetTokens  PasswordResetToken[]
  knownDevices         KnownDevice[]
  securityEvents       SecurityEvent[]
}
 
model Session {
  id        String   @id @default(cuid())
  userId    String
  token     String   @unique
  expiresAt DateTime
  createdAt DateTime @default(now())
  ipAddress String?
  userAgent String?
 
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
}
 
model VerificationToken {
  id         String   @id @default(cuid())
  identifier String   // email
  token      String   // SHA-256 ハッシュ
  expires    DateTime
 
  @@unique([identifier, token])
}
 
model PasswordResetToken {
  id        String   @id @default(cuid())
  userId    String
  token     String   // SHA-256 ハッシュ
  expiresAt DateTime
  createdAt DateTime @default(now())
 
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
}
 
model KnownDevice {
  id          String   @id @default(cuid())
  userId      String
  fingerprint String
  userAgent   String
  ipAddress   String
  lastSeenAt  DateTime
 
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
 
  @@unique([userId, fingerprint])
}
 
model SecurityEvent {
  id        String   @id @default(cuid())
  userId    String
  event     String
  timestamp DateTime @default(now())
  metadata  Json?
 
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
 
  @@index([userId, timestamp])
}
*/

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]