"""
Firebase Realtime Database client for audience data retrieval.
"""

import firebase_admin
from firebase_admin import db, credentials
import firebase_admin.db
from typing import List, Optional, Dict, Any
import logging
import os
import json
from dotenv import load_dotenv
load_dotenv()


class FirebaseClient:
    """
    Client for interacting with Firebase Realtime Database to retrieve audience data.
    """
    
    def __init__(self):
        """
        Initialize Firebase client with database URL and credentials.
        
        Args:
            database_url: Firebase Realtime Database URL
            credentials_path: Path to Firebase service account credentials JSON file
        """
        self.database_url = os.environ.get("FIREBASE_HOST")
        self._app = None
        self._initialize_firebase()
    
    def _initialize_firebase(self):
        """Initialize Firebase Admin SDK."""
        try:
            # Check if Firebase app is already initialized
            if not firebase_admin._apps:
                cred = credentials.Certificate(json.loads(os.environ.get("FIREBASE_CREDENTIALS_JSON")))
                
                self._app = firebase_admin.initialize_app(credential=cred, options={
                    'databaseURL': self.database_url
                })
            else:
                self._app = firebase_admin.get_app()
                
        except Exception as e:
            logging.error(f"Failed to initialize Firebase: {e}")
            raise
    
    def get_audience_users(self, property_id:str, audience_id: str) -> List[str]:
        """
        Retrieve user_pseudo_id list from Firebase for a given audience_id.
        
        Args:
            audience_id: The audience identifier to query
            firebase_path: Optional custom Firebase path. If not provided, uses default path pattern
            
        Returns:
            List of user_pseudo_id strings
            
        Raises:
            ValueError: If audience_id is invalid
            ConnectionError: If Firebase connection fails
        """
        if not audience_id or not isinstance(audience_id, str):
            raise ValueError("audience_id must be a non-empty string")
        
        try:
            # Use provided path or construct default path
            path = f"account/{property_id}/audience/{audience_id}/user_pseudo_id"
            
            # Get reference to the Firebase path
            ref = db.reference(path)
            
            # Retrieve data from Firebase
            data = ref.get()
            
            if data is None:
                logging.warning(f"No data found for audience_id: {audience_id} at path: {path}")

                logging.info(f"Start cal audience for {audience_id}")

                from feature.audience.audience_builder import AudinceBuilder
                pathAudience = f"account/{property_id}/audience/{audience_id}"
                data = db.reference(pathAudience).get()
                builder = AudinceBuilder(json=data, cache=False)
                valid, message = builder._validate_json_data()
                
                if not valid:
                    return []
                final_result = builder.get_final_audience()
                return final_result
            
            # Extract user_pseudo_ids from the data
            if isinstance(data, dict):
                user_pseudo_ids = data.get('user_pseudo_ids', [])
            elif isinstance(data, list):
                user_pseudo_ids = data
            else:
                logging.warning(f"Unexpected data format for audience_id: {audience_id}")
                return []
            # Ensure we return a list of strings
            if isinstance(user_pseudo_ids, list):
                return [str(uid) for uid in user_pseudo_ids if uid is not None]
            else:
                logging.warning(f"user_pseudo_ids is not a list for audience_id: {audience_id}")
                return []
                
        except Exception as e:
            logging.error(f"Failed to retrieve audience data for {audience_id}: {e}")
            raise ConnectionError(f"Firebase connection failed: {e}")
    
    def test_connection(self) -> bool:
        """
        Test Firebase connection by attempting to read from root.
        
        Returns:
            True if connection is successful, False otherwise
        """
        try:
            ref = db.reference("/")
            # Just test the connection, don't actually read data
            ref.get(shallow=True)
            return True
        except Exception as e:
            logging.error(f"Firebase connection test failed: {e}")
            return False
    
    def close(self):
        """Clean up Firebase connection."""
        try:
            if self._app:
                firebase_admin.delete_app(self._app)
                self._app = None
        except Exception as e:
            logging.error(f"Error closing Firebase connection: {e}")