"""
Quotex Client Wrapper using pyquotex
GitHub: https://github.com/cleitonleonel/pyquotex
"""
import asyncio
from typing import Optional, List, Dict, Any
from datetime import datetime


class QuotexClient:
    def __init__(self, email: str, password: str):
        self.email = email
        self.password = password
        self.client = None
        self.is_connected = False
        self._candle_data: Dict[str, List] = {}

    async def connect(self) -> bool:
        """Connect to Quotex via pyquotex"""
        try:
            from quotexapi.stable_api import Quotex
            self.client = Quotex(self.email, self.password)
            check, reason = await self.client.connect()
            if check:
                self.is_connected = True
                print(f"✅ Connected to Quotex as {self.email}")
                return True
            else:
                print(f"❌ Quotex connection failed: {reason}")
                return False
        except ImportError:
            print("⚠️  pyquotex not installed. Running in DEMO mode.")
            self.is_connected = True  # Demo mode
            return True
        except Exception as e:
            print(f"❌ Quotex error: {e}")
            return False

    async def disconnect(self):
        if self.client:
            try:
                await self.client.close()
            except Exception:
                pass
        self.is_connected = False

    async def get_balance(self) -> Dict:
        if not self.client:
            return {"balance": 10000.0, "currency": "USD", "mode": "demo"}
        try:
            balance = await self.client.get_balance()
            return {"balance": balance, "currency": "USD", "mode": "real"}
        except Exception as e:
            return {"error": str(e)}

    async def get_available_assets(self) -> List[Dict]:
        if not self.client:
            # Demo assets
            return [
                {"asset": "EURUSD", "name": "EUR/USD", "payout": 85, "open": True},
                {"asset": "GBPUSD", "name": "GBP/USD", "payout": 82, "open": True},
                {"asset": "USDJPY", "name": "USD/JPY", "payout": 83, "open": True},
                {"asset": "BTCUSD", "name": "BTC/USD", "payout": 88, "open": True},
                {"asset": "ETHUSD", "name": "ETH/USD", "payout": 86, "open": True},
                {"asset": "AAPL", "name": "Apple Inc", "payout": 80, "open": True},
                {"asset": "GOLD", "name": "Gold", "payout": 84, "open": True},
            ]
        try:
            all_assets = self.client.get_all_asset_name()
            return [{"asset": a, "name": a, "payout": 80, "open": True} for a in all_assets[:20]]
        except Exception as e:
            return []

    async def get_candles(self, asset: str, period: int = 60, count: int = 100) -> List[Dict]:
        """Get OHLC candles for an asset"""
        if not self.client:
            return self._generate_demo_candles(asset, count)
        try:
            candles = await self.client.get_candles(asset, period, count)
            return candles
        except Exception as e:
            print(f"Error getting candles for {asset}: {e}")
            return self._generate_demo_candles(asset, count)

    async def get_realtime_price(self, asset: str) -> Optional[float]:
        """Get current real-time price"""
        if not self.client:
            import random
            base_prices = {
                "EURUSD": 1.0850, "GBPUSD": 1.2650, "USDJPY": 149.50,
                "BTCUSD": 43500.0, "ETHUSD": 2650.0, "GOLD": 2050.0,
            }
            base = base_prices.get(asset, 1.0)
            return base * (1 + random.uniform(-0.002, 0.002))
        try:
            price = await self.client.get_realtime_price(asset)
            return price
        except Exception:
            return None

    async def place_trade(self, asset: str, direction: str, amount: float, duration: int) -> Dict:
        """Place a binary options trade"""
        if not self.client:
            import random
            trade_id = f"demo_{int(datetime.utcnow().timestamp())}"
            return {
                "id": trade_id,
                "asset": asset,
                "direction": direction,
                "amount": amount,
                "duration": duration,
                "status": "open",
                "mode": "demo",
            }
        try:
            status, trade_id = await self.client.buy(amount, asset, direction.upper(), duration)
            return {
                "id": trade_id,
                "asset": asset,
                "direction": direction,
                "amount": amount,
                "duration": duration,
                "status": "open" if status else "failed",
            }
        except Exception as e:
            return {"error": str(e)}

    def _generate_demo_candles(self, asset: str, count: int) -> List[Dict]:
        """Generate realistic demo candle data"""
        import random
        from datetime import timedelta
        candles = []
        base_prices = {
            "EURUSD": 1.0850, "GBPUSD": 1.2650, "USDJPY": 149.50,
            "BTCUSD": 43500.0, "ETHUSD": 2650.0, "GOLD": 2050.0,
        }
        price = base_prices.get(asset, 1.0)
        now = datetime.utcnow()

        for i in range(count):
            change = random.uniform(-0.003, 0.003)
            open_p = price
            close_p = price * (1 + change)
            high_p = max(open_p, close_p) * (1 + random.uniform(0, 0.002))
            low_p = min(open_p, close_p) * (1 - random.uniform(0, 0.002))
            vol = random.uniform(100, 10000)
            candles.append({
                "time": (now - timedelta(seconds=(count - i) * 60)).isoformat(),
                "open": round(open_p, 5),
                "high": round(high_p, 5),
                "low": round(low_p, 5),
                "close": round(close_p, 5),
                "volume": round(vol, 2),
            })
            price = close_p

        return candles