# aduc_framework/director.py
#
# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
#
# Versão 3.0.0 (Framework State Manager)
#
# Este arquivo contém a classe AducDirector. Sua única responsabilidade
# é gerenciar o objeto de estado da geração (GenerationState). Ele atua
# como o "score" da orquestra ou o "script" do filme, mantendo um registro
# preciso de todos os parâmetros e artefatos gerados.

import logging
import os
from typing import List, Dict, Any

# Importa os modelos de dados Pydantic que ele irá gerenciar
from .types import GenerationState, PreProductionParams, ProductionParams, Ato, MediaRef, KeyframeData, VideoData

logger = logging.getLogger(__name__)

class AducDirector:
    """
    Representa o Diretor de Cena, responsável por gerenciar o estado da produção.
    Atua como a fonte única da verdade para todos os dados relacionados a uma
    única tarefa de geração de vídeo.
    """
    def __init__(self, workspace_dir: str):
        """
        Inicializa o Diretor.

        Args:
            workspace_dir (str): O diretório onde os artefatos são salvos.
                                 O Diretor usa isso para referenciar caminhos se necessário.
        """
        self.workspace_dir = workspace_dir
        self.state: GenerationState = self._initialize_state()
        os.makedirs(self.workspace_dir, exist_ok=True)
        logger.info(f"AducDirector inicializado. O estado de geração foi criado.")

    def _initialize_state(self) -> GenerationState:
        """
        Cria uma instância vazia e válida do modelo GenerationState.
        """
        return GenerationState()

    def get_full_state(self) -> GenerationState:
        """
        Retorna o objeto de estado Pydantic completo.

        Returns:
            GenerationState: O estado atual da geração.
        """
        return self.state
    
    def get_full_state_as_dict(self) -> Dict[str, Any]:
        """
        Retorna o estado completo serializado como um dicionário Python.
        Útil para passar para bibliotecas que não suportam Pydantic diretamente.

        Returns:
            Dict[str, Any]: O estado atual como um dicionário.
        """
        return self.state.model_dump()

    def update_parameters(self, stage: str, params: Any):
        """
        Atualiza o nó de parâmetros no estado de geração.

        Args:
            stage (str): O estágio da produção ('pre_producao', 'producao', etc.).
            params (BaseModel): O objeto Pydantic contendo os parâmetros para aquele estágio.
        """
        if hasattr(self.state.parametros_geracao, stage):
            setattr(self.state.parametros_geracao, stage, params)
            logger.info(f"Parâmetros do estágio '{stage}' atualizados no estado.")
        else:
            logger.warning(f"Tentativa de atualizar parâmetros para um estágio desconhecido: '{stage}'")

    def update_pre_production_state(self, prompt: str, ref_paths: List[str], storyboard: List[str]):
        """
        Popula as seções iniciais do estado após a geração do storyboard.

        Args:
            prompt (str): O prompt geral.
            ref_paths (List[str]): Lista de caminhos para as mídias de referência.
            storyboard (List[str]): Lista de resumos dos atos.
        """
        self.state.Promt_geral = prompt
        self.state.midias_referencia = [MediaRef(id=i, caminho=path) for i, path in enumerate(ref_paths)]
        self.state.Atos = [Ato(id=i, resumo_ato=ato) for i, ato in enumerate(storyboard)]
        logger.info("Estado de pré-produção (prompt, referências, atos) atualizado.")

    def update_keyframes_state(self, keyframes_data: List[Dict[str, Any]]):
        """
        Atualiza a lista de keyframes no estado.

        Args:
            keyframes_data (List[Dict[str, Any]]): Uma lista de dicionários, cada um
                                                   representando os dados de um keyframe.
        """
        # Converte os dicionários em modelos Pydantic KeyframeData
        self.state.Keyframe_atos = [KeyframeData(**data) for data in keyframes_data]
        logger.info(f"{len(keyframes_data)} keyframes adicionados ao estado.")

    def update_video_state(self, video_data_dict: Dict[str, Any]):
        """
        Atualiza a lista de vídeos gerados no estado.

        Args:
            video_data_dict (Dict[str, Any]): Um dicionário representando os dados do vídeo gerado.
        """
        # Converte o dicionário em um modelo Pydantic VideoData
        video_model = VideoData(**video_data_dict)
        # Atualmente, substituímos a lista, mas poderíamos adicionar a ela no futuro.
        self.state.videos_atos = [video_model]
        logger.info("Dados da produção de vídeo atualizados no estado.")