import { useState } from 'react';
import { Task, TaskStatus } from '@/types/types';
import { getTaskStatus, calculateTaskDuration } from '@/utils/taskUtils';
import { createTask, updateTask } from '@/helpers/axios_helper';

interface UseTaskProps {
  onSuccess?: () => void;
  onError?: (error: any) => void;
}

export const useTask = ({ onSuccess, onError }: UseTaskProps = {}) => {
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const handleCreateTask = async (taskData: Partial<Task>) => {
    setIsLoading(true);
    setError(null);

    try {
      // Calculer le statut initial
      const status = getTaskStatus(taskData.startDate ?? null, taskData.dueDate ?? null, null);

      // Créer la tâche avec le statut calculé
      const response = await createTask({
        ...taskData,
        status,
        duration: 'indéterminée',
        appreciation: '',
      });

      onSuccess?.();
      return response;
    } catch (err: any) {
      const errorMessage = err.response?.data?.message || 'Une erreur est survenue lors de la création de la tâche';
      setError(errorMessage);
      onError?.(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  };

  const handleUpdateTask = async (taskId: number, taskData: Partial<Task>) => {
    setIsLoading(true);
    setError(null);

    console.log('🔧 handleUpdateTask appelé avec:', { taskId, taskData });

    try {
      // Si la tâche est marquée comme terminée, calculer la durée et l'appréciation
      let updatedData = { ...taskData };
      
      if (taskData.status === TaskStatus.COMPLETED && !taskData.completedAt) {
        console.log('✅ Tâche marquée comme terminée, calcul de la durée et appréciation...');
        updatedData.completedAt = new Date();
        
        // Récupérer les données actuelles de la tâche pour avoir startDate et dueDate
        // Pour l'instant, on va utiliser les données fournies ou des valeurs par défaut
        const startDate = taskData.startDate || null;
        const dueDate = taskData.dueDate || null;
        
        console.log('📅 Dates pour calcul:', { startDate, dueDate, completedAt: updatedData.completedAt });
        
        const { duration, appreciation } = calculateTaskDuration(
          startDate,
          updatedData.completedAt,
          dueDate
        );
        
        console.log('📊 Résultats du calcul:', { duration, appreciation });
        
        updatedData.duration = duration;
        updatedData.appreciation = appreciation;
      }

      // Calculer le nouveau statut
      updatedData.status = getTaskStatus(
        updatedData.startDate || null,
        updatedData.dueDate || null,
        updatedData.completedAt || null
      );

      console.log('📤 Données envoyées à l\'API:', updatedData);

      const response = await updateTask(taskId, updatedData);
      console.log('✅ Réponse de l\'API:', response);
      
      onSuccess?.();
      return response;
    } catch (err: any) {
      console.error('❌ Erreur dans handleUpdateTask:', err);
      const errorMessage = err.response?.data?.message || 'Une erreur est survenue lors de la mise à jour de la tâche';
      setError(errorMessage);
      onError?.(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  };

  return {
    createTask: handleCreateTask,
    updateTask: handleUpdateTask,
    isLoading,
    error,
  };
};