ColaFlow-Web/lib/hooks/useAuth.ts

import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { apiClient, tokenManager } from '../api/client';
import { API_ENDPOINTS } from '../api/config';
import { useAuthStore } from '@/stores/authStore';
import { useRouter } from 'next/navigation';

interface LoginCredentials {
  email: string;
  password: string;
  tenantSlug: string;
}

interface RegisterTenantData {
  email: string;
  password: string;
  fullName: string;
  tenantName: string;
}

export function useLogin() {
  const setUser = useAuthStore((state) => state.setUser);
  const router = useRouter();

  return useMutation({
    mutationFn: async (credentials: LoginCredentials) => {
      const { data } = await apiClient.post(API_ENDPOINTS.LOGIN, credentials);
      return data;
    },
    onSuccess: (data) => {
      tokenManager.setAccessToken(data.accessToken);
      tokenManager.setRefreshToken(data.refreshToken);

      // Map backend field names to frontend User type
      // Backend returns: { Id, TenantId, Email, FullName, ... }
      // Frontend expects: { id, tenantId, email, fullName, ... }
      const backendUser = data.user;
      setUser({
        id: backendUser.id || backendUser.Id, // Handle both casing
        email: backendUser.email || backendUser.Email,
        fullName: backendUser.fullName || backendUser.FullName,
        tenantId: backendUser.tenantId || backendUser.TenantId,
        tenantName: data.tenant?.name || data.tenant?.Name || 'Unknown',
        role: data.tenant?.role || backendUser.role || 'TenantMember',
        isEmailVerified: backendUser.isEmailVerified ?? backendUser.IsEmailVerified ?? false,
        createdAt: backendUser.createdAt || backendUser.CreatedAt || new Date().toISOString(),
        updatedAt: backendUser.updatedAt || backendUser.UpdatedAt,
      });

      router.push('/dashboard');
    },
  });
}

export function useRegisterTenant() {
  const router = useRouter();

  return useMutation({
    mutationFn: async (data: RegisterTenantData) => {
      const response = await apiClient.post(
        API_ENDPOINTS.REGISTER_TENANT,
        data
      );
      return response.data;
    },
    onSuccess: () => {
      router.push('/login?registered=true');
    },
  });
}

export function useLogout() {
  const clearUser = useAuthStore((state) => state.clearUser);
  const queryClient = useQueryClient();
  const router = useRouter();

  return useMutation({
    mutationFn: async () => {
      try {
        await apiClient.post(API_ENDPOINTS.LOGOUT);
      } catch {
        // Ignore logout errors
      }
    },
    onSuccess: () => {
      tokenManager.clearTokens();
      clearUser();
      queryClient.clear();
      router.push('/login');
    },
  });
}

export function useCurrentUser() {
  const setUser = useAuthStore((state) => state.setUser);
  const clearUser = useAuthStore((state) => state.clearUser);
  const setLoading = useAuthStore((state) => state.setLoading);

  return useQuery({
    queryKey: ['currentUser'],
    queryFn: async () => {
      const { data } = await apiClient.get(API_ENDPOINTS.ME);

      // Map backend /me response to frontend User type
      // Backend returns: { userId, tenantId, email, fullName, tenantSlug, tenantRole, role }
      // Frontend expects: { id, tenantId, email, fullName, tenantName, role, isEmailVerified, createdAt }
      const mappedUser = {
        id: data.userId || data.id, // Backend uses 'userId'
        email: data.email,
        fullName: data.fullName,
        tenantId: data.tenantId,
        tenantName: data.tenantSlug || 'Unknown', // Use tenantSlug as tenantName fallback
        role: data.tenantRole || data.role || 'TenantMember',
        isEmailVerified: true, // Assume verified if token is valid
        createdAt: new Date().toISOString(),
      };

      setUser(mappedUser);
      setLoading(false);
      return mappedUser;
    },
    enabled: !!tokenManager.getAccessToken(),
    retry: false,
    staleTime: 5 * 60 * 1000, // 5 minutes
    refetchOnWindowFocus: false,
    throwOnError: () => {
      clearUser();
      tokenManager.clearTokens();
      setLoading(false);
      return false;
    },
  });
}