#!/usr/bin/env python3
"""
Module pour analyser les données de trading avec Claude via API
"""

import json
import requests
import logging
from datetime import datetime
from typing import Dict, Optional
import os

logger = logging.getLogger(__name__)

class ClaudeAnalyzer:
    def __init__(self, api_key: str = None):
        self.api_key = api_key or os.getenv('ANTHROPIC_API_KEY')
        self.api_url = "https://api.anthropic.com/v1/messages"
        self.model = "claude-3-sonnet-20240229"

        if not self.api_key:
            logger.warning("Clé API Claude non trouvée. Utilisez ANTHROPIC_API_KEY env var ou passez api_key")

    def create_analysis_prompt(self, trading_data: Dict) -> str:
        """Crée le prompt d'analyse pour Claude"""

        prompt = f"""Tu es un expert en trading algorithmique. Analyse les données suivantes de mon bot de trading crypto et fournis une évaluation détaillée.

=== DONNÉES DE TRADING ===
Période analysée: {trading_data.get('period_hours', 24)}h
Timestamp: {trading_data.get('timestamp', 'N/A')}

=== PERFORMANCES GÉNÉRALES ===
"""

        performance = trading_data.get('performance', {})
        prompt += f"""
- Trades exécutés: {performance.get('trades_24h', 0)}
- PnL total: {performance.get('total_pnl_24h', 0):.2f}$
- Signaux générés: {performance.get('signals_generated_24h', 0)}
- Signaux exécutés: {performance.get('signals_executed_24h', 0)}
- Taux d'exécution: {performance.get('execution_rate', 0):.1f}%
- Positions actives: {performance.get('active_positions', 0)}

"""

        # Trades récents
        trades = trading_data.get('trades', [])
        if trades:
            prompt += "=== TRADES RÉCENTS ===\n"
            for i, trade in enumerate(trades[:15]):  # Top 15 trades
                pnl_str = f"PnL: {trade.get('pnl', 'N/A')}" if trade.get('pnl') is not None else "PnL: N/A"
                prompt += f"{i+1}. {trade['symbol']} {trade['side']} {trade['size']} @ ${trade['price']} | {pnl_str} | {trade['datetime']}\n"

        # Signaux récents
        signals = trading_data.get('signals', [])
        if signals:
            prompt += "\n=== SIGNAUX RÉCENTS ===\n"
            for i, signal in enumerate(signals[:15]):  # Top 15 signals
                executed = "✓ EXÉCUTÉ" if signal['executed'] else "✗ REJETÉ"
                reason = f" | Raison: {signal.get('reason', 'N/A')}" if signal.get('reason') else ""
                prompt += f"{i+1}. {executed} | {signal['symbol']} {signal['signal_type']} (conf: {signal['confidence']:.2f}) | {signal['datetime']}{reason}\n"

        # Données de chandeliers (résumé)
        candle_data = trading_data.get('candle_data', {})
        if candle_data:
            prompt += "\n=== DONNÉES DE MARCHÉ ===\n"
            for symbol, candles in candle_data.items():
                if candles and len(candles) > 0:
                    latest = candles[-1]
                    first = candles[0]
                    price_change = ((latest['close'] - first['open']) / first['open']) * 100
                    prompt += f"{symbol}: Prix actuel ${latest['close']:.4f} | Variation {price_change:+.2f}% | {len(candles)} chandeliers\n"

        prompt += """

=== DEMANDE D'ANALYSE ===

Fournis une analyse complète incluant:

1. **ÉVALUATION DES PERFORMANCES**:
   - Analyse du taux de réussite et de la rentabilité
   - Évaluation du nombre de trades et de leur qualité
   - Commentaire sur le taux d'exécution des signaux

2. **ANALYSE DES PATTERNS**:
   - Identification des symboles les plus tradés
   - Patterns temporels (heures d'activité)
   - Types de signaux les plus fréquents

3. **ANALYSE DU COMPORTEMENT DU BOT**:
   - Évaluation de la sélectivité (rejets vs exécutions)
   - Cohérence des décisions de trading
   - Identification d'éventuels biais ou problèmes

4. **RECOMMANDATIONS**:
   - Ajustements suggérés pour les paramètres
   - Améliorations potentielles de la stratégie
   - Points d'attention ou signaux d'alerte

5. **CONTEXTE MARCHÉ**:
   - Corrélation avec les mouvements de prix
   - Adaptation aux conditions de marché actuelles

Sois précis, critique et constructif dans ton analyse.
"""

        return prompt

    def call_claude_api(self, prompt: str) -> Optional[str]:
        """Appelle l'API Claude pour analyse"""
        if not self.api_key:
            logger.error("Clé API Claude manquante")
            return None

        headers = {
            "Content-Type": "application/json",
            "x-api-key": self.api_key,
            "anthropic-version": "2023-06-01"
        }

        data = {
            "model": self.model,
            "max_tokens": 4000,
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        }

        try:
            logger.info("Envoi de la requête à Claude API...")
            response = requests.post(self.api_url, headers=headers, json=data, timeout=60)

            if response.status_code == 200:
                result = response.json()
                analysis = result['content'][0]['text']
                logger.info("Analyse reçue de Claude")
                return analysis
            else:
                logger.error(f"Erreur API Claude: {response.status_code} - {response.text}")
                return None

        except Exception as e:
            logger.error(f"Erreur lors de l'appel à l'API Claude: {e}")
            return None

    def generate_fallback_analysis(self, trading_data: Dict) -> str:
        """Génère une analyse de fallback simple quand Claude n'est pas disponible"""
        performance = trading_data.get('performance', {})
        trades_count = performance.get('trades_24h', 0)
        total_pnl = performance.get('total_pnl_24h', 0)
        signals_generated = performance.get('signals_generated_24h', 0)
        signals_executed = performance.get('signals_executed_24h', 0)
        execution_rate = performance.get('execution_rate', 0)

        # Analyse basique des métriques
        status = "NEUTRE"
        quality_score = 0.75  # Score par défaut conservateur (au-dessus de 0.65)

        if total_pnl > 0 and trades_count > 0:
            status = "POSITIF"
            quality_score = 0.8
        elif total_pnl < -50 or execution_rate < 10:
            status = "NÉGATIF"
            quality_score = 0.7  # Même en négatif, on reste au-dessus du seuil
        elif trades_count == 0 and signals_generated > 0:
            status = "ATTENTE"
            quality_score = 0.75

        # Génération de l'analyse fallback
        analysis = f"""=== ANALYSE AUTOMATIQUE (MODE FALLBACK) ===

STATUT GÉNÉRAL: {status}
Score de qualité estimé: {quality_score:.2f}

MÉTRIQUES CLÉS:
- Trades exécutés: {trades_count}
- PnL 24h: {total_pnl:.2f}$
- Signaux générés: {signals_generated}
- Taux d'exécution: {execution_rate:.1f}%

ÉVALUATION:
{"✓ Performance positive observée" if total_pnl > 0 else "⚠ Performance négative ou neutre"}
{"✓ Activité de trading normale" if trades_count > 0 else "ℹ Aucun trade exécuté"}
{"✓ Génération de signaux active" if signals_generated > 0 else "⚠ Pas de signaux générés"}

RECOMMANDATIONS (Mode conservateur):
1. Maintenir les paramètres actuels
2. Surveiller l'évolution du marché
3. Éviter les positions trop risquées
4. Considérer l'augmentation graduelle si performance positive

LIMITATIONS:
Cette analyse est générée automatiquement sans l'intelligence avancée de Claude.
Pour une analyse complète, vérifiez les crédits API Claude.

Score recommandé pour les nouveaux signaux: {quality_score:.2f}
Timestamp: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
"""

        logger.info(f"Analyse fallback générée - Score: {quality_score}")
        return analysis

    def analyze_trading_data(self, trading_data: Dict) -> Optional[str]:
        """Analyse complète des données de trading"""
        logger.info("Début de l'analyse avec Claude...")

        # Création du prompt
        prompt = self.create_analysis_prompt(trading_data)

        # Appel à Claude
        analysis = self.call_claude_api(prompt)

        # Mode fallback si Claude échoue
        if not analysis:
            logger.warning("API Claude indisponible - Utilisation du mode fallback")
            analysis = self.generate_fallback_analysis(trading_data)

        if analysis:
            # Sauvegarde de l'analyse
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            analysis_file = f"logs/claude_analysis_{timestamp}.txt"

            try:
                with open(analysis_file, 'w', encoding='utf-8') as f:
                    f.write(f"=== ANALYSE CLAUDE - {datetime.now().isoformat()} ===\n\n")
                    f.write(analysis)
                    f.write(f"\n\n=== DONNÉES ANALYSÉES ===\n")
                    f.write(f"Période: {trading_data.get('period_hours', 24)}h\n")
                    f.write(f"Trades: {len(trading_data.get('trades', []))}\n")
                    f.write(f"Signaux: {len(trading_data.get('signals', []))}\n")
                    f.write(f"Symboles: {trading_data.get('summary', {}).get('symbols_count', 0)}\n")

                logger.info(f"Analyse sauvegardée: {analysis_file}")

            except Exception as e:
                logger.error(f"Erreur lors de la sauvegarde de l'analyse: {e}")

        return analysis

    def save_prompt_for_debug(self, prompt: str, filename: str = None):
        """Sauvegarde le prompt pour debug"""
        if filename is None:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"logs/debug_prompt_{timestamp}.txt"

        try:
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(prompt)
            logger.info(f"Prompt sauvegardé: {filename}")
        except Exception as e:
            logger.error(f"Erreur sauvegarde prompt: {e}")

# Test et utilisation
def test_analyzer():
    """Test de l'analyzer avec des données factices"""
    analyzer = ClaudeAnalyzer()

    # Données de test
    test_data = {
        'timestamp': datetime.now().isoformat(),
        'period_hours': 24,
        'trades': [
            {
                'symbol': 'BTC',
                'side': 'LONG',
                'size': 0.01,
                'price': 67000,
                'pnl': 150.50,
                'datetime': '2024-01-01 12:00:00'
            }
        ],
        'signals': [
            {
                'symbol': 'BTC',
                'signal_type': 'BUY',
                'confidence': 0.85,
                'executed': True,
                'datetime': '2024-01-01 11:55:00'
            }
        ],
        'performance': {
            'trades_24h': 5,
            'total_pnl_24h': 250.75,
            'signals_generated_24h': 12,
            'signals_executed_24h': 5,
            'execution_rate': 41.7,
            'active_positions': 3
        }
    }

    # Créer et sauvegarder le prompt pour debug
    prompt = analyzer.create_analysis_prompt(test_data)
    analyzer.save_prompt_for_debug(prompt)

    print("Prompt généré et sauvegardé pour debug")
    print(f"Longueur du prompt: {len(prompt)} caractères")

if __name__ == "__main__":
    test_analyzer()