import { createServerClient } from '@supabase/ssr'
import { NextResponse, type NextRequest } from 'next/server'

export async function middleware(request: NextRequest) {
  let supabaseResponse = NextResponse.next({
    request,
  })

  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll()
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value, options }) => request.cookies.set(name, value))
          supabaseResponse = NextResponse.next({
            request,
          })
          cookiesToSet.forEach(({ name, value, options }) =>
            supabaseResponse.cookies.set(name, value, options)
          )
        },
      },
    }
  )

  // Do not run code between createServerClient and
  // supabase.auth.getUser(). A simple mistake could make it very hard to debug
  // issues with users being randomly logged out.

  // IMPORTANT: DO NOT REMOVE auth.getUser()
  const {
    data: { user },
  } = await supabase.auth.getUser()

  // Public routes that don't require authentication
  const isPublicRoute = 
    request.nextUrl.pathname.startsWith('/login') ||
    request.nextUrl.pathname.startsWith('/signup') ||
    request.nextUrl.pathname.startsWith('/auth') ||
    request.nextUrl.pathname.startsWith('/_next') ||
    request.nextUrl.pathname.startsWith('/api') ||
    request.nextUrl.pathname.startsWith('/forgot-password') ||
    request.nextUrl.pathname.startsWith('/reset-password') ||
    request.nextUrl.pathname === '/'

  // Protected routes that require both auth and completed onboarding
  const isProtectedRoute =
    request.nextUrl.pathname.startsWith('/dashboard') ||
    request.nextUrl.pathname.startsWith('/tasks') ||
    request.nextUrl.pathname.startsWith('/achievements') ||
    request.nextUrl.pathname.startsWith('/history') ||
    request.nextUrl.pathname.startsWith('/leaderboard') ||
    request.nextUrl.pathname.startsWith('/partners') ||
    request.nextUrl.pathname.startsWith('/settings')

  // If there's no user and the route requires auth, redirect to login
  if (!user && !isPublicRoute) {
    const redirectUrl = new URL('/login', request.url)
    redirectUrl.searchParams.set('redirectedFrom', request.nextUrl.pathname)
    // Ensure cookies are passed if supabaseResponse was modified
    const response = NextResponse.redirect(redirectUrl);
    supabaseResponse.cookies.getAll().forEach(cookie => {
      response.cookies.set(cookie.name, cookie.value, cookie);
    });
    return response;
  }

  // If there's a user, check their onboarding status
  if (user) {
    // Check if user has a profile
    const { data: profile } = await supabase
      .from('profiles')
      .select('username')
      .eq('id', user.id)
      .single()

    const needsOnboarding = !profile || !profile.username
    const isOnboardingRoute = request.nextUrl.pathname.startsWith('/onboarding')
    const isAuthRoute = request.nextUrl.pathname.startsWith('/login') || 
                       request.nextUrl.pathname.startsWith('/signup')

    // If user needs onboarding and tries to access a protected route, redirect to onboarding
    if (needsOnboarding && isProtectedRoute) {
      const redirectUrl = new URL('/onboarding', request.url);
      const response = NextResponse.redirect(redirectUrl);
      // Ensure cookies are passed if supabaseResponse was modified
      supabaseResponse.cookies.getAll().forEach(cookie => {
        response.cookies.set(cookie.name, cookie.value, cookie);
      });
      return response;
    }

    // If user is fully onboarded and tries to access auth pages or onboarding, redirect to dashboard
    if (!needsOnboarding && (isAuthRoute || isOnboardingRoute)) {
      const redirectUrl = new URL('/dashboard', request.url);
      const response = NextResponse.redirect(redirectUrl);
      // Ensure cookies are passed if supabaseResponse was modified
      supabaseResponse.cookies.getAll().forEach(cookie => {
        response.cookies.set(cookie.name, cookie.value, cookie);
      });
      return response;
    }
  }

  return supabaseResponse
}

export const config = {
  matcher: [
    /*
     * Match all request paths except for the ones starting with:
     * - _next/static (static files)
     * - _next/image (image optimization files)
     * - favicon.ico (favicon file)
     * - public assets (images, audio, etc.)
     * Feel free to modify this pattern to include more paths.
     */
    '/((?!_next/static|_next/image|favicon.ico|sounds|.*\\.(?:svg|png|jpg|jpeg|gif|webp|mp3|wav)$).*)',
  ],
} 

import { createBrowserClient } from '@supabase/ssr'

export function createClient() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  )
}

"use client"
import { createClient } from "@/lib/supabase/client";
import { useEffect, useState, useCallback, useRef } from "react";
// ... other imports ...

export default function UserLayout({ children }: UserLayoutProps) {
  const [userData, setUserData] = useState<UserData | null>(null);
  // ... other states ...
  const supabase = createClient();
  const isMountedRef = useRef(true);

  const refreshUserDataAndStatus = useCallback(async () => {
    console.log('[UserLayout] Initiating refreshUserDataAndStatus...');
    try {
      const { data: { user: authUser }, error: authError } = await supabase.auth.getUser(); // This might also hang if called here
      // ... rest of the function ...
    } catch (e) {
        console.error('[UserLayout] CRITICAL ERROR in refreshUserDataAndStatus catch block:', e);
    }
  }, [supabase]);


  useEffect(() => {
    isMountedRef.current = true;
    console.log('[UserLayout] Main data-fetching useEffect triggered.');
    let userId: string | null = null;
    let isMounted = true; // Local isMounted for this effect

    const setup = async () => {
      console.log('[UserLayout] setup() function initiated.');
      try {
        console.log('[UserLayout] setup(): Attempting supabase.auth.getUser()...');

        const getUserPromise = supabase.auth.getUser();
        const timeoutPromise = new Promise((_, reject) =>
          setTimeout(() => reject(new Error('supabase.auth.getUser() timed out after 10 seconds')), 10000)
        );

        let user: any = null; // Use 'any' or proper User type
        let setupGetUserError: Error | null = null;

        try {
          const result = await Promise.race([
            getUserPromise,
            timeoutPromise
          ]) as { data: { user: any }, error: any }; // Adjust type as needed

          if (result.error) {
            setupGetUserError = result.error;
          } else if (result.data) { // Check if data exists
            user = result.data.user;
          }
        } catch (e: any) {
          setupGetUserError = e;
        }

        if (setupGetUserError) {
          console.error('[UserLayout] setup(): Error or timeout from supabase.auth.getUser():', setupGetUserError);
        }
        console.log('[UserLayout] setup(): supabase.auth.getUser() completed/timedout. User:', user ? user.id : 'null');
        userId = user?.id ?? null;

        await refreshUserDataAndStatus(); // Called regardless of user state from setup's getUser
        // ... (rest of setup) ...

      } catch (error) {
        console.error('[UserLayout] setup(): Error in setup function:', error);
      }
    };

    setup(); // Initial call

    const { data: { subscription: authSubscription } } = supabase.auth.onAuthStateChange((_event, session) => {
      console.log('[UserLayout] onAuthStateChange triggered. Event:', _event);
      if (!isMountedRef.current) return; // Use ref here

      if (_event === 'SIGNED_OUT') {
        refreshUserDataAndStatus();
        userId = null;
      } else if (_event === 'SIGNED_IN' && session) {
        console.log('[UserLayout] onAuthStateChange: SIGNED_IN event, calling setup().');
        setup();
      }
    });

    return () => {
      isMountedRef.current = false;
      if (authSubscription) authSubscription.unsubscribe();
      // ... any other cleanup ...
    };
  }, [supabase, refreshUserDataAndStatus]);

  if (userData === null) {
    return <LoadingLayout />;
  }
  // ... rest of layout ...
  return ( /* ... */ );
}