// auth.ts - Google プロバイダーの完全設定
import Google from 'next-auth/providers/google';
import type { NextAuthConfig } from 'next-auth';
 
export const googleProvider = Google({
  clientId: process.env.GOOGLE_CLIENT_ID!,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
 
  // 認可パラメータのカスタマイズ
  authorization: {
    params: {
      scope: 'openid email profile',
      prompt: 'consent',         // 毎回同意画面を表示（Refresh Token 取得に必要）
      access_type: 'offline',    // Refresh Token を取得
      response_type: 'code',     // Authorization Code Flow
      // hd: 'mycompany.com',    // 特定ドメインに限定（Google Workspace）
    },
  },
 
  // ID Token から取得するプロフィール情報のマッピング
  profile(profile) {
    return {
      id: profile.sub,                        // Google の一意識別子
      name: profile.name,                     // フルネーム
      email: profile.email,                   // メールアドレス
      image: profile.picture,                 // アバター URL
      emailVerified: profile.email_verified,  // メール検証済みフラグ
      // カスタムフィールド
      role: 'viewer',                         // デフォルトロール
      locale: profile.locale,                 // ロケール（ja, en 等）
    };
  },
});

// Google Workspace ドメイン制限の実装
callbacks: {
  async signIn({ account, profile }) {
    if (account?.provider === 'google') {
      // 特定ドメインのみ許可
      const allowedDomains = ['mycompany.com', 'partner.com'];
      const email = profile?.email;
 
      if (!email) return false;
 
      const domain = email.split('@')[1];
      if (!allowedDomains.includes(domain)) {
        return '/login?error=DomainNotAllowed';
      }
 
      // email_verified チェック
      if (!profile?.email_verified) {
        return '/login?error=EmailNotVerified';
      }
    }
    return true;
  },
}

// Google Refresh Token Rotation の実装
import { google } from 'googleapis';
 
async function refreshGoogleAccessToken(refreshToken: string) {
  const oauth2Client = new google.auth.OAuth2(
    process.env.GOOGLE_CLIENT_ID,
    process.env.GOOGLE_CLIENT_SECRET,
  );
 
  oauth2Client.setCredentials({
    refresh_token: refreshToken,
  });
 
  try {
    const { credentials } = await oauth2Client.refreshAccessToken();
 
    return {
      access_token: credentials.access_token!,
      expires_at: Math.floor(credentials.expiry_date! / 1000),
      refresh_token: credentials.refresh_token ?? refreshToken,
      // Google は Refresh Token を毎回返さない場合がある
      // → 既存の Refresh Token を保持
    };
  } catch (error) {
    console.error('Failed to refresh Google access token:', error);
    throw error;
  }
}
 
// Auth.js の jwt コールバックで使用
callbacks: {
  async jwt({ token, account }) {
    // 初回ログイン時: トークンを保存
    if (account) {
      return {
        ...token,
        access_token: account.access_token,
        expires_at: account.expires_at,
        refresh_token: account.refresh_token,
        provider: account.provider,
      };
    }
 
    // Access Token が有効な場合はそのまま返す
    if (token.expires_at && Date.now() < (token.expires_at as number) * 1000) {
      return token;
    }
 
    // Access Token が期限切れの場合はリフレッシュ
    if (token.provider === 'google' && token.refresh_token) {
      try {
        const refreshed = await refreshGoogleAccessToken(
          token.refresh_token as string
        );
        return {
          ...token,
          access_token: refreshed.access_token,
          expires_at: refreshed.expires_at,
          refresh_token: refreshed.refresh_token,
        };
      } catch {
        // リフレッシュ失敗 → 再ログインを促す
        return { ...token, error: 'RefreshAccessTokenError' };
      }
    }
 
    return token;
  },
}

// auth.ts - GitHub プロバイダーの完全設定
import GitHub from 'next-auth/providers/github';
 
export const githubProvider = GitHub({
  clientId: process.env.GITHUB_CLIENT_ID!,
  clientSecret: process.env.GITHUB_CLIENT_SECRET!,
 
  // スコープ設定
  authorization: {
    params: {
      scope: 'read:user user:email',
    },
  },
 
  // GitHub は OpenID Connect ではないため、/user API レスポンスを使用
  profile(profile) {
    return {
      id: String(profile.id),              // GitHub の数値 ID を文字列に
      name: profile.name || profile.login,  // name が null なら login を使用
      email: profile.email,                 // null の場合がある（後述）
      image: profile.avatar_url,            // アバター URL
      role: 'viewer',                       // デフォルトロール
    };
  },
});

// GitHub メール取得の完全実装
callbacks: {
  async signIn({ user, account, profile }) {
    // GitHub プロバイダーでメールが null の場合の対処
    if (account?.provider === 'github' && !user.email) {
      try {
        // GitHub API でメール一覧を取得
        const emailRes = await fetch('https://api.github.com/user/emails', {
          headers: {
            Authorization: `Bearer ${account.access_token}`,
            Accept: 'application/vnd.github+json',
            'X-GitHub-Api-Version': '2022-11-28',
          },
        });
 
        if (!emailRes.ok) {
          console.error('Failed to fetch GitHub emails:', emailRes.status);
          return '/login?error=EmailFetchFailed';
        }
 
        const emails: Array<{
          email: string;
          primary: boolean;
          verified: boolean;
          visibility: string | null;
        }> = await emailRes.json();
 
        // 優先順位: primary + verified > verified > primary
        const primary = emails.find((e) => e.primary && e.verified);
        const verified = emails.find((e) => e.verified);
 
        const selectedEmail = primary?.email ?? verified?.email;
 
        if (selectedEmail) {
          user.email = selectedEmail;
        } else {
          // 検証済みメールがない場合はログインを拒否
          return '/login?error=NoVerifiedEmail';
        }
      } catch (error) {
        console.error('Error fetching GitHub emails:', error);
        return '/login?error=EmailFetchFailed';
      }
    }
    return true;
  },
}

// GitHub 組織メンバーシップを検証してアクセスを制限
async function checkGitHubOrgMembership(
  accessToken: string,
  allowedOrgs: string[]
): Promise<boolean> {
  const orgsRes = await fetch('https://api.github.com/user/orgs', {
    headers: {
      Authorization: `Bearer ${accessToken}`,
      Accept: 'application/vnd.github+json',
    },
  });
 
  if (!orgsRes.ok) return false;
 
  const orgs: Array<{ login: string }> = await orgsRes.json();
  return orgs.some((org) => allowedOrgs.includes(org.login));
}
 
// Auth.js コールバックで使用
callbacks: {
  async signIn({ account }) {
    if (account?.provider === 'github') {
      const isMember = await checkGitHubOrgMembership(
        account.access_token!,
        ['my-company', 'my-team']
      );
 
      if (!isMember) {
        return '/login?error=OrgMembershipRequired';
      }
    }
    return true;
  },
}

// GitHub の特定チームメンバーシップ確認
async function checkGitHubTeamMembership(
  accessToken: string,
  org: string,
  teamSlug: string
): Promise<boolean> {
  // 自分のチームメンバーシップを確認
  const res = await fetch(
    `https://api.github.com/orgs/${org}/teams/${teamSlug}/memberships/${username}`,
    {
      headers: {
        Authorization: `Bearer ${accessToken}`,
        Accept: 'application/vnd.github+json',
      },
    }
  );
 
  if (!res.ok) return false;
 
  const data = await res.json();
  return data.state === 'active';
}
 
// チームに基づくロール割り当て
async function assignRoleByTeam(
  accessToken: string,
  org: string
): Promise<string> {
  // admin チームのメンバーか確認
  if (await checkGitHubTeamMembership(accessToken, org, 'admin')) {
    return 'admin';
  }
 
  // editors チームのメンバーか確認
  if (await checkGitHubTeamMembership(accessToken, org, 'editors')) {
    return 'editor';
  }
 
  // それ以外は viewer
  return 'viewer';
}

// auth.ts - Apple プロバイダーの完全設定
import Apple from 'next-auth/providers/apple';
 
export const appleProvider = Apple({
  clientId: process.env.APPLE_CLIENT_ID!,
  // clientSecret は動的に生成する必要がある
  clientSecret: generateAppleClientSecret(),
});
 
// Apple clientSecret の生成
// p8 秘密鍵から ES256 JWT を生成
import * as jose from 'jose';
 
async function generateAppleClientSecret(): Promise<string> {
  // 環境変数から秘密鍵を取得（改行を復元）
  const privateKeyPem = process.env.APPLE_PRIVATE_KEY!.replace(/\\n/g, '\n');
 
  // PKCS#8 形式の秘密鍵をインポート
  const privateKey = await jose.importPKCS8(privateKeyPem, 'ES256');
 
  // JWT を生成
  const jwt = await new jose.SignJWT({})
    .setProtectedHeader({
      alg: 'ES256',
      kid: process.env.APPLE_KEY_ID!,  // Key ID
    })
    .setIssuedAt()
    .setExpirationTime('180d')  // 最大 6 ヶ月
    .setAudience('https://appleid.apple.com')
    .setIssuer(process.env.APPLE_TEAM_ID!)   // Team ID
    .setSubject(process.env.APPLE_CLIENT_ID!) // Services ID
    .sign(privateKey);
 
  return jwt;
}

// Apple ログインの初回データ保存実装
callbacks: {
  async signIn({ user, account, profile }) {
    if (account?.provider === 'apple') {
      // Apple の profile は初回のみ name を含む
      const appleProfile = profile as {
        sub: string;
        email?: string;
        email_verified?: boolean;
        is_private_email?: string;
      };
 
      // user オブジェクトには Auth.js が name を設定済み
      // （POST ボディの user パラメータから取得）
 
      const existingUser = await prisma.user.findFirst({
        where: {
          accounts: {
            some: {
              provider: 'apple',
              providerAccountId: appleProfile.sub,
            },
          },
        },
      });
 
      if (!existingUser && user.email) {
        // 新規ユーザー: Private Relay メールのフラグを保存
        await prisma.user.create({
          data: {
            email: user.email,
            name: user.name,
            image: user.image,
            isPrivateEmail: appleProfile.is_private_email === 'true',
          },
        });
      }
    }
    return true;
  },
}

// Apple Private Relay メールへの送信設定
// Apple にリレーメール送信元として登録が必要
 
// メール送信時の分岐
async function sendEmail(to: string, subject: string, body: string) {
  const isAppleRelay = to.endsWith('@privaterelay.appleid.com');
 
  if (isAppleRelay) {
    // Apple Relay 経由の場合、送信元ドメインが登録済みである必要がある
    // From: noreply@myapp.com（Apple に登録したドメイン）
    await sendViaRegisteredDomain(to, subject, body);
  } else {
    await sendNormally(to, subject, body);
  }
}

// Microsoft プロバイダー設定
import MicrosoftEntraID from 'next-auth/providers/microsoft-entra-id';
 
MicrosoftEntraID({
  clientId: process.env.AZURE_AD_CLIENT_ID!,
  clientSecret: process.env.AZURE_AD_CLIENT_SECRET!,
  // テナント ID（特定組織のみ許可する場合）
  tenantId: process.env.AZURE_AD_TENANT_ID,
  // 'common': 全 Microsoft アカウント
  // 'organizations': 組織アカウントのみ
  // 'consumers': 個人アカウントのみ
  // 特定テナントID: その組織のみ
 
  authorization: {
    params: {
      scope: 'openid email profile User.Read',
    },
  },
 
  profile(profile) {
    return {
      id: profile.sub,
      name: profile.name,
      email: profile.email,
      image: null, // Microsoft は picture を直接返さない
      role: 'viewer',
    };
  },
});

// Discord プロバイダー設定
import Discord from 'next-auth/providers/discord';
 
Discord({
  clientId: process.env.DISCORD_CLIENT_ID!,
  clientSecret: process.env.DISCORD_CLIENT_SECRET!,
 
  authorization: {
    params: {
      scope: 'identify email guilds', // guilds でサーバー情報も取得可能
    },
  },
 
  profile(profile) {
    // Discord のアバター URL 構築
    const avatarUrl = profile.avatar
      ? `https://cdn.discordapp.com/avatars/${profile.id}/${profile.avatar}.${
          profile.avatar.startsWith('a_') ? 'gif' : 'png'
        }`
      : `https://cdn.discordapp.com/embed/avatars/${
          Number(profile.discriminator) % 5
        }.png`;
 
    return {
      id: profile.id,
      name: profile.username,
      email: profile.email,
      image: avatarUrl,
      role: 'viewer',
    };
  },
});

// 条件付き自動アカウントリンクの完全実装
// auth.ts
 
import { PrismaAdapter } from '@auth/prisma-adapter';
import type { Account, Profile, User } from 'next-auth';
 
export const authConfig = {
  adapter: PrismaAdapter(prisma),
 
  callbacks: {
    async signIn({
      user,
      account,
      profile,
    }: {
      user: User;
      account: Account | null;
      profile?: Profile;
    }) {
      if (!account || !user.email) return true;
 
      // 同じメールの既存ユーザーをチェック
      const existingUser = await prisma.user.findUnique({
        where: { email: user.email },
        include: {
          accounts: {
            select: {
              provider: true,
              providerAccountId: true,
            },
          },
        },
      });
 
      // 新規ユーザーの場合はそのまま
      if (!existingUser) return true;
 
      // 既にこのプロバイダーでリンク済みの場合はそのまま
      const isLinked = existingUser.accounts.some(
        (a) => a.provider === account.provider
      );
      if (isLinked) return true;
 
      // メールの検証状態を確認
      const isEmailVerified = checkEmailVerification(
        account.provider,
        profile
      );
 
      if (!isEmailVerified) {
        // 検証されていない場合: エラーページにリダイレクト
        return `/login?error=OAuthAccountNotLinked&provider=${account.provider}`;
      }
 
      // 検証済みの場合: 既存ユーザーにアカウントをリンク
      try {
        await prisma.account.create({
          data: {
            userId: existingUser.id,
            type: account.type,
            provider: account.provider,
            providerAccountId: account.providerAccountId,
            access_token: account.access_token,
            refresh_token: account.refresh_token,
            expires_at: account.expires_at,
            token_type: account.token_type,
            scope: account.scope,
            id_token: account.id_token,
          },
        });
 
        // リンクイベントを記録
        await prisma.auditLog.create({
          data: {
            userId: existingUser.id,
            action: 'account_linked',
            metadata: {
              provider: account.provider,
              providerAccountId: account.providerAccountId,
              linkedAt: new Date().toISOString(),
            },
          },
        });
 
        // Auth.js のユーザー ID を既存ユーザーに合わせる
        user.id = existingUser.id;
      } catch (error) {
        console.error('Failed to link account:', error);
        return '/login?error=LinkFailed';
      }
 
      return true;
    },
  },
};
 
// プロバイダーごとのメール検証チェック
function checkEmailVerification(
  provider: string,
  profile?: Profile
): boolean {
  switch (provider) {
    case 'google':
      // Google: email_verified フィールドで判定
      return (profile as any)?.email_verified === true;
 
    case 'github':
      // GitHub: /user/emails API で verified のみ返すため
      // user:email スコープがあれば検証済みとみなせる
      return true;
 
    case 'apple':
      // Apple: email_verified は常に true（Apple が保証）
      return (profile as any)?.email_verified === true;
 
    case 'microsoft-entra-id':
      // Microsoft: email_verified フィールドで判定
      return (profile as any)?.email_verified === true;
 
    default:
      // 不明なプロバイダーは安全側に倒す
      return false;
  }
}

// app/settings/accounts/page.tsx - アカウント管理画面（Server Component）
import { auth } from '@/auth';
import { redirect } from 'next/navigation';
import { LinkedAccountsList } from './linked-accounts-list';
 
export default async function AccountSettingsPage() {
  const session = await auth();
  if (!session) redirect('/login');
 
  // ユーザーのリンク済みアカウントを取得
  const accounts = await prisma.account.findMany({
    where: { userId: session.user.id },
    select: {
      id: true,
      provider: true,
      providerAccountId: true,
      createdAt: true,
    },
    orderBy: { createdAt: 'asc' },
  });
 
  // パスワードの有無を確認
  const user = await prisma.user.findUnique({
    where: { id: session.user.id },
    select: { password: true },
  });
 
  const hasPassword = !!user?.password;
  const canUnlink = accounts.length > 1 || hasPassword;
 
  return (
    <div>
      <h1>アカウント連携</h1>
      <LinkedAccountsList
        accounts={accounts}
        canUnlink={canUnlink}
      />
    </div>
  );
}

// app/settings/accounts/actions.ts - Server Actions
'use server';
 
import { auth, signIn } from '@/auth';
import { revalidatePath } from 'next/cache';
 
// アカウントリンク開始
export async function linkAccount(provider: string) {
  const session = await auth();
  if (!session) throw new Error('Unauthorized');
 
  // signIn を呼び出してOAuthフローを開始
  await signIn(provider, {
    redirectTo: '/settings/accounts',
  });
}
 
// アカウントリンク解除
export async function unlinkAccount(
  _prevState: any,
  formData: FormData
): Promise<{ error?: string; success?: boolean }> {
  const session = await auth();
  if (!session) return { error: 'Unauthorized' };
 
  const provider = formData.get('provider') as string;
  if (!provider) return { error: 'Provider is required' };
 
  // リンク済みアカウント数を確認
  const accountCount = await prisma.account.count({
    where: { userId: session.user.id },
  });
 
  // パスワードの有無を確認
  const user = await prisma.user.findUnique({
    where: { id: session.user.id },
    select: { password: true },
  });
 
  // 最後のログイン方法は削除不可
  if (accountCount <= 1 && !user?.password) {
    return {
      error: 'ログイン方法が他にないため、この連携は解除できません。',
    };
  }
 
  try {
    await prisma.account.deleteMany({
      where: {
        userId: session.user.id,
        provider,
      },
    });
 
    // 監査ログ
    await prisma.auditLog.create({
      data: {
        userId: session.user.id,
        action: 'account_unlinked',
        metadata: { provider },
      },
    });
 
    revalidatePath('/settings/accounts');
    return { success: true };
  } catch {
    return { error: 'アカウント連携の解除に失敗しました。' };
  }
}

// app/settings/accounts/linked-accounts-list.tsx - クライアントコンポーネント
'use client';
 
import { useActionState } from 'react';
import { linkAccount, unlinkAccount } from './actions';
 
const providerInfo: Record<string, { name: string; icon: string; color: string }> = {
  google:   { name: 'Google',    icon: '/icons/google.svg',  color: '#4285F4' },
  github:   { name: 'GitHub',    icon: '/icons/github.svg',  color: '#333333' },
  apple:    { name: 'Apple',     icon: '/icons/apple.svg',   color: '#000000' },
  discord:  { name: 'Discord',   icon: '/icons/discord.svg', color: '#5865F2' },
};
 
const allProviders = ['google', 'github', 'apple'];
 
export function LinkedAccountsList({
  accounts,
  canUnlink,
}: {
  accounts: Array<{ id: string; provider: string; createdAt: Date }>;
  canUnlink: boolean;
}) {
  const [state, dispatch] = useActionState(unlinkAccount, {});
 
  const linkedProviders = new Set(accounts.map((a) => a.provider));
  const unlinkedProviders = allProviders.filter((p) => !linkedProviders.has(p));
 
  return (
    <div className="space-y-4">
      {/* リンク済みアカウント */}
      <h2>連携済みアカウント</h2>
      {accounts.map((account) => {
        const info = providerInfo[account.provider];
        return (
          <div key={account.id} className="flex items-center justify-between p-4 border rounded">
            <div className="flex items-center gap-3">
              <img src={info?.icon} alt="" className="w-6 h-6" />
              <span>{info?.name ?? account.provider}</span>
              <span className="text-sm text-gray-500">
                連携日: {new Date(account.createdAt).toLocaleDateString('ja-JP')}
              </span>
            </div>
            {canUnlink && (
              <form action={dispatch}>
                <input type="hidden" name="provider" value={account.provider} />
                <button type="submit" className="text-red-500 hover:text-red-700">
                  連携解除
                </button>
              </form>
            )}
          </div>
        );
      })}
 
      {/* 未リンクのプロバイダー */}
      {unlinkedProviders.length > 0 && (
        <>
          <h2>追加の連携</h2>
          {unlinkedProviders.map((provider) => {
            const info = providerInfo[provider];
            return (
              <div key={provider} className="flex items-center justify-between p-4 border rounded">
                <div className="flex items-center gap-3">
                  <img src={info?.icon} alt="" className="w-6 h-6" />
                  <span>{info?.name ?? provider}</span>
                </div>
                <form action={() => linkAccount(provider)}>
                  <button type="submit" className="text-blue-500 hover:text-blue-700">
                    連携する
                  </button>
                </form>
              </div>
            );
          })}
        </>
      )}
 
      {state.error && (
        <p className="text-red-500">{state.error}</p>
      )}
    </div>
  );
}

// プロフィール同期の完全実装
// 各ログイン時にプロバイダーからの最新情報でプロフィールを更新
 
callbacks: {
  async signIn({ user, account, profile }) {
    if (!account || !user.id) return true;
 
    // プロフィール同期データの構築
    const syncData: Record<string, any> = {
      lastLoginAt: new Date(),
      lastLoginProvider: account.provider,
    };
 
    // プロバイダーごとのプロフィール情報取得
    switch (account.provider) {
      case 'google': {
        const googleProfile = profile as {
          name?: string;
          picture?: string;
          locale?: string;
        };
        if (googleProfile.name) syncData.name = googleProfile.name;
        if (googleProfile.picture) syncData.image = googleProfile.picture;
        if (googleProfile.locale) syncData.locale = googleProfile.locale;
        break;
      }
 
      case 'github': {
        const githubProfile = profile as {
          name?: string;
          login: string;
          avatar_url?: string;
          bio?: string;
          company?: string;
          location?: string;
          blog?: string;
        };
        if (githubProfile.name) syncData.name = githubProfile.name;
        if (githubProfile.avatar_url) syncData.image = githubProfile.avatar_url;
        // 追加フィールド（スキーマに存在する場合）
        if (githubProfile.bio) syncData.bio = githubProfile.bio;
        if (githubProfile.company) syncData.company = githubProfile.company;
        break;
      }
 
      case 'apple': {
        // Apple は 2 回目以降 name を返さないため、既存データを上書きしない
        // sub のみで識別
        break;
      }
    }
 
    // メールは変更しない（セキュリティ上の理由）
    // → メール変更は別のフローで行う
 
    try {
      await prisma.user.update({
        where: { id: user.id },
        data: syncData,
      });
    } catch (error) {
      // 同期失敗はログインを妨げない
      console.error('Profile sync failed:', error);
    }
 
    // Access Token / Refresh Token の更新
    await prisma.account.update({
      where: {
        provider_providerAccountId: {
          provider: account.provider,
          providerAccountId: account.providerAccountId,
        },
      },
      data: {
        access_token: account.access_token,
        refresh_token: account.refresh_token ?? undefined,
        expires_at: account.expires_at,
        token_type: account.token_type,
        scope: account.scope,
        id_token: account.id_token,
      },
    });
 
    return true;
  },
}

// プロバイダーのアバター URL は変更される可能性がある
// ローカルにキャッシュして安定した URL を提供
 
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import sharp from 'sharp';
 
const s3 = new S3Client({ region: process.env.AWS_REGION });
 
async function cacheAvatar(
  userId: string,
  avatarUrl: string
): Promise<string> {
  try {
    // 画像をダウンロード
    const response = await fetch(avatarUrl);
    if (!response.ok) throw new Error('Failed to fetch avatar');
 
    const buffer = Buffer.from(await response.arrayBuffer());
 
    // リサイズと最適化
    const optimized = await sharp(buffer)
      .resize(256, 256, { fit: 'cover' })
      .webp({ quality: 80 })
      .toBuffer();
 
    // S3 にアップロード
    const key = `avatars/${userId}.webp`;
    await s3.send(new PutObjectCommand({
      Bucket: process.env.AVATAR_BUCKET!,
      Key: key,
      Body: optimized,
      ContentType: 'image/webp',
      CacheControl: 'public, max-age=86400', // 1 日キャッシュ
    }));
 
    return `${process.env.CDN_URL}/${key}`;
  } catch (error) {
    console.error('Avatar cache failed:', error);
    return avatarUrl; // フォールバック: 元の URL をそのまま返す
  }
}

// app/login/page.tsx - ソーシャルログインページ
import { signIn } from '@/auth';
import { redirect } from 'next/navigation';
import { auth } from '@/auth';
 
export default async function LoginPage({
  searchParams,
}: {
  searchParams: { callbackUrl?: string; error?: string };
}) {
  // 既にログイン済みならリダイレクト
  const session = await auth();
  if (session) redirect(searchParams.callbackUrl || '/dashboard');
 
  const callbackUrl = searchParams.callbackUrl || '/dashboard';
 
  // エラーメッセージのマッピング
  const errorMessages: Record<string, string> = {
    OAuthAccountNotLinked:
      'このメールアドレスは別のログイン方法で登録されています。元の方法でログインしてください。',
    OAuthSignin: 'ログインの開始に失敗しました。もう一度お試しください。',
    OAuthCallback: '認証に失敗しました。もう一度お試しください。',
    Callback: '認証処理中にエラーが発生しました。',
    AccessDenied: 'アクセスが拒否されました。',
    DomainNotAllowed: 'このドメインのアカウントではログインできません。',
    OrgMembershipRequired: '組織のメンバーシップが必要です。',
    EmailFetchFailed: 'メールアドレスの取得に失敗しました。',
    NoVerifiedEmail: '検証済みのメールアドレスが見つかりません。',
    Default: 'ログインに失敗しました。もう一度お試しください。',
  };
 
  const error = searchParams.error;
  const errorMessage = error
    ? errorMessages[error] || errorMessages.Default
    : null;
 
  return (
    <div className="min-h-screen flex items-center justify-center bg-gray-50">
      <div className="max-w-md w-full space-y-8 p-8 bg-white rounded-xl shadow-md">
        <div className="text-center">
          <h1 className="text-2xl font-bold">ログイン</h1>
          <p className="mt-2 text-gray-600">
            アカウントにログインしてください
          </p>
        </div>
 
        {errorMessage && (
          <div className="bg-red-50 border border-red-200 rounded-lg p-4">
            <p className="text-red-700 text-sm">{errorMessage}</p>
          </div>
        )}
 
        <div className="space-y-3">
          {/* Google */}
          <form
            action={async () => {
              'use server';
              await signIn('google', { redirectTo: callbackUrl });
            }}
          >
            <button
              type="submit"
              className="w-full flex items-center justify-center gap-3 px-4 py-3
                         border border-gray-300 rounded-lg hover:bg-gray-50
                         transition-colors"
            >
              <GoogleIcon className="w-5 h-5" />
              <span>Google で続ける</span>
            </button>
          </form>
 
          {/* Apple */}
          <form
            action={async () => {
              'use server';
              await signIn('apple', { redirectTo: callbackUrl });
            }}
          >
            <button
              type="submit"
              className="w-full flex items-center justify-center gap-3 px-4 py-3
                         bg-black text-white rounded-lg hover:bg-gray-900
                         transition-colors"
            >
              <AppleIcon className="w-5 h-5" />
              <span>Apple で続ける</span>
            </button>
          </form>
 
          {/* GitHub */}
          <form
            action={async () => {
              'use server';
              await signIn('github', { redirectTo: callbackUrl });
            }}
          >
            <button
              type="submit"
              className="w-full flex items-center justify-center gap-3 px-4 py-3
                         bg-gray-800 text-white rounded-lg hover:bg-gray-700
                         transition-colors"
            >
              <GitHubIcon className="w-5 h-5" />
              <span>GitHub で続ける</span>
            </button>
          </form>
        </div>
 
        {/* 区切り線 */}
        <div className="relative">
          <div className="absolute inset-0 flex items-center">
            <div className="w-full border-t border-gray-300" />
          </div>
          <div className="relative flex justify-center text-sm">
            <span className="px-2 bg-white text-gray-500">または</span>
          </div>
        </div>
 
        {/* メール・パスワードフォーム（フォールバック） */}
        <EmailPasswordForm callbackUrl={callbackUrl} />
 
        <p className="text-center text-xs text-gray-500">
          ログインすることで、
          <a href="/terms" className="underline">利用規約</a>
          と
          <a href="/privacy" className="underline">プライバシーポリシー</a>
          に同意したものとみなします。
        </p>
      </div>
    </div>
  );
}

// callbackUrl のバリデーション
function validateCallbackUrl(url: string | undefined): string {
  const defaultUrl = '/dashboard';
 
  if (!url) return defaultUrl;
 
  try {
    const parsed = new URL(url, process.env.NEXTAUTH_URL);
    const appHost = new URL(process.env.NEXTAUTH_URL!).host;
 
    // 同一ホストのみ許可（オープンリダイレクト防止）
    if (parsed.host !== appHost) {
      return defaultUrl;
    }
 
    // 特定のパスを禁止
    const blockedPaths = ['/api/', '/auth/'];
    if (blockedPaths.some((p) => parsed.pathname.startsWith(p))) {
      return defaultUrl;
    }
 
    return parsed.pathname + parsed.search;
  } catch {
    return defaultUrl;
  }
}

// Access Token / Refresh Token の安全な保管
 
// Prisma Schema - Token の暗号化
// model Account {
//   ...
//   access_token_encrypted   String?
//   refresh_token_encrypted  String?
//   ...
// }
 
import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 
const ENCRYPTION_KEY = Buffer.from(process.env.TOKEN_ENCRYPTION_KEY!, 'hex');
// 32 bytes = 256-bit key for AES-256
 
function encryptToken(token: string): string {
  const iv = randomBytes(16);
  const cipher = createCipheriv('aes-256-gcm', ENCRYPTION_KEY, iv);
 
  let encrypted = cipher.update(token, 'utf8', 'hex');
  encrypted += cipher.final('hex');
 
  const authTag = cipher.getAuthTag().toString('hex');
 
  // iv:authTag:encrypted の形式で保存
  return `${iv.toString('hex')}:${authTag}:${encrypted}`;
}
 
function decryptToken(encryptedToken: string): string {
  const [ivHex, authTagHex, encrypted] = encryptedToken.split(':');
 
  const iv = Buffer.from(ivHex, 'hex');
  const authTag = Buffer.from(authTagHex, 'hex');
  const decipher = createDecipheriv('aes-256-gcm', ENCRYPTION_KEY, iv);
  decipher.setAuthTag(authTag);
 
  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
 
  return decrypted;
}
 
// Auth.js のアダプターをラップして暗号化
import { PrismaAdapter } from '@auth/prisma-adapter';
 
function encryptedAdapter(prisma: PrismaClient) {
  const adapter = PrismaAdapter(prisma);
 
  return {
    ...adapter,
    async linkAccount(account: any) {
      // トークンを暗号化してから保存
      const encryptedAccount = {
        ...account,
        access_token: account.access_token
          ? encryptToken(account.access_token)
          : null,
        refresh_token: account.refresh_token
          ? encryptToken(account.refresh_token)
          : null,
      };
      return adapter.linkAccount!(encryptedAccount);
    },
  };
}

// ソーシャルログインのレート制限
// 短時間での大量のログイン試行を防止
 
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
 
const loginRatelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(5, '1 m'), // 1分に5回まで
  analytics: true,
  prefix: 'ratelimit:login',
});
 
// middleware.ts でレート制限を適用
export async function middleware(request: NextRequest) {
  // /api/auth/signin へのリクエストをレート制限
  if (request.nextUrl.pathname.startsWith('/api/auth/signin')) {
    const ip = request.ip ?? request.headers.get('x-forwarded-for') ?? 'unknown';
    const { success, remaining, reset } = await loginRatelimit.limit(ip);
 
    if (!success) {
      return new NextResponse('Too Many Requests', {
        status: 429,
        headers: {
          'Retry-After': String(Math.ceil((reset - Date.now()) / 1000)),
          'X-RateLimit-Remaining': String(remaining),
        },
      });
    }
  }
 
  return NextResponse.next();
}

// Auth.js のデバッグモードを有効化
// auth.ts
export const { handlers, auth, signIn, signOut } = NextAuth({
  debug: process.env.NODE_ENV === 'development',
  // これにより、コンソールに詳細なログが出力される
 
  logger: {
    error(code, ...message) {
      console.error(`[Auth Error] ${code}:`, ...message);
    },
    warn(code, ...message) {
      console.warn(`[Auth Warn] ${code}:`, ...message);
    },
    debug(code, ...message) {
      if (process.env.NODE_ENV === 'development') {
        console.log(`[Auth Debug] ${code}:`, ...message);
      }
    },
  },
 
  events: {
    async signIn({ user, account, profile, isNewUser }) {
      console.log('[Auth Event] signIn:', {
        userId: user.id,
        provider: account?.provider,
        isNewUser,
      });
    },
    async signOut(message) {
      console.log('[Auth Event] signOut:', message);
    },
    async linkAccount({ user, account }) {
      console.log('[Auth Event] linkAccount:', {
        userId: user.id,
        provider: account.provider,
      });
    },
    async createUser({ user }) {
      console.log('[Auth Event] createUser:', { userId: user.id });
    },
  },
});

// ✗ 危険: Client Secret をフロントエンドに露出
// フロントエンドのコード
const response = await fetch('https://oauth2.googleapis.com/token', {
  method: 'POST',
  body: JSON.stringify({
    client_id: 'xxx',
    client_secret: 'EXPOSED_SECRET', // 絶対にダメ！
    code: authorizationCode,
  }),
});
 
// ✓ 正しい: サーバーサイドでトークン交換
// Auth.js がサーバーサイドで自動的に処理
// Client Secret は環境変数から読み取り、サーバーでのみ使用

// ✗ 危険: メール検証なしの自動リンク
callbacks: {
  async signIn({ user, account }) {
    const existing = await prisma.user.findUnique({
      where: { email: user.email! },
    });
    if (existing) {
      // メール検証なしでリンク → アカウント乗っ取り可能！
      await prisma.account.create({
        data: { userId: existing.id, ...account },
      });
    }
    return true;
  },
}
 
// ✓ 正しい: email_verified を確認してからリンク
// （前述の checkEmailVerification 関数を使用）

// ✗ 問題: Apple のプロフィール情報を初回に保存していない
callbacks: {
  async signIn({ user, account }) {
    // Apple の name が null でも気にせず進む
    // → 2 回目以降は name が取得できなくなる！
    return true;
  },
}
 
// ✓ 正しい: 初回ログイン時に name / email を確実に保存
// （前述の Apple 実装を参照）