#!/usr/bin/env python3
"""
TEST LIVE TRADE - Validation du système de trading
Ouvre une MICRO position et la referme immédiatement
Pour confirmer que slippage + gas + fees fonctionnent correctement
"""

import time
import logging
from datetime import datetime
from apollox_v2_client import ApolloXV2Client
from dotenv import load_dotenv
import os

load_dotenv()

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def main():
    print("\n" + "="*80)
    print("🧪 TEST LIVE TRADE - APOLLO V10")
    print("="*80)
    print("\n⚠️  CE TEST VA OUVRIR UNE VRAIE POSITION SUR TON WALLET")
    print("Position: $10 margin | 50x leverage | $500 exposition")
    print("Coût estimé: ~$0.30-0.80 (gas + fees + slippage)")
    print("\n" + "="*80)

    # Confirmation
    confirm = input("\n✋ Taper 'YES' pour continuer, autre chose pour annuler: ")
    if confirm != 'YES':
        print("❌ Test annulé")
        return

    print("\n🚀 Démarrage du test...")

    # Init client avec private key
    private_key = os.getenv('WALLET_PRIVATE_KEY')
    if not private_key:
        print("❌ WALLET_PRIVATE_KEY non trouvée dans .env")
        return

    client = ApolloXV2Client(private_key=private_key)

    # 1. Vérifier balance initiale
    print("\n" + "="*80)
    print("📊 ÉTAT INITIAL")
    print("="*80)

    initial_bnb = client.get_balance()
    initial_usdt = client.get_usdt_balance()

    print(f"💰 BNB: {initial_bnb:.6f}")
    print(f"💵 USDT: {initial_usdt:.2f}")

    if initial_bnb < 0.005:
        print(f"❌ BNB insuffisant pour gas ({initial_bnb:.6f} < 0.005)")
        return

    if initial_usdt < 10:
        print(f"❌ USDT insuffisant ({initial_usdt:.2f} < 10)")
        return

    # 2. Récupérer prix actuel
    print("\n" + "="*80)
    print("📈 PRÉPARATION POSITION")
    print("="*80)

    from live_trader_v10_onchain import BinanceDataProvider
    provider = BinanceDataProvider()

    df = provider.get_klines('BTCUSDT', interval='1m', limit=1)
    current_price = float(df['close'].iloc[-1])

    print(f"📊 Prix BTC: ${current_price:,.2f}")

    # Params position
    MARGIN_USD = 10.0  # $10 margin (minimum ApolloX)
    LEVERAGE = 50      # 50x leverage pour atteindre taille min
    IS_LONG = True     # LONG (peu importe)

    # PAS de SL/TP (on ferme manuellement après 5 sec)
    stop_loss = 0.0
    take_profit = 0.0

    print(f"\n📋 Paramètres:")
    print(f"   Direction: {'LONG' if IS_LONG else 'SHORT'}")
    print(f"   Margin: ${MARGIN_USD}")
    print(f"   Leverage: {LEVERAGE}x")
    print(f"   Exposition: ${MARGIN_USD * LEVERAGE}")
    print(f"   Entry: ${current_price:,.2f}")
    print(f"   SL/TP: Aucun (fermeture manuelle après 5sec)")

    # 3. Ouvrir position
    print("\n" + "="*80)
    print("🔓 OUVERTURE POSITION")
    print("="*80)

    print("📡 Envoi transaction...")
    start_time = time.time()

    try:
        trade_hash = client.open_position(
            pair='BTC',
            is_long=IS_LONG,
            margin_usd=MARGIN_USD,
            leverage=LEVERAGE,
            price=current_price,
            stop_loss=stop_loss,
            take_profit=take_profit
        )

        open_time = time.time() - start_time

        if not trade_hash:
            print("❌ Échec ouverture position")
            return

        print(f"✅ Position ouverte en {open_time:.1f}s")
        print(f"📝 Trade Hash: {trade_hash}")

    except Exception as e:
        print(f"❌ ERREUR: {e}")
        return

    # 4. Attendre 5 secondes
    print("\n⏳ Attente 5 secondes avant fermeture...")
    for i in range(5, 0, -1):
        print(f"   {i}...", end='', flush=True)
        time.sleep(1)
    print("\n")

    # 5. Fermer position
    print("="*80)
    print("🔒 FERMETURE POSITION")
    print("="*80)

    print("📡 Envoi transaction closeTrade...")
    start_time = time.time()

    try:
        success = client.close_position(trade_hash)
        close_time = time.time() - start_time

        if success:
            print(f"✅ Position fermée en {close_time:.1f}s")
        else:
            print("❌ Échec fermeture position")
            print("⚠️  POSITION TOUJOURS OUVERTE - FERME-LA MANUELLEMENT!")
            return

    except Exception as e:
        print(f"❌ ERREUR: {e}")
        print("⚠️  POSITION PEUT-ÊTRE OUVERTE - VÉRIFIE!")
        return

    # 6. Attendre 3 secondes pour que balances se mettent à jour
    print("\n⏳ Attente mise à jour balances...")
    time.sleep(3)

    # 7. Vérifier balance finale
    print("\n" + "="*80)
    print("📊 ÉTAT FINAL")
    print("="*80)

    final_bnb = client.get_balance()
    final_usdt = client.get_usdt_balance()

    print(f"💰 BNB: {final_bnb:.6f} (avant: {initial_bnb:.6f})")
    print(f"💵 USDT: {final_usdt:.2f} (avant: {initial_usdt:.2f})")

    # 8. Calculer coûts
    print("\n" + "="*80)
    print("💸 COÛT TOTAL DU TEST")
    print("="*80)

    bnb_used = initial_bnb - final_bnb
    usdt_diff = final_usdt - initial_usdt

    bnb_value_usd = bnb_used * 600  # Approximation BNB = $600

    print(f"\n🔥 Gas (BNB): {bnb_used:.6f} BNB (≈ ${bnb_value_usd:.2f})")
    print(f"💵 USDT change: ${usdt_diff:+.2f}")
    print(f"📊 Coût total estimé: ${bnb_value_usd + abs(usdt_diff):.2f}")

    # 9. Analyse
    print("\n" + "="*80)
    print("🎯 ANALYSE")
    print("="*80)

    if bnb_used < 0.002:  # < 0.002 BNB = < $1.20
        print("✅ Gas consommé: ACCEPTABLE")
    elif bnb_used < 0.005:
        print("⚠️  Gas consommé: ÉLEVÉ mais OK")
    else:
        print("❌ Gas consommé: TROP ÉLEVÉ")

    if abs(usdt_diff) < 1.0:  # < $1 de perte USDT
        print("✅ Slippage + fees: ACCEPTABLE")
    elif abs(usdt_diff) < 3.0:
        print("⚠️  Slippage + fees: UN PEU ÉLEVÉ")
    else:
        print("❌ Slippage + fees: TROP ÉLEVÉ")

    # Verdict final
    total_cost = bnb_value_usd + abs(usdt_diff)

    print("\n" + "="*80)
    print("🏁 VERDICT FINAL")
    print("="*80)

    if total_cost < 1.00:
        print("✅ EXCELLENT - Coût < $1.00")
        print("✅ Le bot est prêt à trader automatiquement")
    elif total_cost < 2.00:
        print("✅ BON - Coût < $2.00")
        print("✅ Le bot peut trader mais surveille les coûts")
    elif total_cost < 3.00:
        print("⚠️  MOYEN - Coût entre $2-3")
        print("⚠️  Rentable uniquement si gains > $3 par trade")
    else:
        print("❌ MAUVAIS - Coût > $3")
        print("❌ Révise le slippage ou attends meilleure liquidité")

    print("\n" + "="*80)
    print("🧪 Test terminé!")
    print("="*80 + "\n")

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n❌ Test interrompu par l'utilisateur")
    except Exception as e:
        print(f"\n\n❌ ERREUR FATALE: {e}")
        import traceback
        traceback.print_exc()