import WebSocket from 'ws';

class GTXWebSocketClient {
  private ws: WebSocket | null = null;
  private subscriptions: Set<string> = new Set();
  private messageHandlers: Map<string, Function[]> = new Map();
  private reconnectInterval: number = 5000;
  private isConnected: boolean = false;

  constructor(
    private url: string = 'wss://ws.gtxdex.xyz',
    private apiKey?: string,
    private apiSecret?: string
  ) {}

  async connect(): Promise<void> {
    return new Promise((resolve, reject) => {
      let connectionUrl = this.url;
      
      // Connect to WebSocket
      
      this.ws = new WebSocket(connectionUrl);
      
      this.ws.on('open', () => {
        console.log('🔗 WebSocket connected');
        this.isConnected = true;
        
        // Resubscribe to all streams
        this.subscriptions.forEach(stream => {
          this.subscribe(stream);
        });
        
        resolve();
      });
      
      this.ws.on('message', (data: string) => {
        this.handleMessage(JSON.parse(data));
      });
      
      this.ws.on('close', () => {
        console.log('❌ WebSocket disconnected');
        this.isConnected = false;
        this.reconnect();
      });
      
      this.ws.on('error', (error) => {
        console.error('WebSocket error:', error);
        reject(error);
      });
    });
  }

  private createSignature(timestamp: number): string {
    const crypto = require('crypto');
    const message = `timestamp=${timestamp}`;
    return crypto
      .createHmac('sha256', this.apiSecret)
      .update(message)
      .digest('hex');
  }

  private handleMessage(message: any) {
    if (message.stream) {
      // Stream data message
      const handlers = this.messageHandlers.get(message.stream) || [];
      handlers.forEach(handler => handler(message.data));
    } else if (message.id) {
      // Response to subscription/unsubscription
      console.log('Subscription response:', message);
    }
  }

  private reconnect() {
    setTimeout(() => {
      console.log('🔄 Reconnecting...');
      this.connect().catch(console.error);
    }, this.reconnectInterval);
  }

  subscribe(stream: string, handler?: Function): void {
    this.subscriptions.add(stream);
    
    if (handler) {
      if (!this.messageHandlers.has(stream)) {
        this.messageHandlers.set(stream, []);
      }
      this.messageHandlers.get(stream)!.push(handler);
    }

    if (this.isConnected && this.ws) {
      this.ws.send(JSON.stringify({
        method: 'SUBSCRIBE',
        params: [stream],
        id: Date.now()
      }));
    }
  }

  unsubscribe(stream: string): void {
    this.subscriptions.delete(stream);
    this.messageHandlers.delete(stream);

    if (this.isConnected && this.ws) {
      this.ws.send(JSON.stringify({
        method: 'UNSUBSCRIBE',
        params: [stream],
        id: Date.now()
      }));
    }
  }

  // Convenience methods for common streams
  subscribeTicker(symbol: string, handler: (data: any) => void): void {
    this.subscribe(`ticker@${symbol}`, handler);
  }

  subscribeTrades(symbol: string, handler: (data: any) => void): void {
    this.subscribe(`trade@${symbol}`, handler);
  }

  subscribeOrderBook(symbol: string, levels: number = 20, handler?: (data: any) => void): void {
    const stream = levels ? `depth${levels}@${symbol}` : `depth@${symbol}`;
    this.subscribe(stream, handler);
  }

  subscribeKlines(symbol: string, interval: string, handler: (data: any) => void): void {
    this.subscribe(`kline_${interval}@${symbol}`, handler);
  }

  // Private streams
  subscribeUserOrders(handler: (data: any) => void): void {
    this.subscribe('executionReport', handler);
  }

  subscribeAccountUpdates(handler: (data: any) => void): void {
    this.subscribe('outboundAccountPosition', handler);
  }

  subscribeYieldUpdates(handler: (data: any) => void): void {
    this.subscribe('yieldUpdate', handler);
  }

  disconnect(): void {
    if (this.ws) {
      this.ws.close();
    }
  }
}

// Usage
const wsClient = new GTXWebSocketClient();

wsClient.connect().then(() => {
  // Subscribe to price updates
  wsClient.subscribeTicker('ETHUSDC', (ticker) => {
    console.log(`ETH price: $${ticker.lastPrice} (${ticker.priceChangePercent}%)`);
  });

  // Subscribe to trades
  wsClient.subscribeTrades('ETHUSDC', (trade) => {
    console.log(`Trade: ${trade.quantity} ETH at $${trade.price}`);
  });

  // Subscribe to order book
  wsClient.subscribeOrderBook('ETHUSDC', 5, (depth) => {
    console.log(`Best bid: $${depth.bids[0][0]}, Best ask: $${depth.asks[0][0]}`);
  });
});

class ConnectionManager {
  private lastPingTime: number = 0;
  private pingInterval: NodeJS.Timeout | null = null;
  
  startHealthCheck(ws: WebSocket): void {
    this.pingInterval = setInterval(() => {
      if (ws.readyState === WebSocket.OPEN) {
        this.lastPingTime = Date.now();
        ws.ping();
      }
    }, 30000); // Ping every 30 seconds
    
    ws.on('pong', () => {
      const latency = Date.now() - this.lastPingTime;
      console.log(`📡 Ping: ${latency}ms`);
    });
  }
  
  stopHealthCheck(): void {
    if (this.pingInterval) {
      clearInterval(this.pingInterval);
    }
  }
}