tools/user_account.py

"""
👤 Outils de gestion du compte utilisateur et des équipes Figma
"""
import json
from .config import figma_config, make_figma_request

def get_figma_user_detailed_info() -> str:
    """
    Récupère les informations détaillées de l'utilisateur connecté avec plus de données.

    Returns:
        str: Informations détaillées utilisateur au format JSON ou message d'erreur
    """
    result = make_figma_request("me")
    
    if "error" in result:
        return f"❌ Erreur : {result['error']}"
    
    user_info = {
        "id": result.get("id", ""),
        "nom_utilisateur": result.get("handle", ""),
        "email": result.get("email", ""),
        "nom_affichage": result.get("img_url", "").split("/")[-1] if result.get("img_url") else "",
        "url_image": result.get("img_url", ""),
        "date_creation": result.get("created_at", ""),
        "derniere_connexion": result.get("last_activity_at", ""),
        "plan_actuel": "Non spécifié (utiliser get_figma_team_info pour plus de détails)"
    }
    
    return f"👤 **Informations détaillées utilisateur :**\n{json.dumps(user_info, indent=2, ensure_ascii=False)}"

def get_figma_team_info(team_id: str = "") -> str:
    """
    Récupère les informations détaillées d'une équipe Figma incluant le plan d'abonnement.

    Args:
        team_id (str): ID de l'équipe Figma (optionnel, utilise la configuration par défaut si vide)

    Returns:
        str: Informations équipe au format JSON ou message d'erreur
    """
    team_id = team_id or figma_config.get("team_id", "")
    
    if not team_id:
        return "❌ ID de l'équipe requis. Utilisez d'abord list_figma_user_teams() pour trouver votre équipe."
    
    result = make_figma_request(f"teams/{team_id}")
    
    if "error" in result:
        return f"❌ Erreur : {result['error']}"
    
    team_info = {
        "id": result.get("id", ""),
        "nom": result.get("name", ""),
        "plan_abonnement": result.get("billing_plan", "Inconnu"),
        "limite_editeurs": result.get("editor_limit", "Non spécifié"),
        "editeurs_actifs": result.get("active_editors", 0),
        "stockage_utilise": result.get("storage_used", "Non spécifié"),
        "limite_stockage": result.get("storage_limit", "Non spécifié"),
        "fonctionnalites": result.get("features", []),
        "date_creation": result.get("created_at", ""),
        "statut": result.get("status", "")
    }
    
    return f"🏢 **Informations équipe :**\n{json.dumps(team_info, indent=2, ensure_ascii=False)}"

def list_figma_user_teams() -> str:
    """
    Liste toutes les équipes auxquelles l'utilisateur appartient.

    Returns:
        str: Liste des équipes avec rôles et plans ou message d'erreur
    """
    result = make_figma_request("teams")
    
    if "error" in result:
        return f"❌ Erreur : {result['error']}"
    
    teams = result.get("teams", [])
    
    if not teams:
        return "🏢 Aucune équipe trouvée pour cet utilisateur"
    
    team_list = []
    for team in teams:
        team_id = team.get("id", "")
        name = team.get("name", "Sans nom")
        role = team.get("role", "Membre")
        plan = team.get("billing_plan", "Plan inconnu")
        team_list.append(f"🏢 **{name}** (ID: {team_id})\n   - Rôle: {role}\n   - Plan: {plan}")
    
    return f"🏢 **Équipes de l'utilisateur :**\n\n" + "\n\n".join(team_list)

def get_figma_current_user_permissions() -> str:
    """
    Récupère les permissions et capacités de l'utilisateur actuel dans un fichier.

    Returns:
        str: Code JavaScript pour récupérer les permissions ou message d'erreur
    """
    if not figma_config["file_id"]:
        return "❌ ID du fichier requis. Utilisez configure_figma_file_id() d'abord."
    
    comment_text = f"""👥 **Informations utilisateur actuel (Plugin API) :**

📋 **Code Plugin Figma pour récupérer les infos utilisateur :**
```javascript
// Informations utilisateur actuel
const currentUser = figma.currentUser
if (currentUser) {{
  console.log('Utilisateur:', {{
    id: currentUser.id,
    nom: currentUser.name,
    email: currentUser.email || 'Non disponible',
    couleur: currentUser.color,
    sessionId: currentUser.sessionId,
    photoUrl: currentUser.photoUrl || 'Pas de photo'
  }})
}} else {{
  console.log('Aucun utilisateur connecté')
}}

// Type d'éditeur actuel
console.log('Type éditeur:', figma.editorType) // 'figma' | 'figjam' | 'dev' | 'slides'

// Mode du plugin
console.log('Mode plugin:', figma.mode) // 'default' | 'textreview' | 'inspect' | etc.

// Utilisateurs actifs (FigJam uniquement)
if (figma.editorType === 'figjam' && figma.activeUsers) {{
  console.log('Utilisateurs actifs:', figma.activeUsers.map(user => ({{
    id: user.id,
    nom: user.name,
    couleur: user.color,
    sessionId: user.sessionId
  }})))
}}

// Clé du fichier (plugins privés uniquement)
if (figma.fileKey) {{
  console.log('Clé fichier:', figma.fileKey)
}}
```"""
    
    comment_data = {
        "message": comment_text,
        "client_meta": {"x": 0, "y": 0}
    }
    
    result = make_figma_request(f"files/{figma_config['file_id']}/comments", "POST", comment_data)
    
    if "error" in result:
        return f"❌ Erreur lors de la création du commentaire : {result['error']}"
    
    return f"✅ Code généré pour récupérer les permissions et infos utilisateur"

def get_figma_workspace_usage_stats() -> str:
    """
    Récupère les statistiques d'utilisation de l'espace de travail.

    Returns:
        str: Statistiques d'utilisation au format JSON ou message d'erreur
    """
    if not figma_config.get("team_id"):
        return "❌ ID de l'équipe requis. Utilisez list_figma_user_teams() pour trouver votre équipe puis configurez figma_config['team_id']"
    
    # Récupérer les projets de l'équipe
    projects_result = make_figma_request(f"teams/{figma_config['team_id']}/projects")
    
    if "error" in projects_result:
        return f"❌ Erreur : {projects_result['error']}"
    
    projects = projects_result.get("projects", [])
    
    stats = {
        "nombre_projets": len(projects),
        "projets_recents": [],
        "statistiques_utilisation": "Disponible via l'API Team (nécessite permissions admin)"
    }
    
    # Récupérer les 5 projets les plus récents
    for project in projects[:5]:
        stats["projets_recents"].append({
            "nom": project.get("name", ""),
            "id": project.get("id", ""),
            "derniere_modification": project.get("modified_at", "")
        })
    
    return f"📊 **Statistiques d'utilisation :**\n{json.dumps(stats, indent=2, ensure_ascii=False)}"

def get_figma_api_limitations_info() -> str:
    """
    Explique les limitations de l'API Plugin Figma vs l'API REST pour la gestion des projets.

    Returns:
        str: Documentation détaillée des limitations et capacités des APIs Figma
    """
    
    limitations_info = {
        "api_plugin_limitations": {
            "titre": "🚫 Limitations de l'API Plugin Figma",
            "description": "L'API Plugin Figma ne peut PAS :",
            "limitations": [
                "Lister tous les projets d'un utilisateur",
                "Naviguer entre différents fichiers Figma",
                "Accéder aux informations de facturation/abonnement",
                "Créer ou supprimer des projets",
                "Gérer les permissions d'équipe"
            ],
            "contexte": "Le plugin s'exécute uniquement dans le contexte du fichier actuel"
        },
        "api_rest_capacites": {
            "titre": "✅ Capacités de l'API REST Figma",
            "description": "L'API REST Figma peut :",
            "capacites": [
                "Lister les équipes de l'utilisateur",
                "Lister les projets d'une équipe",
                "Lister les fichiers d'un projet",
                "Accéder aux informations de profil utilisateur",
                "Récupérer les commentaires des fichiers",
                "Exporter des assets (avec limitations)"
            ],
            "note": "Nécessite un token d'accès personnel"
        },
        "recommendation": {
            "titre": "💡 Approche hybride recommandée",
            "description": "Utiliser les deux APIs en complémentarité :",
            "strategies": [
                "API REST : Navigation, gestion des projets, informations utilisateur",
                "API Plugin : Création/modification d'éléments dans le fichier actuel",
                "Plugin avec code JavaScript : Manipulation avancée des objets"
            ]
        },
        "workarounds": {
            "titre": "🔧 Solutions de contournement",
            "alternatives": [
                "Utiliser l'API REST pour lister les projets (comme nous faisons)",
                "Stocker les IDs de fichiers dans le clientStorage du plugin",
                "Utiliser des plugins privés pour accéder à figma.fileKey",
                "Implémenter un système de cache des informations projets"
            ]
        }
    }
    
    return f"📚 **Limitations et capacités des APIs Figma :**\n{json.dumps(limitations_info, indent=2, ensure_ascii=False)}"

def list_figma_team_projects(team_id: str = "") -> str:
    """
    Liste les projets d'une équipe Figma.

    Args:
        team_id (str): ID de l'équipe Figma (optionnel, utilise la configuration par défaut si vide)

    Returns:
        str: Liste des projets de l'équipe ou message d'erreur
    """
    team_id = team_id or figma_config["team_id"]
    
    if not team_id:
        return "❌ ID de l'équipe requis. Configurez-le avec figma_config['team_id'] = 'VOTRE_TEAM_ID'"
    
    result = make_figma_request(f"teams/{team_id}/projects")
    
    if "error" in result:
        return f"❌ Erreur : {result['error']}"
    
    projects = result.get("projects", [])
    
    if not projects:
        return "📁 Aucun projet trouvé dans cette équipe"
    
    project_list = []
    for project in projects[:10]:  # Limiter à 10 projets
        name = project.get("name", "Sans nom")
        project_id = project.get("id", "")
        project_list.append(f"📁 {name} (ID: {project_id})")
    
    return f"📁 **Projets de l'équipe :**\n" + "\n".join(project_list)