Server : Apache/2 System : Linux server-15-235-50-60 5.15.0-164-generic #174-Ubuntu SMP Fri Nov 14 20:25:16 UTC 2025 x86_64 User : gositeme ( 1004) PHP Version : 8.2.29 Disable Function : exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname Directory :  /home/gositeme/domains/lavocat.ca/public_html/src/hooks/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

import { useState, useEffect } from 'react';
import { useSession } from 'next-auth/react';

export interface ProfileUser {
  id: string;
  name: string;
  email: string;
  username?: string;
  role: string;
  profilePicture?: string;
  bio?: string;
  location?: string;
  isVerified: boolean;
  isOnline: boolean;
  experience?: number;
  languages?: string[];
  specializations?: string[];
  hourlyRate?: number;
  averageRating?: number;
  totalCases?: number;
  wonCases?: number;
  proBono?: boolean;
  createdAt: string;
  updatedAt: string;
  // Privacy settings
  showFriends?: boolean;
  showEmail?: boolean;
  showPhone?: boolean;
  showLocation?: boolean;
  allowMessages?: boolean;
  showOnlineStatus?: boolean;
}

export interface UserStats {
  followers: number;
  following: number;
  endorsements: number;
  mutualConnections: number;
  friends: number;
  mutualFriends: number;
  views: number;
  totalCases: number;
  activeCases: number;
  completedCases: number;
}

export interface CaseData {
  id: string;
  title: string;
  description: string;
  status: string;
  caseType: string;
  priority: string;
  budget?: number;
  isPublic: boolean;
  createdAt: string;
  updatedAt: string;
  leadLawyer?: {
    id: string;
    name: string;
    profilePicture?: string;
  };
  creator?: {
    id: string;
    name: string;
  };
  _count?: {
    offers: number;
    registrations: number;
    supporters: number;
    comments: number;
  };
}

export interface FriendData {
  id: string;
  name: string;
  profilePicture?: string;
  role: string;
  isOnline: boolean;
  mutualFriends: number;
}

export interface ProfileData {
  user: ProfileUser;
  stats: UserStats;
  activeCases: CaseData[];
  pastCases: CaseData[];
  caseApplications: CaseData[];
  friends: FriendData[];
  mutualFriends: FriendData[];
  isLoading: boolean;
  error: string | null;
}

export function useProfileData(userId: string): ProfileData {
  const { data: session } = useSession();
  const [profileData, setProfileData] = useState<ProfileData>({
    user: {} as ProfileUser,
    stats: {
      followers: 0,
      following: 0,
      endorsements: 0,
      mutualConnections: 0,
      friends: 0,
      mutualFriends: 0,
      views: 0,
      totalCases: 0,
      activeCases: 0,
      completedCases: 0,
    },
    activeCases: [],
    pastCases: [],
    caseApplications: [],
    friends: [],
    mutualFriends: [],
    isLoading: true,
    error: null,
  });

  useEffect(() => {
    if (!userId) return;
    console.log('Fetching user data for userId:', userId);

    const fetchProfileData = async () => {
      try {
        setProfileData(prev => ({ ...prev, isLoading: true, error: null }));

        // Fetch user profile data
        console.log('Fetching user data for userId:', userId);
        const userResponse = await fetch(`/api/users/${userId}`);
        console.log('User response status:', userResponse.status);
        
        if (!userResponse.ok) {
          const errorText = await userResponse.text();
          console.error('User API error:', errorText);
          throw new Error(`Failed to fetch user data: ${userResponse.status} ${userResponse.statusText}`);
        }
        
        const userDataRaw = await userResponse.json();
        console.log('User data raw:', userDataRaw);
        const userData = userDataRaw.user || userDataRaw;

        // Initialize with default values
        let casesData = { cases: [] };
        let friendsData = { friends: [] };
        let mutualFriendsData = { mutualFriends: [] };

        // Try to fetch user's cases (may fail if not authenticated)
        try {
          console.log('Fetching cases for userId:', userId);
          const casesResponse = await fetch(`/api/cases?userId=${userId}`);
          console.log('Cases response status:', casesResponse.status);
          
          if (casesResponse.ok) {
            casesData = await casesResponse.json();
            console.log('Cases data:', casesData);
          } else {
            console.warn('Cases API failed, using empty data');
          }
        } catch (casesError) {
          console.warn('Cases API error, using empty data:', casesError);
        }

        // Try to fetch friends data (may fail if not authenticated)
        try {
          console.log('Fetching friends for userId:', userId);
          const friendsResponse = await fetch(`/api/friends/list?userId=${userId}`);
          console.log('Friends response status:', friendsResponse.status);
          
          if (friendsResponse.ok) {
            friendsData = await friendsResponse.json();
            console.log('Friends data:', friendsData);
          } else {
            console.warn('Friends API failed, using empty data');
          }
        } catch (friendsError) {
          console.warn('Friends API error, using empty data:', friendsError);
        }

        // Try to fetch mutual friends (may fail if not authenticated)
        try {
          console.log('Fetching mutual friends for userId:', userId);
          const mutualFriendsResponse = await fetch(`/api/friends/mutual?userId=${userId}`);
          console.log('Mutual friends response status:', mutualFriendsResponse.status);
          
          if (mutualFriendsResponse.ok) {
            mutualFriendsData = await mutualFriendsResponse.json();
            console.log('Mutual friends data:', mutualFriendsData);
          } else {
            console.warn('Mutual friends API failed, using empty data');
          }
        } catch (mutualFriendsError) {
          console.warn('Mutual friends API error, using empty data:', mutualFriendsError);
        }

        // Calculate stats
        const activeCases = casesData.cases?.filter((c: CaseData) => c.status === 'ACTIVE') || [];
        const pastCases = casesData.cases?.filter((c: CaseData) => c.status === 'COMPLETED' || c.status === 'CLOSED') || [];
        const caseApplications = casesData.cases?.filter((c: CaseData) => c.status === 'PENDING') || [];

        const stats: UserStats = {
          followers: userData.followers || 0,
          following: userData.following || 0,
          endorsements: userData.endorsements || 0,
          mutualConnections: userData.mutualConnections || 0,
          friends: friendsData.friends?.length || 0,
          mutualFriends: mutualFriendsData.mutualFriends?.length || 0,
          views: userData.profileViews || 0,
          totalCases: casesData.cases?.length || 0,
          activeCases: activeCases.length,
          completedCases: pastCases.length,
        };

        setProfileData({
          user: userData,
          stats,
          activeCases,
          pastCases,
          caseApplications,
          friends: friendsData.friends || [],
          mutualFriends: mutualFriendsData.mutualFriends || [],
          isLoading: false,
          error: null,
        });

      } catch (error) {
        console.error('Error fetching profile data:', error);
        setProfileData(prev => ({
          ...prev,
          isLoading: false,
          error: error instanceof Error ? error.message : 'Failed to fetch profile data',
        }));
      }
    };

    fetchProfileData();
  }, [userId]);

  return profileData;
}