#!/usr/bin/env python3
"""
Migration des positions existantes vers le position manager
Importe les positions depuis l'état actuel du bot
"""

import json
import os
from pathlib import Path
from datetime import datetime
from dotenv import load_dotenv
from web3 import Account
from position_manager import PositionManager
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

load_dotenv()


def migrate_from_bot_state():
    """Migre les positions depuis current_state_onchain.json"""

    state_file = Path('live_trading_data/current_state_onchain.json')

    if not state_file.exists():
        logger.warning(f"❌ Fichier state non trouvé: {state_file}")
        return 0

    try:
        with open(state_file, 'r') as f:
            state = json.load(f)

        positions = state.get('positions', {})

        if not positions:
            logger.info("ℹ️  Aucune position dans l'état du bot")
            return 0

        # Initialiser position manager
        private_key = os.getenv('WALLET_PRIVATE_KEY')
        account = Account.from_key(private_key)
        manager = PositionManager(account.address, 'positions.json')

        migrated = 0

        for symbol, pos in positions.items():
            try:
                # Vérifier si déjà migrée (on génère un trade_hash temporaire)
                # Comme on n'a pas le vrai trade_hash, on utilise symbol + entry_price
                temp_trade_hash = f"0x{symbol}_{int(pos['entry_price']*100)}"

                if manager.get_position(temp_trade_hash):
                    logger.info(f"   ⏭️  {symbol}: déjà migrée")
                    continue

                # Extraire les infos
                is_long = pos.get('side', 'LONG') == 'LONG'
                margin = pos.get('margin', 0)
                leverage = pos.get('leverage', 1)
                entry_price = pos.get('entry_price', 0)
                qty = pos.get('qty', 0)
                stop_loss = pos.get('stop_loss', 0)
                take_profit = pos.get('take_profit', 0)

                # Ajouter au position manager
                manager.add_position(
                    trade_hash=temp_trade_hash,  # Hash temporaire
                    tx_hash="0x0000000000000000000000000000000000000000000000000000000000000000",  # TX inconnue
                    symbol=symbol,
                    pair_address="0x0000000000000000000000000000000000000000",  # Inconnu
                    is_long=is_long,
                    margin=margin,
                    leverage=leverage,
                    entry_price=entry_price,
                    qty=qty,
                    stop_loss=stop_loss,
                    take_profit=take_profit,
                    block_number=0  # Inconnu
                )

                logger.info(f"   ✅ {symbol}: MIGRÉE ({leverage}x {'LONG' if is_long else 'SHORT'}, entry: ${entry_price:.2f})")
                migrated += 1

            except Exception as e:
                logger.error(f"   ❌ Erreur migration {symbol}: {e}")

        return migrated

    except Exception as e:
        logger.error(f"❌ Erreur migration: {e}")
        return 0


def migrate_from_contract():
    """Migre les positions depuis le contrat ApolloX (si get_positions fonctionne)"""

    try:
        from apollox_v2_client import ApolloXV2Client

        private_key = os.getenv('WALLET_PRIVATE_KEY')
        client = ApolloXV2Client(private_key=private_key)

        # Essayer de récupérer les positions on-chain
        positions = client.get_positions()

        if not positions:
            logger.info("ℹ️  Aucune position on-chain trouvée")
            return 0

        account = Account.from_key(private_key)
        manager = PositionManager(account.address, 'positions.json')

        migrated = 0

        for pos in positions:
            try:
                trade_hash = pos['tradeHash']

                if manager.get_position(trade_hash):
                    logger.info(f"   ⏭️  Position déjà migrée: {trade_hash[:16]}...")
                    continue

                # Déterminer le symbole depuis pairBase
                pair_address = pos['pairBase']
                symbol = 'UNKNOWN'
                from apollox_v2_client import PAIRS
                for name, addr in PAIRS.items():
                    if addr.lower() == pair_address.lower():
                        symbol = name
                        break

                manager.add_position(
                    trade_hash=trade_hash,
                    tx_hash="0x0000000000000000000000000000000000000000000000000000000000000000",
                    symbol=symbol,
                    pair_address=pair_address,
                    is_long=pos['isLong'],
                    margin=pos['margin'],
                    leverage=int(pos['qty'] / pos['margin']) if pos['margin'] > 0 else 1,
                    entry_price=pos['entryPrice'],
                    qty=pos['qty'],
                    stop_loss=pos['stopLoss'],
                    take_profit=pos['takeProfit'],
                    block_number=0
                )

                logger.info(f"   ✅ Position migrée: {trade_hash[:16]}... ({symbol})")
                migrated += 1

            except Exception as e:
                logger.error(f"   ❌ Erreur: {e}")

        return migrated

    except Exception as e:
        logger.error(f"❌ Erreur récupération on-chain: {e}")
        return 0


if __name__ == '__main__':
    print("=" * 80)
    print("🔄 MIGRATION POSITIONS EXISTANTES")
    print("=" * 80)
    print()

    # Méthode 1: Depuis l'état du bot
    print("📂 Méthode 1: Migration depuis l'état du bot...")
    count1 = migrate_from_bot_state()
    print(f"   ✅ {count1} position(s) migrée(s)\n")

    # Méthode 2: Depuis le contrat (si disponible)
    print("⛓️  Méthode 2: Migration depuis le contrat ApolloX...")
    count2 = migrate_from_contract()
    print(f"   ✅ {count2} position(s) migrée(s)\n")

    total = count1 + count2

    print("=" * 80)
    print(f"✅ MIGRATION TERMINÉE: {total} position(s) importée(s)")
    print("=" * 80)
    print()

    if total > 0:
        print("💡 Les positions sont maintenant trackées!")
        print("   Vérifiez: http://localhost:8889")
    else:
        print("ℹ️  Aucune position existante à migrer")
        print("   Le tracking commencera avec les prochaines positions")