import { useState, useCallback, useEffect, useRef } from 'react';

export type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed';

export interface ForensicTask {
  id: string;
  fileName: string;
  status: TaskStatus;
  progress: number;
  error?: string;
  startTime?: number;
  endTime?: number;
}

export function useTaskQueue(processTask: (taskId: string) => Promise<void>) {
  const [tasks, setTasks] = useState<ForensicTask[]>([]);
  const processingRef = useRef<boolean>(false);

  const addTask = useCallback((fileName: string) => {
    const id = Math.random().toString(36).substr(2, 9);
    const newTask: ForensicTask = {
      id,
      fileName,
      status: 'pending',
      progress: 0,
    };
    setTasks(prev => [...prev, newTask]);
    return id;
  }, []);

  const updateTask = useCallback((id: string, updates: Partial<ForensicTask> | ((task: ForensicTask) => Partial<ForensicTask>)) => {
    setTasks(prev => prev.map(task => {
      if (task.id === id) {
        const resolvedUpdates = typeof updates === 'function' ? updates(task) : updates;
        return { ...task, ...resolvedUpdates };
      }
      return task;
    }));
  }, []);

  const removeTask = useCallback((id: string) => {
    setTasks(prev => prev.filter(task => task.id !== id));
  }, []);

  const clearCompleted = useCallback(() => {
    setTasks(prev => prev.filter(task => task.status !== 'completed' && task.status !== 'failed'));
  }, []);

  useEffect(() => {
    const runQueue = async () => {
      if (processingRef.current) return;
      
      const pendingTask = tasks.find(t => t.status === 'pending');
      if (!pendingTask) return;

      processingRef.current = true;
      
      try {
        updateTask(pendingTask.id, { status: 'processing', startTime: Date.now() });
        await processTask(pendingTask.id);
        updateTask(pendingTask.id, { status: 'completed', progress: 100, endTime: Date.now() });
      } catch (error) {
        updateTask(pendingTask.id, { 
          status: 'failed', 
          error: error instanceof Error ? error.message : String(error),
          endTime: Date.now() 
        });
      } finally {
        processingRef.current = false;
      }
    };

    runQueue();
  }, [tasks, processTask, updateTask]);

  return {
    tasks,
    addTask,
    updateTask,
    removeTask,
    clearCompleted,
    isProcessing: tasks.some(t => t.status === 'processing'),
  };
}