#!/usr/bin/env bun
/**
 * Script to get all active connections to Dragonfly/Redis and group them by client name
 * 
 * This script connects to the actual Dragonfly Docker container and retrieves:
 * - All active client connections
 * - Groups them by client name/type (removes timestamp suffixes)
 * - Shows connection details like IP, idle time, commands executed
 * 
 * Usage:
 *   bun run scripts/get-redis-connections.ts
 *   
 * Requirements:
 *   - Dragonfly Docker container must be running
 *   - Script assumes default connection settings (localhost:6379)
 */

import Redis from 'ioredis';

interface ClientInfo {
  id: string;
  name?: string;
  addr: string;
  fd: string;
  age: string;
  idle: string;
  flags: string;
  db: string;
  sub: string;
  psub: string;
  multi: string;
  qbuf: string;
  qbufFree: string;
  obl: string;
  oll: string;
  omem: string;
  events: string;
  cmd: string;
  argv?: string;
  tot?: string;
  [key: string]: string | undefined;
}

interface GroupedConnections {
  [clientName: string]: {
    count: number;
    connections: ClientInfo[];
    totalCommands: number;
    avgIdleTime: number;
  };
}

class DragonFlyConnectionMonitor {
  private redis: Redis;
  
  constructor() {
    // Connect to Dragonfly using the same settings as the Docker setup
    this.redis = new Redis({
      host: process.env.DRAGONFLY_HOST || 'localhost',
      port: parseInt(process.env.DRAGONFLY_PORT || '6379'),
      password: process.env.DRAGONFLY_PASSWORD || undefined,
      db: parseInt(process.env.DRAGONFLY_DATABASE || '0'),
      maxRetriesPerRequest: 3,
      lazyConnect: false,
    });
  }

  /**
   * Parse CLIENT LIST output into structured data
   */
  private parseClientList(clientListOutput: string): ClientInfo[] {
    const lines = clientListOutput.trim().split('\n');
    const clients: ClientInfo[] = [];

    for (const line of lines) {
      if (!line.trim()) continue;
      
      const client: ClientInfo = {
        id: '',
        addr: '',
        fd: '',
        age: '',
        idle: '',
        flags: '',
        db: '',
        sub: '',
        psub: '',
        multi: '',
        qbuf: '',
        qbufFree: '',
        obl: '',
        oll: '',
        omem: '',
        events: '',
        cmd: '',
      };

      // Parse key=value pairs
      const pairs = line.split(' ');
      for (const pair of pairs) {
        const [key, value] = pair.split('=');
        if (key && value !== undefined) {
          client[key] = value;
        }
      }

      clients.push(client);
    }

    return clients;
  }

  /**
   * Clean up client names by removing timestamp/number suffixes
   */
  private cleanClientName(rawName: string): string {
    if (!rawName || rawName === 'unnamed') {
      return rawName;
    }

    // Remove timestamp/number suffixes (like BATCH-PROCESSOR-1749573709724)
    // Pattern: Remove dash followed by numbers at the end
    let cleanName = rawName.replace(/-\d+$/, '');
    
    // Also handle patterns like NAME---1-1- (RedisInsight style)
    cleanName = cleanName.replace(/---\d+-\d+-?$/, '');
    
    // Convert to a more readable format
    cleanName = cleanName
      .replace(/-/g, ' ')
      .toLowerCase()
      .replace(/\b\w/g, l => l.toUpperCase());

    return cleanName;
  }

  /**
   * Group connections by client name/type
   */
  private groupConnectionsByName(clients: ClientInfo[]): GroupedConnections {
    const grouped: GroupedConnections = {};

    for (const client of clients) {
      // Determine client name - use 'name' field if set, otherwise infer from other properties
      let clientName = client.name || 'unnamed';
      
      // Clean up the client name by removing timestamps/numbers
      if (clientName && clientName !== 'unnamed') {
        clientName = this.cleanClientName(clientName);
      }
      
      // If no name is set, try to infer from the connection characteristics
      if (clientName === 'unnamed' || !clientName) {
        if (client.flags.includes('M')) {
          clientName = 'Master Connection';
        } else if (client.flags.includes('S')) {
          clientName = 'Slave Connection';
        } else if (client.flags.includes('P')) {
          clientName = 'PubSub Connection';
        } else if (client.cmd === 'monitor') {
          clientName = 'Monitor Connection';
        } else if (client.addr.includes('127.0.0.1') || client.addr.includes('localhost')) {
          clientName = 'Local Client';
        } else if (client.addr.includes('172.') || client.addr.includes('192.168.')) {
          clientName = 'Docker Network Client';
        } else {
          clientName = `Client ${client.addr.split(':')[0]}`;
        }
      }

      if (!grouped[clientName]) {
        grouped[clientName] = {
          count: 0,
          connections: [],
          totalCommands: 0,
          avgIdleTime: 0,
        };
      }

      grouped[clientName].count++;
      grouped[clientName].connections.push(client);
      
      // Parse command count if available
      const cmdCount = client.tot ? parseInt(client.tot) : 0;
      grouped[clientName].totalCommands += cmdCount;
    }

    // Calculate average idle times
    for (const groupName in grouped) {
      const group = grouped[groupName];
      const totalIdle = group.connections.reduce((sum, client) => {
        return sum + parseInt(client.idle || '0');
      }, 0);
      group.avgIdleTime = group.count > 0 ? Math.round(totalIdle / group.count) : 0;
    }

    return grouped;
  }

  /**
   * Format connection details for display
   */
  private formatConnectionDetails(client: ClientInfo): string {
    const details = [
      `ID: ${client.id}`,
      `Address: ${client.addr}`,
      `Age: ${client.age}s`,
      `Idle: ${client.idle}s`,
      `DB: ${client.db}`,
      `Flags: ${client.flags}`,
      `Last Command: ${client.cmd || 'none'}`,
    ];
    
    if (client.tot) {
      details.push(`Total Commands: ${client.tot}`);
    }
    
    if (client.name) {
      details.unshift(`Original Name: ${client.name}`);
    }
    
    return details.join(', ');
  }

  /**
   * Get and display all connections grouped by name
   */
  async getConnectionsGroupedByName(): Promise<void> {
    try {
      console.log('🔍 Connecting to Dragonfly...');
      await this.redis.connect();
      
      console.log('📡 Fetching client connections...');
      const clientListOutput = await this.redis.client('LIST') as string;
      
      if (!clientListOutput) {
        console.log('❌ No client information available');
        return;
      }

      const clients = this.parseClientList(clientListOutput);
      const grouped = this.groupConnectionsByName(clients);

      console.log('\n🎯 DRAGONFLY CONNECTION SUMMARY');
      console.log('═'.repeat(60));
      console.log(`Total Active Connections: ${clients.length}`);
      console.log(`Connection Groups: ${Object.keys(grouped).length}`);
      console.log('');

      // Sort groups by count (most connections first)
      const sortedGroups = Object.entries(grouped).sort((a, b) => b[1].count - a[1].count);

      // Display grouped connections
      for (const [groupName, group] of sortedGroups) {
        console.log(`📂 ${groupName.toUpperCase()}`);
        console.log(`   Count: ${group.count}`);
        console.log(`   Total Commands Executed: ${group.totalCommands}`);
        console.log(`   Average Idle Time: ${group.avgIdleTime}s`);
        console.log('   Connections:');
        
        for (const client of group.connections) {
          console.log(`   ├─ ${this.formatConnectionDetails(client)}`);
        }
        console.log('');
      }

      // Get additional server info
      console.log('🖥️  DRAGONFLY SERVER INFO');
      console.log('═'.repeat(60));
      const info = await this.redis.info('server');
      const infoLines = info.split('\n');
      
      for (const line of infoLines) {
        if (line.includes('dragonfly_version') || 
            line.includes('connected_clients') || 
            line.includes('used_memory_human') ||
            line.includes('uptime_in_seconds')) {
          console.log(`   ${line}`);
        }
      }

      // Get memory info
      console.log('\n💾 MEMORY USAGE');
      console.log('═'.repeat(60));
      const memoryInfo = await this.redis.info('memory');
      const memoryLines = memoryInfo.split('\n');
      
      for (const line of memoryLines) {
        if (line.includes('used_memory_human') || 
            line.includes('maxmemory_human') ||
            line.includes('used_memory_percentage')) {
          console.log(`   ${line}`);
        }
      }

    } catch (error) {
      console.error('❌ Error connecting to Dragonfly:', error);
      console.log('\n💡 Troubleshooting:');
      console.log('   - Make sure Dragonfly Docker container is running');
      console.log('   - Check if port 6379 is accessible');
      console.log('   - Verify environment variables if using custom connection settings');
      console.log('   - Run: docker ps | grep dragonfly');
    } finally {
      await this.redis.disconnect();
    }
  }

  /**
   * Monitor connections in real-time
   */
  async monitorConnections(intervalSeconds: number = 5): Promise<void> {
    console.log(`🔄 Starting real-time monitoring (refresh every ${intervalSeconds}s)`);
    console.log('Press Ctrl+C to stop...\n');

    const monitor = async () => {
      console.clear();
      console.log(`🕐 Last updated: ${new Date().toLocaleTimeString()}\n`);
      await this.getConnectionsGroupedByName();
    };

    // Initial run
    await monitor();

    // Set up interval
    const interval = setInterval(monitor, intervalSeconds * 1000);

    // Handle graceful shutdown
    process.on('SIGINT', () => {
      clearInterval(interval);
      console.log('\n👋 Monitoring stopped');
      process.exit(0);
    });
  }
}

// Main execution
async function main() {
  const args = process.argv.slice(2);
  const monitor = new DragonFlyConnectionMonitor();

  if (args.includes('--monitor') || args.includes('-m')) {
    const intervalArg = args.find(arg => arg.startsWith('--interval='));
    const interval = intervalArg ? parseInt(intervalArg.split('=')[1]) : 5;
    await monitor.monitorConnections(interval);
  } else {
    await monitor.getConnectionsGroupedByName();
  }
}

// Help text
if (process.argv.includes('--help') || process.argv.includes('-h')) {
  console.log(`
🐉 Dragonfly Connection Monitor

Usage:
  bun run scripts/get-redis-connections.ts [options]

Options:
  --help, -h              Show this help message
  --monitor, -m           Monitor connections in real-time
  --interval=N            Set monitoring refresh interval in seconds (default: 5)

Examples:
  bun run scripts/get-redis-connections.ts                    # One-time connection list
  bun run scripts/get-redis-connections.ts --monitor          # Real-time monitoring
  bun run scripts/get-redis-connections.ts -m --interval=10   # Monitor every 10 seconds

Environment Variables:
  DRAGONFLY_HOST          Dragonfly host (default: localhost)
  DRAGONFLY_PORT          Dragonfly port (default: 6379)
  DRAGONFLY_PASSWORD      Dragonfly password (if auth enabled)
  DRAGONFLY_DATABASE      Database number (default: 0)

Features:
  ✨ Groups connections by clean names (removes timestamp suffixes)
  📊 Shows connection statistics and command counts
  🔄 Real-time monitoring mode available
  🎨 Color-coded output with connection details
`);
  process.exit(0);
}

// Run the script
console.log('🚀 Starting Redis connection monitor...');
main().catch((error) => {
  console.error('❌ Script error:', error);
  process.exit(1);
});