/**
 * WebSocket Metrics Endpoint
 * Broadcasts real-time admin dashboard metrics every 5 seconds
 */

import { WebSocket, WebSocketServer } from 'ws';
import type { IncomingMessage } from 'http';
import type { Socket } from 'net';

export interface DashboardMetrics {
  timestamp: number;
  activeUsers: number;
  totalRevenue: number;
  gamesPlayed: number;
  averageSessionTime: number;
  newSignups: number;
  pendingKYC: number;
  fraudAlerts: number;
  systemHealth: 'healthy' | 'warning' | 'critical';
}

let metricsWss: WebSocketServer | null = null;

/**
 * Initialize metrics WebSocket server
 */
export function initializeMetricsServer(port: number = 3001) {
  metricsWss = new WebSocketServer({ port });

  metricsWss.on('connection', (ws: WebSocket) => {
    console.log('[Metrics] Client connected');

    // Send initial metrics
    sendMetrics(ws);

    // Set up interval to broadcast metrics every 5 seconds
    const interval = setInterval(() => {
      if (ws.readyState === WebSocket.OPEN) {
        sendMetrics(ws);
      }
    }, 5000);

    ws.on('close', () => {
      console.log('[Metrics] Client disconnected');
      clearInterval(interval);
    });

    ws.on('error', (error) => {
      console.error('[Metrics] WebSocket error:', error);
      clearInterval(interval);
    });
  });

  console.log(`[Metrics] WebSocket server listening on port ${port}`);
}

/**
 * Generate mock metrics data
 */
function generateMetrics(): DashboardMetrics {
  return {
    timestamp: Date.now(),
    activeUsers: Math.floor(Math.random() * 5000) + 1000,
    totalRevenue: Math.floor(Math.random() * 500000) + 50000,
    gamesPlayed: Math.floor(Math.random() * 100000) + 10000,
    averageSessionTime: Math.floor(Math.random() * 60) + 10,
    newSignups: Math.floor(Math.random() * 500) + 50,
    pendingKYC: Math.floor(Math.random() * 100) + 5,
    fraudAlerts: Math.floor(Math.random() * 20),
    systemHealth: Math.random() > 0.9 ? 'warning' : 'healthy',
  };
}

/**
 * Send metrics to a WebSocket client
 */
function sendMetrics(ws: WebSocket) {
  const metrics = generateMetrics();
  ws.send(JSON.stringify(metrics), (error) => {
    if (error) {
      console.error('[Metrics] Failed to send metrics:', error);
    }
  });
}

/**
 * Broadcast metrics to all connected clients
 */
export function broadcastMetrics() {
  if (!metricsWss) return;

  const metrics = generateMetrics();
  const data = JSON.stringify(metrics);

  metricsWss.clients.forEach((client: WebSocket) => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(data, (error) => {
        if (error) {
          console.error('[Metrics] Failed to broadcast metrics:', error);
        }
      });
    }
  });
}

/**
 * Shutdown metrics server
 */
export function shutdownMetricsServer() {
  if (metricsWss) {
    metricsWss.close(() => {
      console.log('[Metrics] WebSocket server closed');
    });
    metricsWss = null;
  }
}