"""
Main - Script principal para processamento de documentos
Descomplicar - Agência de Aceleração Digital
https://www.descomplicar.pt
"""

import os
import argparse
from urllib.parse import urlparse
from datetime import datetime
from pathlib import Path
from processors.pdf_processor import PDFProcessor
from processors.txt_processor import TXTProcessor
from processors.web_processor import WebProcessor
from enrichment.faq_generator import FAQGenerator
from dotenv import load_dotenv

load_dotenv()

def is_url(string: str) -> bool:
    """
    Verifica se uma string é uma URL válida.
    
    Args:
        string (str): String a verificar
        
    Returns:
        bool: True se for URL, False caso contrário
    """
    try:
        result = urlparse(string)
        return all([result.scheme, result.netloc])
    except ValueError:
        return False

def process_document(input_path: str, output_file: str = None) -> None:
    """
    Processa um documento e gera o output formatado.
    
    Args:
        input_path (str): Caminho do ficheiro ou URL de entrada
        output_file (str): Caminho do ficheiro de saída (opcional)
    """
    # Verificar se é URL ou ficheiro local
    if is_url(input_path):
        processor = WebProcessor(input_path)
    else:
        # Determinar tipo de ficheiro
        file_ext = os.path.splitext(input_path)[1].lower()
        
        # Selecionar processador apropriado
        if file_ext == '.pdf':
            processor = PDFProcessor(input_path)
        elif file_ext in ['.txt', '.md']:
            processor = TXTProcessor(input_path)
        else:
            raise ValueError(f"Tipo de ficheiro não suportado: {file_ext}")
    
    try:
        # Processar conteúdo
        processor.process_content()
        
        # Gerar FAQs para cada capítulo
        faq_gen = FAQGenerator()
        for chapter in processor.chapters:
            faqs = faq_gen.generate_faqs(chapter['content'])
            chapter['faqs'] = faqs
        
        # Definir ficheiro de saída se não especificado
        if not output_file:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            if is_url(input_path):
                base_name = urlparse(input_path).netloc.replace('.', '_')
            else:
                base_name = os.path.splitext(os.path.basename(input_path))[0]
            
            # Usar caminho absoluto
            output_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "output")
            output_file = os.path.join(output_dir, f"{base_name}_{timestamp}.md")
        
        # Criar diretório de saída se não existir
        os.makedirs(os.path.dirname(output_file), exist_ok=True)
        
        # Salvar resultado
        processor.save_markdown(output_file)
        print(f"Documento processado com sucesso: {output_file}")
        
    except Exception as e:
        print(f"Erro ao processar documento: {str(e)}")
        raise

def main():
    """Função principal."""
    parser = argparse.ArgumentParser(description='Processador de documentos com geração de FAQs')
    parser.add_argument('input', help='Ficheiro de entrada ou URL')
    parser.add_argument('-o', '--output', help='Ficheiro de saída (opcional)')
    
    args = parser.parse_args()
    process_document(args.input, args.output)

if __name__ == "__main__":
    main()