'use client';

import { useState, useEffect, useCallback } from 'react';
import { tasksClient, TaskFilters, CreateTaskData } from '@/clients/tasks-client';
import { updateTaskStatus, createTask as createTaskAction } from '@/actions/tasks';
import { Task, TaskStats, TaskStatus } from '@/lib/types';

interface UseTasksState {
  tasks: Task[];
  stats: TaskStats;
  loading: boolean;
  error: string | null;
  syncing: boolean; // Pour indiquer les opérations optimistes en cours
}

interface UseTasksActions {
  refreshTasks: () => Promise<void>;
  createTask: (data: CreateTaskData) => Promise<Task | null>;
  updateTaskOptimistic: (taskId: string, status: TaskStatus) => Promise<Task | null>;
  setFilters: (filters: TaskFilters) => void;
}

/**
 * Hook pour la gestion des tâches
 */
export function useTasks(
  initialFilters?: TaskFilters, 
  initialData?: { tasks: Task[]; stats?: TaskStats }
): UseTasksState & UseTasksActions {
  const [state, setState] = useState<UseTasksState>({
    tasks: initialData?.tasks || [],
    stats: initialData?.stats || {
      total: 0,
      completed: 0,
      inProgress: 0,
      todo: 0,
      backlog: 0,
      cancelled: 0,
      freeze: 0,
      archived: 0,
      completionRate: 0
    },
    loading: false,
    error: null,
    syncing: false
  });

  const [filters, setFilters] = useState<TaskFilters>(initialFilters || {});

  /**
   * Récupère les tâches depuis l'API
   */
  const refreshTasks = useCallback(async () => {
    setState(prev => ({ ...prev, loading: true, error: null }));
    
    try {
      const response = await tasksClient.getTasks({ ...filters, limit: undefined });
      
      setState(prev => ({
        ...prev,
        tasks: response.data,
        stats: response.stats,
        loading: false
      }));
    } catch (error) {
      setState(prev => ({
        ...prev,
        loading: false,
        error: error instanceof Error ? error.message : 'Erreur inconnue'
      }));
    }
  }, [filters]);

  /**
   * Crée une nouvelle tâche
   */
  const createTask = useCallback(async (data: CreateTaskData): Promise<Task | null> => {
    setState(prev => ({ ...prev, loading: true, error: null }));
    
    try {
      const result = await createTaskAction({
        title: data.title,
        description: data.description,
        status: data.status,
        priority: data.priority,
        tags: data.tags
      });
      
      if (result.success) {
        // Rafraîchir la liste après création
        await refreshTasks();
        return result.data as Task;
      } else {
        throw new Error(result.error || 'Erreur lors de la création');
      }
    } catch (error) {
      setState(prev => ({
        ...prev,
        loading: false,
        error: error instanceof Error ? error.message : 'Erreur lors de la création'
      }));
      return null;
    }
  }, [refreshTasks]);

  // Note: updateTask et deleteTask ont été migrés vers Server Actions
  // Voir /src/actions/tasks.ts pour updateTaskTitle, updateTaskStatus, deleteTask

  /**
   * Met à jour le statut d'une tâche de manière optimiste (pour drag & drop)
   */
  const updateTaskOptimistic = useCallback(async (taskId: string, status: TaskStatus): Promise<Task | null> => {
    // 1. Sauvegarder l'état actuel pour rollback
    const currentTasks = state.tasks;
    const taskToUpdate = currentTasks.find(t => t.id === taskId);
    
    if (!taskToUpdate) {
      console.error('Tâche non trouvée pour mise à jour optimiste:', taskId);
      return null;
    }

    // 2. Mise à jour optimiste immédiate de l'état local
    const updatedTask = { ...taskToUpdate, status };
    const updatedTasks = currentTasks.map(task => 
      task.id === taskId ? updatedTask : task
    );

    // Recalculer les stats
    const newStats = {
      total: updatedTasks.length,
      completed: updatedTasks.filter(t => t.status === 'done').length,
      inProgress: updatedTasks.filter(t => t.status === 'in_progress').length,
      todo: updatedTasks.filter(t => t.status === 'todo').length,
      backlog: updatedTasks.filter(t => t.status === 'backlog').length,
      cancelled: updatedTasks.filter(t => t.status === 'cancelled').length,
      freeze: updatedTasks.filter(t => t.status === 'freeze').length,
      archived: updatedTasks.filter(t => t.status === 'archived').length,
      completionRate: updatedTasks.length > 0 
        ? Math.round((updatedTasks.filter(t => t.status === 'done').length / updatedTasks.length) * 100)
        : 0
    };

    setState(prev => ({
      ...prev,
      tasks: updatedTasks,
      stats: newStats,
      error: null,
      syncing: true // Indiquer qu'une synchronisation est en cours
    }));

    // 3. Appel Server Action en arrière-plan
    try {
      const result = await updateTaskStatus(taskId, status);
      
      // Si l'action réussit, la revalidation automatique se charge du reste
      if (result.success) {
        setState(prev => ({ ...prev, syncing: false }));
        return result.data as Task;
      } else {
        throw new Error(result.error || 'Erreur lors de la mise à jour');
      }
    } catch (error) {
      // 4. Rollback en cas d'erreur
      setState(prev => ({
        ...prev,
        tasks: currentTasks,
        stats: {
          total: currentTasks.length,
          completed: currentTasks.filter(t => t.status === 'done').length,
          inProgress: currentTasks.filter(t => t.status === 'in_progress').length,
          todo: currentTasks.filter(t => t.status === 'todo').length,
          backlog: currentTasks.filter(t => t.status === 'backlog').length,
          cancelled: currentTasks.filter(t => t.status === 'cancelled').length,
          freeze: currentTasks.filter(t => t.status === 'freeze').length,
          archived: currentTasks.filter(t => t.status === 'archived').length,
          completionRate: currentTasks.length > 0 
            ? Math.round((currentTasks.filter(t => t.status === 'done').length / currentTasks.length) * 100)
            : 0
        },
        error: error instanceof Error ? error.message : 'Erreur lors de la mise à jour',
        syncing: false // Arrêter l'indicateur de synchronisation
      }));
      
      console.error('Erreur lors de la mise à jour optimiste:', error);
      return null;
    }
  }, [state.tasks]);

  // Note: deleteTask a été migré vers Server Actions
  // Utilisez directement deleteTask depuis /src/actions/tasks.ts dans les composants

  // Charger les tâches au montage seulement si pas de données initiales
  useEffect(() => {
    if (!initialData?.tasks?.length) {
      refreshTasks();
    }
  }, [refreshTasks, initialData?.tasks?.length]);

  return {
    ...state,
    refreshTasks,
    createTask,
    updateTaskOptimistic,
    setFilters
  };
}