# aduc_framework/engineers/planner_2d.py
#
# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
#
# Versão 1.1.0 (Strategic Execution Planner)
#
# O Planner2D atua como o Engenheiro-Chefe ou Planejador Estratégico.
# Sua responsabilidade é receber a demanda de alto nível do Orquestrador
# e fragmentá-la em um plano de execução de tarefas sequenciais para o Composer.
# Ele NÃO interage com o LLM.

import logging
from typing import List, Dict, Any, Generator, Optional, Callable

logger = logging.getLogger(__name__)

class Planner2D:
    """
    O Planner2D cria o plano de trabalho estratégico (o `execution_plan`)
    para a fase de pré-produção, que será executado pelo Composer.
    """

    def generate_execution_plan(
        self,
        global_prompt: str,
        num_scenes: int,
        max_duration_per_act: float,
        callback: Optional[Callable] = None
    ) -> Generator[Dict[str, Any], None, List[Dict[str, Any]]]:
        """
        Cria e emite o plano de execução para a pré-produção.

        Args:
            global_prompt (str): A ideia central do filme.
            num_scenes (int): O número de cenas desejadas.
            max_duration_per_act (float): A duração máxima para cada ato.
            callback (Callable, optional): Callback para reportar progresso ao Maestro.

        Yields:
            Dict[str, Any]: Dicionários de atualização de status para a UI.

        Returns:
            List[Dict[str, Any]]: A lista final de tarefas do plano de execução.
        """
        message = "Planner2D: Criando plano de execução estratégico para a pré-produção..."
        logger.info(message)
        if callback:
            # Informa o início do planejamento. Como é rápido, usamos progresso 0.0
            callback(0.0, desc="Iniciando planejamento estratégico...")
        
        # Emite um log inicial para a UI via Orquestrador
        yield {"status": "planning", "progress": 0.0, "message": message}

        # --- Definição do Plano de Execução Estratégico ---
        # Esta é a "Planta da Obra", a sequência de tarefas que o Composer seguirá.
        # Cada tarefa tem uma descrição clara para ser exibida na UI.
        execution_plan = [
            {
                "task_id": "PREPROD_01_CATALOG_ASSETS",
                "description": "Catalogando assets visuais (cenários, personagens, objetos)...",
                "inputs": {"global_prompt": global_prompt},
                "status": "pending"
            },
            {
                "task_id": "PREPROD_02_SCORE_ASSETS",
                "description": "Avaliando a relevância de cada asset para a história...",
                "inputs": {"global_prompt": global_prompt},
                "status": "pending"
            },
            {
                "task_id": "PREPROD_03_CREATE_SUMMARY",
                "description": "Criando o resumo do roteiro...",
                "inputs": {"global_prompt": global_prompt, "num_scenes": num_scenes},
                "status": "pending"
            },
            {
                "task_id": "PREPROD_04_FRAGMENT_SCENES",
                "description": "Dividindo a história em cenas principais...",
                "inputs": {"num_scenes": num_scenes},
                "status": "pending"
            },
            {
                "task_id": "PREPROD_05_REVIEW_PLAN",
                "description": "Revisando o plano de cenas para coerência...",
                "inputs": {},
                "status": "pending"
            },
            {
                "task_id": "PREPROD_06_FRAGMENT_ACTS",
                "description": "Dividindo cada cena em atos cinematográficos...",
                "inputs": {"max_duration_per_act": max_duration_per_act},
                "status": "pending"
            }
        ]
        
        message = f"Planner2D: Plano de execução com {len(execution_plan)} tarefas criado."
        logger.info(message)
        if callback:
             # Informa a conclusão do planejamento. Usamos um progresso pequeno (ex: 0.1)
             # para indicar que esta fase terminou e a próxima, mais longa (Composer), vai começar.
            callback(0.1, desc="Plano estratégico concluído. Iniciando execução...")

        # Emite uma atualização final para a UI, incluindo o plano gerado
        yield {"status": "planning_complete", "progress": 0.1, "message": message, "plan": execution_plan}
        
        return execution_plan

# --- Instância Singleton ---
# A instância única do Planner2D para ser usada em todo o framework.
planner_2d_singleton = Planner2D()