import { useState, useEffect, createContext, useContext, ReactNode } from 'react';
import { User, Session } from '@supabase/supabase-js';
import { supabase } from '@/integrations/supabase/client';

type AppRole = 'admin' | 'sales_team' | 'user';

interface AuthContextType {
  user: User | null;
  session: Session | null;
  roles: AppRole[];
  loading: boolean;
  signIn: (email: string, password: string) => Promise<{ error: Error | null; userId?: string }>;
  signOut: () => Promise<void>;
  hasRole: (role: AppRole) => boolean;
  isAdmin: boolean;
  isSalesTeam: boolean;
  checkUserActive: (userId: string) => Promise<boolean>;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

/**
 * Marker lever bara i sessionStorage: den försvinner när fliken/webbläsaren
 * stängs (men överlever reload och navigering). Saknas den vid uppstart
 * betyder det en ny flik-session → logga ut.
 */
const TAB_SESSION_KEY = 'suteki-tab-session';

export function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null);
  const [session, setSession] = useState<Session | null>(null);
  const [roles, setRoles] = useState<AppRole[]>([]);
  const [loading, setLoading] = useState(true);

  const fetchUserRoles = async (userId: string) => {
    const { data, error } = await supabase
      .from('user_roles')
      .select('role')
      .eq('user_id', userId);
    
    if (error) {
      console.error('Error fetching roles:', error);
      return [];
    }
    
    return data?.map(r => r.role as AppRole) || [];
  };

  const checkUserActive = async (userId: string): Promise<boolean> => {
    const { data, error } = await supabase
      .from('profiles')
      .select('is_active')
      .eq('user_id', userId)
      .single();
    
    if (error) {
      // If no profile exists, assume user is active (backward compatibility)
      if (error.code === 'PGRST116') {
        return true;
      }
      console.error('Error checking user status:', error);
      return true;
    }
    
    return data?.is_active ?? true;
  };

  useEffect(() => {
    let cancelled = false;
    const hasTabSession = sessionStorage.getItem(TAB_SESSION_KEY) === '1';

    // Set up auth state listener FIRST
    const { data: { subscription } } = supabase.auth.onAuthStateChange(
      (event, session) => {
        if (session) {
          sessionStorage.setItem(TAB_SESSION_KEY, '1');
        }
        setSession(session);
        setUser(session?.user ?? null);
        
        // Defer role fetching with setTimeout to avoid deadlock
        if (session?.user) {
          setTimeout(() => {
            fetchUserRoles(session.user.id).then(setRoles);
          }, 0);
        } else {
          setRoles([]);
        }
      }
    );

    // THEN check for existing session
    supabase.auth.getSession().then(({ data: { session } }) => {
      // Sessionen kommer från localStorage men fliken är ny → logga ut.
      if (session && !hasTabSession) {
        supabase.auth.signOut().finally(() => {
          if (cancelled) return;
          sessionStorage.removeItem(TAB_SESSION_KEY);
          setSession(null);
          setUser(null);
          setRoles([]);
          setLoading(false);
        });
        return;
      }

      if (session) sessionStorage.setItem(TAB_SESSION_KEY, '1');
      setSession(session);
      setUser(session?.user ?? null);
      
      if (session?.user) {
        fetchUserRoles(session.user.id).then(roles => {
          setRoles(roles);
          setLoading(false);
        });
      } else {
        setLoading(false);
      }
    });

    return () => {
      cancelled = true;
      subscription.unsubscribe();
    };
  }, []);

  const signIn = async (email: string, password: string) => {
    const { data, error } = await supabase.auth.signInWithPassword({ email, password });
    return { 
      error: error as Error | null,
      userId: data?.user?.id
    };
  };

  const signOut = async () => {
    await supabase.auth.signOut();
    sessionStorage.removeItem(TAB_SESSION_KEY);
    setRoles([]);
  };

  const hasRole = (role: AppRole) => roles.includes(role);
  const isAdmin = hasRole('admin');
  const isSalesTeam = hasRole('sales_team') || isAdmin;

  return (
    <AuthContext.Provider value={{
      user,
      session,
      roles,
      loading,
      signIn,
      signOut,
      hasRole,
      isAdmin,
      isSalesTeam,
      checkUserActive
    }}>
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
}
