import { NextResponse } from "next/server";
import { getCollection } from "@/lib/mongodb";

// Verify Firebase ID token using Firebase REST API
async function verifyIdToken(idToken: string): Promise<any> {
  try {
    const apiKey = process.env.NEXT_PUBLIC_FIREBASE_API_KEY || "AIzaSyCPxvawp-ECyMhNY3pdTFpUgxTJLNKPdik";
    
    // Use Firebase REST API to verify the token
    const response = await fetch(
      `https://www.googleapis.com/identitytoolkit/v3/relyingparty/getAccountInfo?key=${apiKey}`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ idToken }),
      }
    );

    if (!response.ok) {
      const errorData = await response.json();
      console.error("Token verification error:", errorData);
      throw new Error(errorData.error?.message || "Invalid token");
    }

    const data = await response.json();
    if (data.users && data.users.length > 0) {
      return data.users[0];
    }
    throw new Error("User not found in token");
  } catch (error) {
    console.error("Token verification error:", error);
    throw error;
  }
}

export async function POST(request: Request) {
  try {
    const body = await request.json();
    const { idToken, email, name, photoURL, provider } = body;

    if (!idToken) {
      return NextResponse.json(
        { error: "ID token is required" },
        { status: 400 }
      );
    }

    // Verify the Firebase ID token
    let firebaseUser;
    try {
      firebaseUser = await verifyIdToken(idToken);
    } catch (error: any) {
      console.error("Token verification failed:", error);
      return NextResponse.json(
        { error: "Invalid or expired token" },
        { status: 401 }
      );
    }

    if (!firebaseUser) {
      return NextResponse.json(
        { error: "User not found" },
        { status: 404 }
      );
    }

    // Extract user information from Firebase user object
    const userEmail = firebaseUser.email || email;
    const userName = firebaseUser.displayName || name || firebaseUser.email?.split("@")[0] || "User";
    const userPhotoURL = firebaseUser.photoUrl || firebaseUser.photoURL || photoURL;
    const firebaseUid = firebaseUser.localId || firebaseUser.uid || firebaseUser.id;

    if (!userEmail) {
      return NextResponse.json(
        { error: "Email is required" },
        { status: 400 }
      );
    }

    const usersCollection = await getCollection("users");

    // Check if user exists in MongoDB
    let user = await usersCollection.findOne({ email: userEmail });

    if (user) {
      // User exists, update Firebase UID and other info if needed
      const updateData: any = {
        updatedAt: new Date(),
      };

      if (!user.firebaseUid) {
        updateData.firebaseUid = firebaseUid;
      }

      if (userPhotoURL && !user.photoURL) {
        updateData.photoURL = userPhotoURL;
      }

      if (Object.keys(updateData).length > 1) {
        await usersCollection.updateOne(
          { email: userEmail },
          { $set: updateData }
        );
        user = await usersCollection.findOne({ email: userEmail });
      }
    } else {
      // Create new user in MongoDB
      const newUser = {
        name: userName,
        email: userEmail,
        photoURL: userPhotoURL || "",
        firebaseUid: firebaseUid,
        provider: provider || "google",
        role: "customer",
        phone: "",
        address: {},
        preferences: {
          newsletter: false,
          currency: "AED",
          language: "en",
        },
        createdAt: new Date(),
        updatedAt: new Date(),
      };

      const result = await usersCollection.insertOne(newUser);
      user = await usersCollection.findOne({ _id: result.insertedId });
    }

    if (!user) {
      return NextResponse.json(
        { error: "Failed to create or retrieve user" },
        { status: 500 }
      );
    }

    // Return user data (without password)
    const userData = {
      _id: user._id.toString(),
      name: user.name,
      email: user.email,
      phone: user.phone || "",
      role: user.role || "customer",
      address: user.address || {},
      preferences: user.preferences || {},
      photoURL: user.photoURL || "",
      firebaseUid: user.firebaseUid || "",
    };

    return NextResponse.json({
      success: true,
      user: userData,
      message: "Authentication successful",
    });
  } catch (error) {
    console.error("Firebase authentication error:", error);
    return NextResponse.json(
      { error: "Authentication failed", details: error instanceof Error ? error.message : "Unknown error" },
      { status: 500 }
    );
  }
}