import { NextResponse } from "next/server";
import { getSessionUser } from "@/lib/auth/get-session-user";
import { getMetaRedirectUri } from "@/lib/env";
import { logAutoPost } from "@/lib/logging/auto-post-logger";
import { clearOAuthCookies, readOAuthCookies } from "@/lib/social/oauth-cookies";
import { exchangeMetaCode, resolveMetaConnection } from "@/lib/social/meta-oauth";
import { persistSocialConnection } from "@/lib/social/save-connection";
import { loadProjectSocialAccounts } from "@/lib/storage/social-accounts";

const PREFIX = "meta";

export async function POST(request: Request) {
  const cookies = await readOAuthCookies(PREFIX);
  const platform = (cookies.platform ?? "facebook") as "facebook" | "instagram";

  try {
    const user = await getSessionUser();
    if (!user) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });

    const body = (await request.json()) as { code?: string; state?: string };
    const { code, state } = body;
    if (!code || !state) {
      return NextResponse.json({ error: "code and state are required" }, { status: 400 });
    }

    if (!cookies.state || cookies.state !== state) {
      return NextResponse.json({ error: "Invalid or expired OAuth state" }, { status: 400 });
    }
    if (!cookies.projectId) {
      return NextResponse.json({ error: "Missing project context" }, { status: 400 });
    }

    const redirectUri =
      cookies.redirectUri ?? getMetaRedirectUri(platform);

    await logAutoPost({
      level: "INFO",
      event: "oauth_callback_received",
      projectId: cookies.projectId,
      providerId: platform,
      status: "processing",
      message: `Meta OAuth callback for ${platform}.`,
      details: { redirectUri },
    });

    const token = await exchangeMetaCode(code, redirectUri);

    const serverAccounts = await loadProjectSocialAccounts(user.id, cookies.projectId);
    const facebookPageId = serverAccounts.find((a) => a.platform === "facebook")?.externalId;

    const connection = await resolveMetaConnection(token.accessToken, platform, {
      preferPageId: facebookPageId ?? undefined,
    });

    const expiresAt = token.expiresIn
      ? new Date(Date.now() + token.expiresIn * 1000).toISOString()
      : null;

    const account = await persistSocialConnection(
      user.id,
      cookies.projectId,
      {
        platform,
        profileName: connection.profileName,
        accessToken: connection.accessToken,
        publishToken: connection.publishToken,
        externalId: connection.externalId,
        expiresAt,
      },
      { email: user.email, name: user.name },
    );

    await logAutoPost({
      level: "SUCCESS",
      event: "provider_connected",
      projectId: cookies.projectId,
      providerId: platform,
      status: "connected",
      message: `${platform} connected as ${account.profileName}.`,
      details: { externalId: account.externalId },
    });

    const response = NextResponse.json({
      success: true,
      projectId: cookies.projectId,
      returnTo: cookies.returnTo,
      platform,
      profileName: account.profileName,
      externalId: account.externalId,
      expiresAt: account.expiresAt,
    });

    clearOAuthCookies(response, PREFIX);
    return response;
  } catch (error) {
    const message = error instanceof Error ? error.message : "Meta connection failed";
    await logAutoPost({
      level: "ERROR",
      event: "oauth_connect_failed",
      projectId: cookies.projectId,
      providerId: platform,
      status: "failed",
      message: `Meta ${platform} connection failed.`,
      error,
    });
    return NextResponse.json({ error: message }, { status: 400 });
  }
}