#!/usr/bin/env python3
"""
Détecte les fermetures de positions via les token transfers
"""

import requests
import json
import os
from dotenv import load_dotenv
from position_manager import PositionManager, get_position_manager
from web3 import Web3, Account
from datetime import datetime

load_dotenv()

# Config
WALLET_ADDRESS = "0x7476737C49d55bea691e54c2c96fD39a6bAf3049"
API_KEY = os.getenv('BSCSCAN_API_KEY')
APOLLOX_CONTRACT = "0x1b6F2d3844C6ae7D56ceb3C3643b9060ba28FEb0"

# USDT sur BSC
USDT_CONTRACT = "0x55d398326f99059fF775485246999027B3197955"

def get_token_transfers():
    """Récupère tous les token transfers USDT vers notre wallet depuis ApolloX"""
    
    url = "https://api.etherscan.io/v2/api"
    params = {
        'chainid': '56',
        'module': 'account',
        'action': 'tokentx',
        'contractaddress': USDT_CONTRACT,
        'address': WALLET_ADDRESS,
        'startblock': 65508000,
        'endblock': 99999999,
        'sort': 'asc',
        'apikey': API_KEY
    }
    
    print(f"📡 Récupération des token transfers USDT...")
    
    try:
        response = requests.get(url, params=params, timeout=15)
        data = response.json()
        
        if data.get('status') == '1' and isinstance(data.get('result'), list):
            transfers = data['result']
            print(f"   ✅ {len(transfers)} transfers récupérés")
            
            # Filtrer les transfers DEPUIS ApolloX VERS notre wallet
            closes = []
            for tx in transfers:
                from_addr = tx.get('from', '').lower()
                to_addr = tx.get('to', '').lower()
                
                if from_addr == APOLLOX_CONTRACT.lower() and to_addr == WALLET_ADDRESS.lower():
                    closes.append(tx)
                    
            print(f"   🎯 {len(closes)} fermetures potentielles détectées")
            return closes
        else:
            print(f"   ❌ Erreur: {data.get('message', 'Unknown')}")
            return []
            
    except Exception as e:
        print(f"   ❌ Exception: {e}")
        return []


def update_closures():
    """Met à jour les positions fermées"""
    
    print("=" * 80)
    print("🔍 DÉTECTION DES FERMETURES DE POSITIONS")
    print("=" * 80)
    print()
    
    # Init position manager
    private_key = os.getenv('WALLET_PRIVATE_KEY')
    account = Account.from_key(private_key)
    manager = get_position_manager(account.address, 'positions.json')
    
    # Récupérer les transfers
    closes = get_token_transfers()
    
    if not closes:
        print("\n⚠️  Aucun transfer détecté")
        return
    
    print(f"\n📊 Analyse de {len(closes)} transfers...")
    print()
    
    closed_count = 0
    
    for transfer in closes:
        tx_hash = transfer['hash']
        amount_raw = int(transfer['value'])
        amount_usdt = amount_raw / 1e18  # USDT has 18 decimals
        timestamp = datetime.fromtimestamp(int(transfer['timeStamp'])).isoformat()
        block = int(transfer['blockNumber'])
        
        print(f"💰 Transfer: {tx_hash[:16]}...")
        print(f"   Amount: ${amount_usdt:.2f} USDT")
        print(f"   Block: {block}")
        print(f"   Time: {timestamp}")
        
        # Trouver la position correspondante
        # On cherche la position ouverte la plus proche en temps
        open_positions = [p for p in manager.get_all_positions() if p.status == 'OPEN']
        
        if not open_positions:
            print(f"   ⚠️  Aucune position ouverte à matcher")
            continue
            
        # Trier par block pour trouver la plus ancienne
        open_positions.sort(key=lambda p: p.block_number)
        
        # La première position ouverte est probablement celle qui vient d'être fermée
        pos = open_positions[0]
        
        # Calculer le PnL
        pnl = amount_usdt - pos.margin
        pnl_pct = (pnl / pos.margin * 100) if pos.margin > 0 else 0
        
        print(f"   📍 Matched position: {pos.trade_hash[:16]}...")
        print(f"   💵 Margin: ${pos.margin:.2f}")
        print(f"   {'📈' if pnl >= 0 else '📉'} PnL: ${pnl:.2f} ({pnl_pct:+.2f}%)")
        
        # Fermer la position
        if pos.trade_hash in manager.positions:
            manager.positions[pos.trade_hash].status = 'CLOSED'
            manager.positions[pos.trade_hash].closed_at = timestamp
            manager.positions[pos.trade_hash].close_tx_hash = tx_hash
            manager.positions[pos.trade_hash].pnl = pnl
            manager.positions[pos.trade_hash].pnl_pct = pnl_pct
            manager.positions[pos.trade_hash].exit_price = 0  # On n'a pas le prix de sortie
            
            manager.save()
            closed_count += 1
            print(f"   ✅ Position fermée")
        
        print()
    
    print("=" * 80)
    print(f"✅ TERMINÉ: {closed_count} positions fermées")
    print("=" * 80)
    print()
    
    # Afficher les stats
    stats = manager.get_stats()
    print(f"📊 Statistiques:")
    print(f"   Total trades: {stats['closed_positions']}")
    print(f"   Wins: {stats['winning_trades']}")
    print(f"   Losses: {stats['losing_trades']}")
    print(f"   Win rate: {stats['win_rate']:.1f}%")
    print(f"   Total PnL: ${stats['total_pnl']:.2f}")


if __name__ == '__main__':
    update_closures()