"""Lógica de descubrimiento de archivos y radicados.

Separa la lógica de recorrer el sistema de archivos del servicio principal.
"""
import os
from typing import List, Optional, Tuple
from core.utils import find_first_matching_file, ALLOWED_DOC_EXTS


def get_sorted_radicados(root_path: str) -> List[str]:
    """Devuelve una lista ordenada de nombres de subdirectorios (radicados) en root_path."""
    if not os.path.isdir(root_path):
        return []
    return sorted([d for d in os.listdir(root_path) if os.path.isdir(os.path.join(root_path, d))])


def get_files_as_radicados(root_path: str) -> List[str]:
    """Devuelve una lista de nombres de archivos (sin extensión) que actúan como radicados."""
    if not os.path.isdir(root_path):
        return []
    files = sorted([f for f in os.listdir(root_path) if f.lower().endswith(ALLOWED_DOC_EXTS)])
    # Retornamos el nombre completo del archivo para que el procesador pueda encontrarlo,
    # O retornamos el stem y luego reconstruimos?
    # El procesador espera "radicado" que luego usa para os.path.join(root, rad).
    # Si retornamos el nombre de archivo, os.path.join funcionará para encontrar el archivo.
    # Pero el "radicado" visual debe ser sin extensión.
    # Vamos a retornar el nombre de archivo completo aquí, y el procesador deberá manejarlo.
    return files


def find_file_for_type_in_radicados(
    root_path: str,
    radicados: List[str],
    keyword: str
) -> Tuple[Optional[str], Optional[str]]:
    """Busca el primer archivo que coincida con keyword en la lista de radicados.
    
    Retorna: (ruta_completa_del_archivo, nombre_del_radicado)
    """
    for rad in radicados:
        rad_path = os.path.join(root_path, rad)
        
        # Si rad es un archivo (modo General), verificamos si coincide
        if os.path.isfile(rad_path):
             # En modo general, 'rad' es el nombre del archivo.
             # Si hay keyword, verificamos si el archivo coincide con el keyword.
             # Pero esta función se usa para "Multi-Doc Type", donde buscamos UN archivo para UN tipo.
             # Si estamos en modo general, el archivo ES el documento.
             # Simplemente retornamos el archivo si coincide con el keyword (o si no hay keyword).
             from core.utils import _matches_pattern
             if not keyword or _matches_pattern(rad, keyword):
                 return rad_path, os.path.splitext(rad)[0]
             continue

        try:
            files = sorted(os.listdir(rad_path))
        except Exception:
            continue
        
        match_name = find_first_matching_file(files, keyword) if keyword else None
        if match_name:
            return os.path.join(rad_path, match_name), rad
            
    return None, None