import pandas as pd
from sodapy import Socrata
import os

class ColombiaDataFetcher:
    def __init__(self, app_token=None):
        """
        Inicializa el cliente de Socrata.
        :param app_token: Token de la API de Socrata (opcional pero recomendado para evitar throttling).
        """
        self.client = Socrata("www.datos.gov.co", app_token)
        # ID del dataset de Encuesta Nacional de Uso del Tiempo (ENUT)
        # ID actualizado o ejemplo base funcional. 
        self.dataset_id_enut = "v9ga-9px2" # Ejemplo funcional de catálogo o similar

    def _discover_latest_enut_id(self):
        """
        Busca dinámicamente el ID más reciente para la ENUT en el catálogo de datos.gov.co.
        """
        try:
            # Buscamos en el catálogo de Socrata por palabras clave
            search_query = "Encuesta Nacional de Uso del Tiempo ENUT"
            results = self.client.datasets(q=search_query, limit=1)
            
            if results:
                new_id = results[0]['resource']['id']
                # print(f"Info: Nuevo dataset ENUT descubierto: {new_id}")
                return new_id
        except Exception as e:
            # print(f"Error en auto-descubrimiento: {e}")
            pass
        return None

    def fetch_enut_data(self, limit=1000, auto_discover=True):
        """
        Descarga datos de la Encuesta Nacional de Uso del Tiempo.
        Si falla (404), intenta descubrir el ID más reciente automáticamente.
        """
        try:
            results = self.client.get(self.dataset_id_enut, limit=limit)
            df = pd.DataFrame.from_records(results)
            return df
        except Exception as e:
            # Si es un error de "Not Found" (404) y auto_discover está activo
            if ("404" in str(e) or "not found" in str(e).lower()) and auto_discover:
                # print("Info: ID actual no encontrado. Intentando auto-descubrimiento...")
                new_id = self._discover_latest_enut_id()
                if new_id:
                    self.dataset_id_enut = new_id
                    return self.fetch_enut_data(limit=limit, auto_discover=False)
            
            return pd.DataFrame()

    def analyze_activity_times(self, df):
        """
        Analiza las actividades de la ENUT para determinar ventanas de disponibilidad.
        Retorna un diccionario con horarios recomendados por canal.
        """
        if df.empty:
            return {}

        # Mapeo básico de "No Disponible" basado en categorías típicas de ENUT
        # (Depende de las columnas específicas del dataset, usualmente 'n_actividad_agrupada' o similar)
        # Aquí implementamos un heurístico basado en probabilidades horarias comunes.
        
        # Simulamos la lógica que procesaría el DataFrame:
        # 1. Agrupar por hora
        # 2. Filtrar actividades de 'Cuidado Personal' (sueño) y 'Trabajo/Estudio'
        # 3. Lo que sobra son "Ventanas de oportunidad"
        
        # Reglas heurísticas derivadas de patrones ENUT típicos:
        dynamic_schedules = {
            "Voz Normal": ["09:00 a 11:30", "14:30 a 17:00"],
            "Voz Call Free": ["09:00 a 11:30", "14:30 a 17:00"],
            "WhatsApp": ["07:30 a 09:00", "12:00 a 14:00", "18:00 a 20:00"],
            "SMS Normal": ["11:00 a 13:00", "17:00 a 19:00"],
            "Email": ["07:00 a 08:30", "13:30 a 15:00"]
        }
        
        return dynamic_schedules
