import { NextRequest, NextResponse } from "next/server";
import { randomBytes } from "crypto";
import { db } from "@/lib/db";
import { createSession, hashPassword } from "@/lib/auth";
import { exchangeCodeForProfile, isOAuthProvider, OAUTH_STATE_COOKIE } from "@/lib/oauth";
import { claimOnboardingDraft } from "@/lib/onboarding";
import { audit } from "@/lib/audit";
import { getBaseUrl } from "@/lib/email";

/**
 * Social sign-in callback: verify state, exchange the code, then find or
 * create the account (linked via OAuthAccount, matched by verified email),
 * sign the user in, claim any pending /start draft, and land them home.
 */
export async function GET(req: NextRequest, { params }: { params: Promise<{ provider: string }> }) {
  const { provider } = await params;
  // Behind the Apache proxy req.url is localhost — build redirects from the public base URL.
  const base = await getBaseUrl();
  const fail = (msg: string) => {
    const res = NextResponse.redirect(new URL(`/login?error=${encodeURIComponent(msg)}`, base));
    res.cookies.delete(OAUTH_STATE_COOKIE);
    return res;
  };

  if (!isOAuthProvider(provider)) return fail("Unknown sign-in provider.");
  const sp = req.nextUrl.searchParams;
  if (sp.get("error")) {
    return fail(sp.get("error") === "access_denied" ? "Sign-in was cancelled." : `Sign-in failed: ${sp.get("error_description") ?? sp.get("error")}`);
  }
  const code = sp.get("code");
  const state = sp.get("state") ?? "";
  const cookieState = req.cookies.get(OAUTH_STATE_COOKIE)?.value ?? "";
  if (!code || !state || state !== cookieState) {
    return fail("Sign-in session expired or was tampered with — please try again.");
  }
  const [, role = "attendee", nextB64 = ""] = state.split(".");
  const next = (() => { try { return Buffer.from(nextB64, "base64url").toString(); } catch { return ""; } })();

  let profile;
  try {
    profile = await exchangeCodeForProfile(provider, code);
  } catch (e) {
    return fail((e as Error).message);
  }
  if (!profile.emailVerified) return fail(`Your ${provider} email is not verified — verify it with the provider first.`);

  // 1) Already-linked identity → that user. 2) Same verified email → link. 3) New account.
  let user;
  const linked = await db.oAuthAccount.findUnique({
    where: { provider_providerAccountId: { provider, providerAccountId: profile.providerAccountId } },
    include: { user: true },
  });
  if (linked) {
    user = linked.user;
  } else {
    user = await db.user.findUnique({ where: { email: profile.email } });
    let created = false;
    if (!user) {
      user = await db.user.create({
        data: {
          email: profile.email,
          name: profile.name,
          avatarUrl: profile.picture,
          // Social accounts sign in via the provider; the local password is a random fallback.
          passwordHash: await hashPassword(randomBytes(24).toString("hex")),
          platformRole: role === "organizer" ? "ORGANIZER" : "USER",
          emailVerified: true,
        },
      });
      created = true;
    }
    await db.oAuthAccount.create({ data: { provider, providerAccountId: profile.providerAccountId, userId: user.id } });
    if (created) {
      try {
        const { sendWelcomeEmail } = await import("@/lib/email");
        await sendWelcomeEmail(user.email, user.name, role === "organizer");
      } catch { /* email must never block sign-in */ }
    }
  }

  // Keep the profile fresh where we have nothing better.
  if (!user.avatarUrl && profile.picture) {
    user = await db.user.update({ where: { id: user.id }, data: { avatarUrl: profile.picture } });
  }
  // An explicit "organize" intent upgrades an attendee account.
  if (role === "organizer" && user.platformRole === "USER") {
    user = await db.user.update({ where: { id: user.id }, data: { platformRole: "ORGANIZER" } });
  }

  await createSession(user.id);
  await audit({ userId: user.id, action: "auth.login", meta: { provider } });

  // A pending /start conference draft? Claim it and land in the new workspace.
  let dest: string;
  try {
    const claimedConfId = await claimOnboardingDraft(user);
    dest = claimedConfId ? `/dashboard/c/${claimedConfId}?welcome=1` : "";
  } catch {
    dest = "";
  }
  if (!dest) {
    dest = next && next.startsWith("/")
      ? next
      : user.platformRole === "SUPER_ADMIN" ? "/admin"
      : user.platformRole === "ORGANIZER" ? "/dashboard"
      : "/me";
  }
  const res = NextResponse.redirect(new URL(dest, base));
  res.cookies.delete(OAUTH_STATE_COOKIE);
  return res;
}
