import { NextResponse } from "next/server";
import { getIronSession } from "iron-session/edge";
import { sessionOptions } from "./lib/session";

export const middleware = async (req) => {

  const res = NextResponse.next();


  const urlAlberta = req.nextUrl.clone();


  //get current session if it exists
  const session = await getIronSession(req, res, sessionOptions);
  //grab current session + display current session data
  const { location } = session;

  // REDIRECT LOGIC HERE //
  //SESSION ALREADY EXISTS
  //if user lands on any page but they're from alberta, send them to the Alberta page version of the req.url

  if (
    session?.location?.location &&
    location?.location?.country === "CA" &&
    location?.location?.region === "Alberta" &&
    urlAlberta.pathname.indexOf("/AB") === -1
  ) {
    const locale = req.cookies.get("NEXT_LOCALE")?.value || "en";

    const albertaURL =
      locale === "en"
        ? urlAlberta.origin + "/" + "AB" + urlAlberta.pathname
        : urlAlberta.origin + "/" + locale + "/" + "AB" + urlAlberta.pathname;

    return NextResponse.redirect(new URL(albertaURL, req.url));
  }
  console.log("location", location);
  try {
    //NO SESSIONS
    //get user IP and set the browser session for user location
    console.log("NO SESSION FOUND - FETCHING FROM API")
    if (!session.location) {
      console.log("!Session.location")
      //   fetch user IP + local data and set it in a session cookie
      const url = process.env.PROD_URL + `api/geolocation-api`;
      console.log("url", url)
      const res_location = await fetch(url);
      const locationData = await res_location.json();
      session.location = locationData;
      console.log("locationData REGION : ", locationData.location)
      await session.save();

      if (
        locationData?.location?.country === "CA" &&
        locationData?.location?.region === "Alberta" &&
        urlAlberta.pathname.indexOf("/AB") === -1
      ) {
        const locale = req.cookies.get("NEXT_LOCALE")?.value || "en";

        const albertaURL =
          locale === "en"
            ? urlAlberta.origin + "/" + "AB" + urlAlberta.pathname
            : urlAlberta.origin +
              "/" +
              locale +
              "/" +
              "AB" +
              urlAlberta.pathname;

        return NextResponse.redirect(new URL(albertaURL, req.url));
      }
    }
  } catch (error) {
    console.error("Error fetching geolocation:", error);

    // Handle the error from the geolocation API
    // Redirect the user to the root site URL on API error
    const rootSiteUrl = process.env.PROD_URL; // Change this to your actual root site URL

    const redirectedUrl = new URL(rootSiteUrl);
    redirectedUrl.pathname = req.nextUrl.pathname; // Preserve the current path
    return NextResponse.redirect(redirectedUrl.toString());
  }
};

export const config = { matcher: "/((?!.*\\.).*)" };

export function middleware(request: NextRequest) {

    const clientIP = request.ip ?? "127.0.0.1";

-  // Get the client IP address from the 'x-forwarded-for' header
  console.log("req in middleware : ", req)  //empty {}
  const clientIP = req.headers['http_x_forwarded_for'];
  const realIpHeader = req.headers['http_x_real_ip'];
  // Log the client IP address
  console.log("Client IP:", clientIP); //null
  console.log("realIpHeader:", realIpHeader); //null
 

forwardedFor = req.headers["x-forwarded-for"]; //127.0.0.1

export async function getServerSideProps(context) {
  const res = await fetch(process.env.WEB_API_HOME);
  const data = await res.json();
  const forwardIp = context.req.headers["x-forwarded-for"] || null; //10.0.1...
  const remoteIP = context.req.socket.remoteAddress || null; //null

  return {
    props: {
      data,
      forwardIp: forwardIp,
      remoteIP: remoteIP,
    },
  };
}

forwardedFor = req.headers["x-forwarded-for"]; //127.0.0.1

The public IP address of the client that made the request. If you are trying to use Vercel behind a proxy, we currently overwrite the
X-Forwarded-For
header and do not forward external IPs. This restriction is in place to prevent IP spoofing. Please contact us if allowing Vercel to trust your X-Forwarded-For IP is a feature your Team needs (Enterprise only).