import os
from pathlib import Path
import cv2
from .processors.filters import ImageFilters
from .processors.document import DocumentProcessor
from .processors.superres import SuperResolution
from .utils.image_io import ImageIO


class Engine:
    """
    Orquestrador principal do pipeline de processamento de imagens.
    """
    
    def __init__(self, output_dir='output', quality=95, output_format='auto',
                 denoise_strength=10, contrast_clip=3.0, extra_sharpen=False,
                 verbose=False):
        """
        Inicializa o engine de processamento.
        
        Args:
            output_dir: Diretório de saída
            quality: Qualidade JPEG (1-100)
            output_format: Formato de saída ('auto', 'png', 'jpg')
            denoise_strength: Força do denoise (0-30)
            contrast_clip: Intensidade do CLAHE (1.0-5.0)
            extra_sharpen: Aplicar sharpening adicional
            verbose: Modo verboso
        """
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
        
        self.quality = quality
        self.output_format = output_format
        self.denoise_strength = denoise_strength
        self.contrast_clip = contrast_clip
        self.extra_sharpen = extra_sharpen
        self.verbose = verbose
        
        # Inicializar processadores
        self.filters = ImageFilters(
            denoise_strength=denoise_strength,
            contrast_clip=contrast_clip
        )
        self.doc_processor = DocumentProcessor()
        self.superres = SuperResolution()
        self.io = ImageIO()
    
    def run(self, input_path, mode='general', upscale=False):
        """
        Executa o pipeline de processamento.
        
        Args:
            input_path: Caminho da imagem de entrada
            mode: Modo de processamento ('general', 'text', 'dark', 'superres')
            upscale: Aplicar super-resolução
            
        Returns:
            Caminho da imagem de saída
        """
        if self.verbose:
            print(f"[DEBUG] Carregando: {input_path}")
        
        # Carregar imagem
        img = self.io.load(input_path)
        
        if img is None:
            raise ValueError(f"Não foi possível carregar a imagem: {input_path}")
        
        # Aplicar processamento baseado no modo
        if mode == 'general':
            img = self._process_general(img)
        elif mode == 'text':
            img = self._process_text(img)
        elif mode == 'dark':
            img = self._process_dark(img)
        elif mode == 'superres':
            img = self._process_superres(img)
        else:
            raise ValueError(f"Modo desconhecido: {mode}")
        
        # Aplicar super-resolução se solicitado
        if upscale and mode != 'superres':
            if self.verbose:
                print("[DEBUG] Aplicando super-resolução...")
            img = self.superres.upscale(img)
        
        # Sharpening extra se solicitado
        if self.extra_sharpen:
            if self.verbose:
                print("[DEBUG] Aplicando sharpen extra...")
            img = self.filters.sharpen(img, strength=1.5)
        
        # Salvar imagem
        output_path = self._get_output_path(input_path, mode, upscale)
        
        if self.verbose:
            print(f"[DEBUG] Salvando em: {output_path}")
        
        self.io.save(img, str(output_path), quality=self.quality)
        
        return output_path
    
    def _process_general(self, img):
        """Pipeline de melhoria geral."""
        img = self.filters.denoise(img)
        img = self.filters.enhance_contrast(img)
        img = self.filters.sharpen(img)
        return img
    
    def _process_text(self, img):
        """Pipeline otimizado para texto e documentos."""
        # Melhorias básicas
        img = self.filters.denoise(img)
        img = self.filters.enhance_contrast(img)
        
        # Processamento específico para texto
        img = self.doc_processor.enhance_text(img)
        
        return img
    
    def _process_dark(self, img):
        """Pipeline otimizado para interfaces escuras."""
        # Processamento específico para UIs escuras
        img = self.filters.denoise(img, strength=self.denoise_strength * 0.7)
        img = self.filters.enhance_dark_ui(img)
        img = self.filters.sharpen(img, strength=0.8)
        
        return img
    
    def _process_superres(self, img):
        """Pipeline com foco em super-resolução."""
        # Limpeza básica antes do upscale
        img = self.filters.denoise(img, strength=self.denoise_strength * 1.2)
        
        # Super-resolução
        img = self.superres.upscale(img)
        
        # Refinamento pós-upscale
        img = self.filters.enhance_contrast(img)
        img = self.filters.sharpen(img, strength=0.5)
        
        return img
    
    def _get_output_path(self, input_path, mode, upscale):
        """Gera o caminho de saída baseado nas configurações."""
        input_path = Path(input_path)
        
        # Determinar extensão de saída
        if self.output_format == 'auto':
            ext = input_path.suffix
        else:
            ext = f'.{self.output_format}'
        
        # Nome do arquivo com sufixos
        suffix = f"_{mode}"
        if upscale:
            suffix += "_2x"
        
        output_name = f"{input_path.stem}{suffix}{ext}"
        
        return self.output_dir / output_name
