import React, { useState, useEffect } from 'react';
import { toast } from 'react-toastify';

// Definição de tarefas para os agentes
export interface AgentTask {
  id: string;
  agentId: string;
  description: string;
  status: 'pending' | 'in-progress' | 'completed' | 'failed';
  result?: string;
  error?: string;
  createdAt: Date;
  completedAt?: Date;
}

// Definição de plano de execução
export interface ExecutionPlan {
  id: string;
  name: string;
  description: string;
  steps: {
    id: string;
    description: string;
    agentId: string;
    dependsOn?: string[];
    status: 'pending' | 'in-progress' | 'completed' | 'failed';
  }[];
  createdAt: Date;
  status: 'pending' | 'in-progress' | 'completed' | 'failed';
}

interface AgentOrchestratorProps {
  userPrompt: string;
  html: string;
  availableAgents: string[];
  onTaskCreated: (task: AgentTask) => void;
  onPlanCreated: (plan: ExecutionPlan) => void;
  onTaskUpdated: (taskId: string, status: AgentTask['status'], result?: string) => void;
}

/**
 * Componente orquestrador - responsável por:
 * 1. Analisar a solicitação do usuário
 * 2. Criar um plano de execução
 * 3. Distribuir tarefas para agentes específicos
 * 4. Monitorar progresso
 */
const AgentOrchestrator: React.FC<AgentOrchestratorProps> = ({
  userPrompt,
  html,
  availableAgents,
  onTaskCreated,
  onPlanCreated,
  onTaskUpdated
}) => {
  const [isPlanning, setIsPlanning] = useState(false);
  const [currentPlan, setCurrentPlan] = useState<ExecutionPlan | null>(null);

  // Função para criar um novo plano baseado na solicitação do usuário
  const createPlan = async (prompt: string) => {
    setIsPlanning(true);
    try {
      // Usar o modelo de IA para criar um plano de execução
      // (Na implementação real, isso seria uma chamada para um LLM específico)
      const plan: ExecutionPlan = {
        id: `plan-${Date.now()}`,
        name: `Plano para: ${prompt.substring(0, 30)}...`,
        description: `Plano de execução para atender à solicitação: "${prompt}"`,
        steps: [
          {
            id: `step-1-${Date.now()}`,
            description: 'Analisar requisitos e criar estrutura básica',
            agentId: availableAgents[0] || 'default',
            status: 'pending'
          },
          {
            id: `step-2-${Date.now()}`,
            description: 'Implementar funcionalidades principais',
            agentId: availableAgents[1] || availableAgents[0] || 'default',
            dependsOn: [`step-1-${Date.now()}`],
            status: 'pending'
          },
          {
            id: `step-3-${Date.now()}`,
            description: 'Finalizar e otimizar',
            agentId: availableAgents[2] || availableAgents[0] || 'default',
            dependsOn: [`step-2-${Date.now()}`],
            status: 'pending'
          }
        ],
        createdAt: new Date(),
        status: 'pending'
      };
      
      setCurrentPlan(plan);
      onPlanCreated(plan);
      
      // Criar primeira tarefa baseada no plano
      const firstStep = plan.steps[0];
      const task: AgentTask = {
        id: `task-${Date.now()}`,
        agentId: firstStep.agentId,
        description: `${firstStep.description} para: "${prompt}"`,
        status: 'pending',
        createdAt: new Date()
      };
      
      onTaskCreated(task);
      
    } catch (error) {
      toast.error('Erro ao criar plano de execução');
      console.error('Erro ao criar plano:', error);
    } finally {
      setIsPlanning(false);
    }
  };

  // Monitorar mudanças na solicitação do usuário
  useEffect(() => {
    if (userPrompt && !isPlanning && !currentPlan) {
      createPlan(userPrompt);
    }
  }, [userPrompt]);

  return null; // Este é um componente lógico, não renderiza UI
};

export default AgentOrchestrator; 