import asyncio
from pocketoptionapi_async.client import AsyncPocketOptionClient
from pocketoptionapi_async.models import OrderDirection, TimeFrame

async def main():
    # Complete SSID format (get from browser dev tools)
    ssid = r'42["auth",{"session":"your_session_here","isDemo":1,"uid":12345,"platform":1}]'
    
    # Create client with persistent connection
    client = AsyncPocketOptionClient(
        ssid, 
        is_demo=True,
        persistent_connection=True,  # Enable keep-alive
        auto_reconnect=True         # Enable auto-reconnection
    )
    
    try:
        # Connect
        await client.connect()
        
        # Get balance
        balance = await client.get_balance()
        print(f"Balance: ${balance.balance}")
        
        # Get candles
        candles = await client.get_candles("EURUSD", TimeFrame.M1, 100)
        print(f"Retrieved {len(candles)} candles")
        
        # Place order (demo)
        order = await client.place_order("EURUSD", 10, OrderDirection.CALL, 60)
        print(f"Order placed: {order.order_id}")
        
    finally:
        await client.disconnect()

asyncio.run(main())

from connection_keep_alive import ConnectionKeepAlive

async def persistent_connection_demo():
    ssid = r'42["auth",{"session":"your_session","isDemo":1,"uid":12345,"platform":1}]'
    
    # Create keep-alive manager
    keep_alive = ConnectionKeepAlive(ssid, is_demo=True)
    
    # Add event handlers
    async def on_connected(data):
        print(f"Connected to: {data['region']}")
    
    async def on_message(data):
        print(f"Message: {data['message'][:50]}...")
    
    keep_alive.add_event_handler('connected', on_connected)
    keep_alive.add_event_handler('message_received', on_message)
    
    try:
        # Start persistent connection (runs indefinitely with auto-reconnect)
        await keep_alive.start_persistent_connection()
        
        # Send messages
        await keep_alive.send_message('42["ps"]')
        
        # Keep running...
        await asyncio.sleep(60)
        
    finally:
        await keep_alive.stop_persistent_connection()

asyncio.run(persistent_connection_demo())

from connection_monitor import ConnectionMonitor

async def monitoring_demo():
    monitor = ConnectionMonitor(ssid, is_demo=True)
    
    # Add alert handlers
    async def on_alert(alert):
        print(f"ALERT: {alert['message']}")
    
    monitor.add_event_handler('alert', on_alert)
    
    # Start monitoring
    await monitor.start_monitoring()
    
    # Get real-time stats
    stats = monitor.get_real_time_stats()
    print(f"Messages: {stats['total_messages']}, Errors: {stats['total_errors']}")
    
    # Generate diagnostics report
    report = monitor.generate_diagnostics_report()
    print(f"Health Score: {report['health_score']}/100")
    
    await monitor.stop_monitoring()

from load_testing_tool import LoadTester, LoadTestConfig

async def load_test_demo():
    tester = LoadTester(ssid, is_demo=True)
    
    config = LoadTestConfig(
        concurrent_clients=5,
        operations_per_client=20,
        use_persistent_connection=True,
        stress_mode=False
    )
    
    report = await tester.run_load_test(config)
    
    print(f"Throughput: {report['test_summary']['avg_operations_per_second']:.1f} ops/sec")
    print(f"Success Rate: {report['test_summary']['success_rate']:.1%}")

from integration_tests import IntegrationTester

async def integration_test_demo():
    tester = IntegrationTester(ssid)
    report = await tester.run_full_integration_tests()
    
    print(f"Health Score: {report['integration_summary']['health_score']:.1f}/100")
    print(f"Tests Passed: {report['integration_summary']['passed_tests']}")

client = AsyncPocketOptionClient(
    ssid="your_ssid",
    is_demo=True,                    # Demo/Live mode
    region="eu",                     # Preferred region
    persistent_connection=True,      # Keep-alive enabled
    auto_reconnect=True,            # Auto-reconnection
    uid=12345,                      # User ID
    platform=1                     # Platform identifier
)

class AsyncPocketOptionClient:
    async def connect(regions: List[str] = None, persistent: bool = None) -> bool
    async def disconnect() -> None
    async def get_balance() -> Balance
    async def get_candles(asset: str, timeframe: TimeFrame, count: int) -> List[Candle]
    async def place_order(asset: str, amount: float, direction: OrderDirection, duration: int) -> OrderResult
    async def send_message(message: str) -> bool
    def get_connection_stats() -> Dict[str, Any]
    def add_event_callback(event: str, callback: Callable) -> None

class ConnectionKeepAlive:
    async def start_persistent_connection() -> bool
    async def stop_persistent_connection() -> None
    async def send_message(message: str) -> bool
    def add_event_handler(event: str, handler: Callable) -> None
    def get_connection_stats() -> Dict[str, Any]

class ConnectionMonitor:
    async def start_monitoring(persistent_connection: bool = True) -> bool
    async def stop_monitoring() -> None
    def get_real_time_stats() -> Dict[str, Any]
    def generate_diagnostics_report() -> Dict[str, Any]
    def export_metrics_csv(filename: str = None) -> str