/**
 * @ai-summary React Query hooks for dashboard data
 */

import { useQuery } from '@tanstack/react-query';
import { useAuth0 } from '@auth0/auth0-react';
import { vehiclesApi } from '../../vehicles/api/vehicles.api';
import { fuelLogsApi } from '../../fuel-logs/api/fuel-logs.api';
import { maintenanceApi } from '../../maintenance/api/maintenance.api';
import { DashboardSummary, VehicleNeedingAttention } from '../types';

/**
 * Hook to fetch dashboard summary stats
 */
export const useDashboardSummary = () => {
  const { isAuthenticated, isLoading: authLoading } = useAuth0();

  return useQuery({
    queryKey: ['dashboard', 'summary'],
    queryFn: async (): Promise<DashboardSummary> => {
      // Fetch all required data in parallel
      const [vehicles, fuelLogs] = await Promise.all([
        vehiclesApi.getAll(),
        fuelLogsApi.getUserFuelLogs(),
      ]);

      // Fetch schedules for all vehicles to count upcoming maintenance
      const allSchedules = await Promise.all(
        vehicles.map(v => maintenanceApi.getSchedulesByVehicle(v.id))
      );
      const flatSchedules = allSchedules.flat();

      // Calculate upcoming maintenance (next 30 days)
      const thirtyDaysFromNow = new Date();
      thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30);

      const upcomingMaintenance = flatSchedules.filter(schedule => {
        // Count schedules as upcoming if they have a next due date within 30 days
        if (!schedule.nextDueDate) return false;
        const dueDate = new Date(schedule.nextDueDate);
        return dueDate >= new Date() && dueDate <= thirtyDaysFromNow;
      });

      // Calculate recent fuel logs (last 7 days)
      const sevenDaysAgo = new Date();
      sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);

      const recentFuelLogs = fuelLogs.filter(log => {
        const logDate = new Date(log.dateTime);
        return logDate >= sevenDaysAgo;
      });

      return {
        totalVehicles: vehicles.length,
        upcomingMaintenanceCount: upcomingMaintenance.length,
        recentFuelLogsCount: recentFuelLogs.length,
      };
    },
    enabled: isAuthenticated && !authLoading,
    staleTime: 2 * 60 * 1000, // 2 minutes - fresher than other queries for dashboard
    gcTime: 5 * 60 * 1000, // 5 minutes cache time
    retry: (failureCount, error: any) => {
      // Retry 401 errors up to 3 times for mobile auth timing issues
      if (error?.response?.status === 401 && failureCount < 3) {
        console.log(`[Mobile Auth] Dashboard retry ${failureCount + 1}/3 for 401 error`);
        return true;
      }
      return false;
    },
    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
  });
};

/**
 * Hook to fetch vehicles needing attention (overdue maintenance)
 */
export const useVehiclesNeedingAttention = () => {
  const { isAuthenticated, isLoading: authLoading } = useAuth0();

  return useQuery({
    queryKey: ['dashboard', 'vehiclesNeedingAttention'],
    queryFn: async (): Promise<VehicleNeedingAttention[]> => {
      // Fetch vehicles
      const vehicles = await vehiclesApi.getAll();

      const vehiclesNeedingAttention: VehicleNeedingAttention[] = [];
      const now = new Date();

      // Check each vehicle for overdue maintenance
      for (const vehicle of vehicles) {
        const schedules = await maintenanceApi.getSchedulesByVehicle(vehicle.id);

        // Find overdue schedules
        const overdueSchedules = schedules.filter(schedule => {
          if (!schedule.nextDueDate) return false;
          const dueDate = new Date(schedule.nextDueDate);
          return dueDate < now;
        });

        if (overdueSchedules.length > 0) {
          // Calculate priority based on how overdue the maintenance is
          const mostOverdue = overdueSchedules.reduce((oldest, current) => {
            const oldestDate = new Date(oldest.nextDueDate!);
            const currentDate = new Date(current.nextDueDate!);
            return currentDate < oldestDate ? current : oldest;
          });

          const daysOverdue = Math.floor((now.getTime() - new Date(mostOverdue.nextDueDate!).getTime()) / (1000 * 60 * 60 * 24));

          let priority: 'high' | 'medium' | 'low' = 'low';
          if (daysOverdue > 30) {
            priority = 'high';
          } else if (daysOverdue > 14) {
            priority = 'medium';
          }

          vehiclesNeedingAttention.push({
            ...vehicle,
            reason: `${overdueSchedules.length} overdue maintenance ${overdueSchedules.length === 1 ? 'item' : 'items'}`,
            priority,
          });
        }
      }

      // Sort by priority (high -> medium -> low)
      const priorityOrder = { high: 0, medium: 1, low: 2 };
      return vehiclesNeedingAttention.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
    },
    enabled: isAuthenticated && !authLoading,
    staleTime: 2 * 60 * 1000, // 2 minutes
    gcTime: 5 * 60 * 1000, // 5 minutes cache time
    retry: (failureCount, error: any) => {
      if (error?.response?.status === 401 && failureCount < 3) {
        console.log(`[Mobile Auth] Vehicles attention retry ${failureCount + 1}/3 for 401 error`);
        return true;
      }
      return false;
    },
    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
  });
};
