import firebase_admin
from firebase_admin import credentials, messaging
import os

# Ruta al archivo JSON que descargaste (ajusta si lo guardas en otro lado)
# Usamos rutas relativas seguras
API_KEY_FILENAME= 'serviceAccountKey.json'
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
CRED_PATH = os.path.join(BASE_DIR, API_KEY_FILENAME)

def initialize_firebase():
    """Inicializa la App de Firebase solo si no existe ya."""
    if not firebase_admin._apps:
        try:
            if os.path.exists(CRED_PATH):
                cred = credentials.Certificate(CRED_PATH)
                firebase_admin.initialize_app(cred)
                print("[FIREBASE] Inicializado correctamente.")
            else:
                print(f"[FIREBASE] No se encontró {API_KEY_FILENAME} en {CRED_PATH}. Push desactivado.")
        except Exception as e:
            print(f"[FIREBASE] Error inicializando: {e}")

def subscribe_token_to_topic(tokens, topic_name):
    """
    Suscribe uno o más tokens de dispositivos (FCM Tokens) a un tópico.
    'tokens' debe ser una lista de strings.
    """
    initialize_firebase()
    try:
        # Firebase espera una lista de tokens, incluso si es solo uno
        response = messaging.subscribe_to_topic(tokens, topic_name)
        print(f"[FCM SUBSCRIBE] {response.success_count} tokens suscritos a {topic_name}")
        
        # Opcional: Manejar tokens fallidos (ej. desinstalaron la app)
        if response.failure_count > 0:
            print(f"[FCM SUBSCRIBE] Fallaron {response.failure_count} tokens.")
            
        return True
    except Exception as e:
        print(f"[FCM SUBSCRIBE ERROR] Error suscribiendo a {topic_name}: {e}")
        return False

def suscribir_token_a_topicos(fcm_token, lista_centros):
    """
    Suscribe forzosamente un token a una lista de tópicos desde el Backend.
    lista_centros: ["Loslagos-Puertomontt-Huelmo", ...]
    """
    if not fcm_token or not lista_centros:
        return

    # Firebase permite suscribir hasta 1000 dispositivos a un tema, 
    # pero aquí lo hacemos al revés: 1 dispositivo a varios temas.
    # Lamentablemente la API es topic-centric (1 topic -> N tokens).
    # Así que debemos iterar por centro.
    
    for centro in lista_centros:
        try:
            # El topic debe ser idéntico al que usa el móvil (Capitalizado y sin guiones extra)
            response = messaging.subscribe_to_topic([fcm_token], centro)
            print(f" [BACKEND SUBSCRIPTION] Token suscrito a {centro}: {response.success_count} éxito")
        except Exception as e:
            print(f" Error suscribiendo backend a {centro}: {e}")

def desuscribir_token_de_topicos(tokens, topic_name):
    """
    Elimina la suscripción de un token a un tópico específico.
    """
    # initialize_firebase() # Asegúrate de que esté inicializado
    try:
        response = messaging.unsubscribe_from_topic(tokens, topic_name)
        if response.success_count > 0:
            print(f"[FCM UNSUBSCRIBE] Token eliminado de {topic_name}")
        return True
    except Exception as e:
        print(f"[FCM UNSUBSCRIBE ERROR] Falló al salir de {topic_name}: {e}")
        return False
    

def send_topic_notification(centro_id, title, body, data_payload=None, extra_kwargs=None):
    """
    Envía una notificación a todos los dispositivos suscritos a un centro.
    topic: "centro_REGION-AREA-CENTRO"
    """
    # Asegurar inicialización
    initialize_firebase()
    
    # El topic no puede tener espacios ni caracteres raros. 
    # Tu centro_id ya viene normalizado (ej: Loslagos-Puertomontt-Huelmo)
    topic = f"{centro_id}"
    
    # Convertir todo el payload a string porque FCM data solo acepta strings
    str_data = {}
    if data_payload:
        for k, v in data_payload.items():
            str_data[k] = str(v)

    try:
        android_notification_config = None
        if extra_kwargs:
            # Aquí extraemos el color, canal e icono si vienen en los argumentos extra
            android_notification_config = messaging.AndroidNotification(
                color=extra_kwargs.get("color"),             # Ej: #FF0000
                channel_id=extra_kwargs.get("android_channel_id"), # Ej: alerts_channel
                icon=extra_kwargs.get("icon"),               # Ej: ic_stat_itg
                default_sound=True
            )

        # Construcción del Mensaje
        message = messaging.Message(
            # Notificación visible (Banner en el teléfono)
            notification=messaging.Notification(
                title=title,
                body=body,
            ),
            # Data silenciosa (para que la app procese en background)
            data=str_data,
            # Destino (El Topic)
            topic=topic,
            # Configuraciones extra para Android/iOS (opcional, prioridad alta)
            android=messaging.AndroidConfig(
                priority='high',
                ttl=3600, # Opcional: Tiempo de vida (1 hora)
                notification=android_notification_config # <--- AQUÍ SE INYECTA EL COLOR Y CANAL
            ),
            apns=messaging.APNSConfig(
                headers={'apns-priority': '10'},
                payload=messaging.APNSPayload(
                    aps=messaging.Aps(sound="default", content_available=True, badge=1 )
                )
            )
        )

        # Enviar
        response = messaging.send(message)
        print("[PUSH-iOS]  subscribe response:", response)
        print(f"[PUSH] Enviado a topic '{topic}': {response}")
        return True, response

    except Exception as e:
        print(f"[PUSH ERROR] No se pudo enviar a {topic}: {e}")
        return False, str(e)