src/data/loader.py

"""
Módulo de gestión de entrada/salida de datos (I/O).
Centraliza las operaciones de lectura y escritura para garantizar la
consistencia de formatos y la correcta gestión de rutas en el proyecto.
"""

import os
import pandas as pd
import logging
from typing import Optional
from src.utils.config import DATASET_COLUMNS

logger = logging.getLogger(__name__)

# Ruta base por defecto para el entorno de Google Colab
DEFAULT_BASE_DIR = '/content/drive/MyDrive/TFG/data'

def load_dataset(file_path: str, fallback_url: Optional[str] = None) -> pd.DataFrame:
    """
    Carga el dataset RAW original (sin cabeceras, separado por comas).
    Uso: Para la primera carga de datos brutos.
    """
    try:
        logger.info(f"Iniciando carga de datos crudos desde: {file_path}")
        
        # Lectura estándar para el formato original del corpus
        df = pd.read_csv(
            file_path,
            sep=',',
            engine='python',
            header=None,
            names=DATASET_COLUMNS
        )
        logger.info(f"Carga local exitosa: {len(df)} registros.")
        return df

    except FileNotFoundError:
        logger.warning(f"Archivo local no encontrado: {file_path}")
        
        if fallback_url:
            logger.info(f"Intentando descarga desde respaldo remoto: {fallback_url}")
            try:
                df = pd.read_csv(
                    fallback_url,
                    sep=',',
                    engine='python',
                    header=None,
                    names=DATASET_COLUMNS
                )
                logger.info(f"Carga remota exitosa: {len(df)} registros.")
                return df
            except Exception as e:
                logger.critical(f"Fallo crítico en carga remota: {str(e)}")
                raise e
        else:
            raise

    except Exception as e:
        logger.error(f"Error inesperado en load_dataset: {str(e)}")
        raise e

def load_processed_data(filename: str, input_dir: str = DEFAULT_BASE_DIR) -> pd.DataFrame:
    """
    Carga un dataset PROCESADO (con cabeceras, separado por punto y coma).
    Uso: Para cargar checkpoints o versiones enriquecidas (v1, v2, v3).
    
    Args:
        filename (str): Nombre del archivo (ej: 'dataset_v2.csv').
        input_dir (str): Directorio donde buscar el archivo.
    """
    try:
        full_path = os.path.join(input_dir, filename)
        logger.info(f"Cargando dataset procesado desde: {full_path}")
        
        if not os.path.exists(full_path):
            raise FileNotFoundError(f"No se encuentra el archivo: {full_path}")
            
        # Importante: encoding utf-8 y separador ; para compatibilidad
        df = pd.read_csv(full_path, sep=';', encoding='utf-8')
        logger.info(f"Carga exitosa: {len(df)} registros procesados.")
        return df
        
    except Exception as e:
        logger.error(f"Error cargando datos procesados {filename}: {str(e)}")
        raise e

def save_processed_data(df: pd.DataFrame, file_name: str, output_dir: str = DEFAULT_BASE_DIR) -> str:
    """
    Persiste el dataframe enriquecido en el almacenamiento.
    Crea el directorio si no existe y maneja la codificación segura.

    Args:
        df (pd.DataFrame): Datos a guardar.
        file_name (str): Nombre del archivo de salida.
        output_dir (str): Directorio de destino.

    Returns:
        str: Ruta absoluta del archivo guardado.
    """
    try:
        # 1. Validación y creación del directorio
        if not os.path.exists(output_dir):
            os.makedirs(output_dir, exist_ok=True)
            logger.info(f"Directorio creado: {output_dir}")

        # 2. Construcción de ruta segura
        output_path = os.path.join(output_dir, file_name)
        logger.info(f"Guardando datos en: {output_path}")

        # 3. Escritura (UTF-8 y separador ;)
        df.to_csv(output_path, index=False, sep=';', encoding='utf-8')
        
        logger.info("Persistencia finalizada exitosamente.")
        return output_path

    except Exception as e:
        logger.error(f"Error crítico al guardar {file_name}: {e}")
        raise e