"""
Client API pour communiquer avec le backend Flask (version portable)
"""
import requests
import time
from typing import List, Dict, Optional, Tuple


class APIClient:
    """Client pour communiquer avec l'API MyMind"""
    
    def __init__(self, api_urls: List[str], working_url: Optional[str] = None):
        self.api_urls = api_urls
        self.working_url = working_url
        self.timeout = 5
        # Session HTTP pour conserver les cookies (authentification par session)
        self.session = requests.Session()

    def _split_base_and_api(self, url: str) -> Tuple[str, str]:
        """
        Sépare l'URL entre la base (http://...:5005) et le préfixe /api éventuel.
        Retourne (base_url, api_prefix).
        """
        if not url:
            return '', ''
        if url.endswith('/api'):
            return url[:-4], '/api'
        return url, ''
    
    def find_working_url(self) -> Optional[str]:
        """Trouve une URL API qui fonctionne"""
        if self.working_url:
            # Tester si l'URL actuelle fonctionne encore
            try:
                response = self.session.get(
                    f"{self.working_url}/shortcuts",
                    timeout=3
                )
                if response.ok:
                    return self.working_url
            except Exception:
                pass
        
        # Essayer toutes les URLs
        for url in self.api_urls:
            try:
                response = self.session.get(
                    f"{url}/shortcuts",
                    timeout=3
                )
                if response.ok:
                    self.working_url = url
                    return url
            except Exception:
                continue
        
        # Si aucune ne fonctionne, utiliser la première par défaut
        self.working_url = self.api_urls[0] if self.api_urls else None
        return self.working_url

    def login(self, email: str, password: str) -> bool:
        """
        Authentifie l'utilisateur auprès de l'API et stocke la session (cookies).
        Retourne True si la connexion réussit.
        """
        if not email or not password:
            return False

        api_url = self.find_working_url()
        if not api_url:
            return False

        base_url, api_prefix = self._split_base_and_api(api_url)
        login_url = f"{base_url}{api_prefix}/auth/login"

        try:
            response = self.session.post(
                login_url,
                json={"email": email, "password": password},
                timeout=self.timeout
            )
            return response.ok
        except Exception as e:
            print(f"Erreur lors de l'authentification: {e}")
            return False
    
    def get_clients(self) -> List[Dict]:
        """Récupère tous les clients accessibles"""
        url = self.find_working_url()
        if not url:
            return []
        
        try:
            response = self.session.get(
                f"{url}/extension/clients",
                timeout=self.timeout
            )
            if response.ok:
                return response.json()
        except Exception as e:
            print(f"Erreur lors de la récupération des clients: {e}")
        
        return []
    
    def get_groups(self, client_id: int) -> List[Dict]:
        """Récupère tous les groupes d'un client"""
        url = self.find_working_url()
        if not url:
            return []
        
        try:
            response = self.session.get(
                f"{url}/extension/clients/{client_id}/groups",
                timeout=self.timeout
            )
            if response.ok:
                return response.json()
        except Exception as e:
            print(f"Erreur lors de la récupération des groupes: {e}")
        
        return []
    
    def get_shortcuts(self, client_id: Optional[int] = None, 
                     group_id: Optional[int] = None) -> List[Dict]:
        """Récupère les raccourcis (filtrés par client/groupe)"""
        url = self.find_working_url()
        if not url:
            return []
        
        try:
            params = {}
            if client_id:
                params['client_id'] = client_id
            if group_id:
                params['group_id'] = group_id
            
            response = self.session.get(
                f"{url}/extension/shortcuts",
                params=params,
                timeout=self.timeout
            )
            if response.ok:
                shortcuts = response.json()
                # Construire les URLs complètes pour les images
                base_url, _ = self._split_base_and_api(url)
                for shortcut in shortcuts:
                    if shortcut.get('image_path') and not shortcut.get('image_url'):
                        shortcut['image_url'] = f"{base_url}/api/images/{shortcut['image_path']}"
                return shortcuts
        except Exception as e:
            print(f"Erreur lors de la récupération des raccourcis: {e}")
        
        return []
    
    def search_shortcut(self, keyword: str, client_id: Optional[int] = None,
                       group_id: Optional[int] = None) -> Optional[Dict]:
        """Recherche un raccourci par mot-clé"""
        url = self.find_working_url()
        if not url:
            return None
        
        try:
            params = {'keyword': keyword}
            if client_id:
                params['client_id'] = client_id
            if group_id:
                params['group_id'] = group_id
            
            response = self.session.get(
                f"{url}/shortcuts/search",
                params=params,
                timeout=self.timeout
            )
            if response.ok:
                shortcut = response.json()
                # Construire l'URL complète pour l'image
                if shortcut.get('image_path') and not shortcut.get('image_url'):
                    base_url, _ = self._split_base_and_api(url)
                    shortcut['image_url'] = f"{base_url}/api/images/{shortcut['image_path']}"
                return shortcut
        except Exception as e:
            print(f"Erreur lors de la recherche du raccourci: {e}")
        
        return None
    
    def get_form_list_items(self, form_list_id: int) -> Optional[Dict]:
        """Récupère les éléments d'une liste de formulaire"""
        url = self.find_working_url()
        if not url:
            print(f"[MyMind API] Aucune URL API disponible pour charger la liste {form_list_id}")
            return None
        
        try:
            # Utiliser la même logique que get_shortcuts - l'URL contient déjà le préfixe /api si nécessaire
            # Construire l'URL de la même manière que les autres endpoints
            base_url, api_prefix = self._split_base_and_api(url)
            
            # Construire l'URL complète
            if api_prefix:
                api_url = f"{base_url}{api_prefix}/form-lists/{form_list_id}/items/complete"
            else:
                # Si pas de préfixe /api dans l'URL de base, utiliser /api
                api_url = f"{base_url}/api/form-lists/{form_list_id}/items/complete"
            
            print(f"[MyMind API] URL de base: {base_url}")
            print(f"[MyMind API] Préfixe API: {api_prefix}")
            print(f"[MyMind API] URL complète: {api_url}")
            print(f"[MyMind API] Session cookies: {dict(self.session.cookies)}")
            
            response = self.session.get(
                api_url,
                timeout=self.timeout
            )
            
            print(f"[MyMind API] Réponse status: {response.status_code}")
            
            if response.ok:
                data = response.json()
                print(f"[MyMind API] Données reçues - Type: {type(data)}, Keys: {list(data.keys()) if isinstance(data, dict) else 'N/A'}")
                if isinstance(data, dict) and 'items' in data:
                    print(f"[MyMind API] Nombre d'items: {len(data['items'])}")
                return data
            else:
                error_text = response.text
                print(f"[MyMind API] Erreur HTTP {response.status_code}: {error_text}")
                if response.status_code == 401 or response.status_code == 403:
                    print(f"[MyMind API] Problème d'authentification - la session peut avoir expiré")
                    print(f"[MyMind API] Essayez de vous reconnecter via l'interface")
        except requests.exceptions.Timeout:
            print(f"[MyMind API] Timeout lors de la récupération de la liste {form_list_id}")
        except requests.exceptions.RequestException as e:
            print(f"[MyMind API] Erreur réseau lors de la récupération de la liste {form_list_id}: {e}")
        except Exception as e:
            print(f"[MyMind API] Erreur lors de la récupération des éléments de la liste de formulaire: {e}")
            import traceback
            traceback.print_exc()
        
        return None
    