import crypto from 'crypto';
import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
import { join } from 'path';
import axios from 'axios';

const TIMEOUT_SECONDS = 1800; // 30 Minuten
const MAX_ACTIVE_VIDEO_CONNECTIONS = 3;
const ACTIVE_VIDEO_SESSION_STATUSES = new Set(['ringing', 'connecting', 'active']);
const TERMINAL_VIDEO_SESSION_STATUSES = new Set(['rejected', 'cancelled', 'ended', 'failed']);
const VIDEO_CONNECTION_STATES = new Set(['new', 'connecting', 'connected', 'disconnected', 'failed', 'closed']);

function parseDelimitedEnvList(rawValue) {
  return String(rawValue || '')
    .split(/[,\n]/)
    .map((entry) => entry.trim())
    .filter(Boolean);
}

function buildVideoIceServers() {
  const jsonConfig = String(process.env.VIDEO_ICE_SERVERS_JSON || '').trim();
  if (jsonConfig) {
    try {
      const parsed = JSON.parse(jsonConfig);
      return Array.isArray(parsed) ? parsed : [];
    } catch (error) {
      console.error('Ungültiges VIDEO_ICE_SERVERS_JSON:', error.message);
      return [];
    }
  }

  const iceServers = [];
  const stunUrls = parseDelimitedEnvList(process.env.VIDEO_STUN_URLS);
  if (stunUrls.length > 0) {
    iceServers.push({ urls: stunUrls });
  }

  const turnUrls = parseDelimitedEnvList(process.env.VIDEO_TURN_URLS);
  const turnUsername = String(process.env.VIDEO_TURN_USERNAME || '').trim();
  const turnCredential = String(process.env.VIDEO_TURN_CREDENTIAL || '').trim();
  if (turnUrls.length > 0 && turnUsername && turnCredential) {
    iceServers.push({
      urls: turnUrls,
      username: turnUsername,
      credential: turnCredential
    });
  }

  return iceServers;
}

const VIDEO_ICE_SERVERS = buildVideoIceServers();
const VIDEO_MEDIA_RELAY_CONFIGURED = VIDEO_ICE_SERVERS.some((server) => {
  const urls = Array.isArray(server?.urls) ? server.urls : [server?.urls];
  return urls.some((url) => String(url || '').startsWith('turn:') || String(url || '').startsWith('turns:'));
});

if (!VIDEO_MEDIA_RELAY_CONFIGURED) {
  console.warn('Video-Medienpfad ist nicht vollständig konfiguriert. Setze VIDEO_TURN_URLS, VIDEO_TURN_USERNAME und VIDEO_TURN_CREDENTIAL.');
}

class Client {
  constructor(sessionId) {
    this.sessionId = sessionId;
    this.gender = '';
    this.country = '';
    this.isoCountryCode = '';
    this.userName = '';
    this.age = 0;
    this.conversations = {};
    this.lastActivity = new Date();
    this.loginTimeStamp = new Date();
    this.blockedUsers = new Set();
    this.socket = null; // Socket.IO Socket-Objekt
    this.chatAuth = null; // { username, rights: Set<string> }
    this.pendingChatLogin = null; // { step: 'username'|'password', username: string }
  }

  setActivity() {
    this.lastActivity = new Date();
  }

  activitiesTimedOut() {
    const secondsSinceActivity = (new Date() - this.lastActivity) / 1000;
    return secondsSinceActivity > TIMEOUT_SECONDS;
  }

  remainingSecondsToTimeout() {
    const secondsSinceActivity = (new Date() - this.lastActivity) / 1000;
    return Math.max(0, TIMEOUT_SECONDS - secondsSinceActivity);
  }

  currentlyLoggedInSeconds() {
    return Math.floor((new Date() - this.loginTimeStamp) / 1000);
  }

  toJSON() {
    return {
      sessionId: this.sessionId,
      userName: this.userName,
      gender: this.gender,
      country: this.country,
      isoCountryCode: this.isoCountryCode,
      age: this.age
    };
  }
}

const CHAT_USERS_FILE_NAME = 'chat-users.json';
const CHAT_RIGHTS = {
  STAT: 'stat',
  KICK: 'kick'
};

function getLogsDir(__dirname) {
  return join(__dirname, '../logs');
}

function ensureLogsDir(__dirname) {
  const logsDir = getLogsDir(__dirname);
  if (!existsSync(logsDir)) {
    mkdirSync(logsDir, { recursive: true });
  }
  return logsDir;
}

function getChatUsersPath(__dirname) {
  return join(ensureLogsDir(__dirname), CHAT_USERS_FILE_NAME);
}

function sha256(value) {
  return crypto.createHash('sha256').update(value).digest('hex');
}

function ensureChatUsersFile(__dirname) {
  const usersPath = getChatUsersPath(__dirname);
  if (existsSync(usersPath)) {
    return;
  }
  // Security: never create predictable default credentials.
  // Admin users must be configured explicitly in logs/chat-users.json.
  writeFileSync(usersPath, '[]\n', 'utf-8');
  console.warn(
    `[Auth] ${CHAT_USERS_FILE_NAME} wurde neu erstellt. Bitte mindestens einen Admin-User mit Passwort-Hash konfigurieren.`
  );
}

function loadChatUsers(__dirname) {
  ensureChatUsersFile(__dirname);
  const usersPath = getChatUsersPath(__dirname);
  const raw = readFileSync(usersPath, 'utf-8').trim();
  if (!raw) return [];

  let users = [];
  try {
    users = JSON.parse(raw);
  } catch (error) {
    throw new Error(`Ungültige ${CHAT_USERS_FILE_NAME}: ${error.message}`);
  }

  if (!Array.isArray(users)) {
    throw new Error(`${CHAT_USERS_FILE_NAME} muss ein Array sein`);
  }

  return users
    .filter((entry) => entry && typeof entry.username === 'string')
    .map((entry) => ({
      username: entry.username.trim(),
      passwordHash: typeof entry.passwordHash === 'string' ? entry.passwordHash.trim() : '',
      rights: Array.isArray(entry.rights) ? entry.rights.map((r) => String(r).toLowerCase()) : []
    }))
    .filter((entry) => entry.username && entry.passwordHash);
}

function parseLoginRecord(line) {
  const trimmed = line.trim();
  if (!trimmed) return null;
  const parts = trimmed.split(',');
  if (parts.length < 5) return null;

  const timestamp = parts[0].trim();
  const userName = parts[1].trim();
  const gender = parts[parts.length - 1].trim();
  const ageRaw = parts[parts.length - 2].trim();
  const country = parts.slice(2, parts.length - 2).join(',').trim();
  const age = Number.parseInt(ageRaw, 10);

  const date = new Date(timestamp);
  if (!timestamp || !userName || !country || Number.isNaN(age) || Number.isNaN(date.getTime())) {
    return null;
  }

  return {
    timestamp,
    date,
    day: timestamp.slice(0, 10),
    userName,
    country,
    age,
    gender
  };
}

let clients = new Map();
let conversations = new Map(); // Key: "user1:user2" (alphabetisch sortiert)
let videoConversations = new Map(); // Key: "user1:user2"
let videoSessions = new Map(); // Key: callId

// Map: Socket-ID -> Express-Session-ID (für Session-Wiederherstellung)
let socketToSessionMap = new Map();

// Exportiere clients Map für Zugriff von außen
export function getClientsMap() {
  return clients;
}

// Exportiere Funktion zum Abrufen der Session-ID für einen Socket
export function getSessionIdForSocket(socketId) {
  return socketToSessionMap.get(socketId);
}

export function extractSessionId(handshakeOrRequest) {
  // Unterstützt sowohl Socket.IO handshake als auch Express request
  const cookies = handshakeOrRequest.headers?.cookie || handshakeOrRequest.cookies || '';
  
  console.log('extractSessionId - Cookies:', cookies);
  
  const sessionMatch = cookies.match(/connect\.sid=([^;]+)/);
  if (sessionMatch) {
    let sessionId = sessionMatch[1];
    
    console.log('extractSessionId - Gefundenes Cookie:', sessionId);
    
    // Express-Session speichert die Session-ID als signierten Wert: s:xxxxx.signature
    // Die tatsächliche Session-ID ist nur xxxxx
    if (sessionId.startsWith('s:')) {
      const parts = sessionId.split('.');
      if (parts.length > 0) {
        sessionId = parts[0].substring(2); // Entferne 's:' Präfix
        console.log('extractSessionId - Bereinigte Session-ID:', sessionId);
      }
    }
    
    return sessionId;
  }
  
  console.log('extractSessionId - Kein connect.sid Cookie gefunden');
  // Fallback: Generiere temporäre UUID
  return crypto.randomUUID();
}

// Exportiere Funktion zum Prüfen des Session-Status
export function getSessionStatus(req) {
  // Verwende req.sessionID von Express-Session
  const sessionId = req.sessionID || extractSessionId(req);
  
  if (!sessionId) {
    return null;
  }
  
  const client = clients.get(sessionId);
  
  if (!client || !client.userName) {
    return null;
  }
  
  return {
    sessionId: client.sessionId,
    userName: client.userName,
    gender: client.gender,
    age: client.age,
    country: client.country,
    isoCountryCode: client.isoCountryCode
  };
}

function getConversationKey(user1, user2) {
  return [user1, user2].sort().join(':');
}

function isSocketConnected(socket) {
  return !!(socket && socket.connected);
}

function isClientOnline(client) {
  return !!(client && client.userName && isSocketConnected(client.socket));
}

function getClientByUserName(userName) {
  for (const client of clients.values()) {
    if (client.userName === userName) {
      return client;
    }
  }
  return null;
}

function getOrCreateVideoConversation(user1, user2) {
  const users = [user1, user2].sort();
  const convKey = users.join(':');
  let state = videoConversations.get(convKey);
  if (!state) {
    state = {
      convKey,
      users,
      consents: {
        [users[0]]: false,
        [users[1]]: false
      },
      activeCallIds: new Set()
    };
    videoConversations.set(convKey, state);
  } else {
    for (const user of users) {
      if (typeof state.consents[user] !== 'boolean') {
        state.consents[user] = false;
      }
    }
    if (!(state.activeCallIds instanceof Set)) {
      state.activeCallIds = new Set(Array.isArray(state.activeCallIds) ? state.activeCallIds : []);
    }
  }
  return state;
}

function getExistingVideoConversation(user1, user2) {
  return videoConversations.get(getConversationKey(user1, user2)) || null;
}

function getVideoConversationForRead(user1, user2) {
  const existing = getExistingVideoConversation(user1, user2);
  if (existing) {
    return existing;
  }
  const users = [user1, user2].sort();
  return {
    convKey: users.join(':'),
    users,
    consents: {
      [users[0]]: false,
      [users[1]]: false
    },
    activeCallIds: new Set()
  };
}

function removeVideoConversationIfEmpty(user1, user2) {
  const convKey = getConversationKey(user1, user2);
  const state = videoConversations.get(convKey);
  if (!state) return;

  const hasConsent = Object.values(state.consents || {}).some(Boolean);
  const hasActiveCalls = Array.from(state.activeCallIds || []).some((callId) => {
    const session = videoSessions.get(callId);
    return session && ACTIVE_VIDEO_SESSION_STATUSES.has(session.status);
  });

  if (!hasConsent && !hasActiveCalls) {
    videoConversations.delete(convKey);
  }
}

function getOtherParticipant(session, userName) {
  return session.participants.find((participant) => participant !== userName) || null;
}

function buildVideoConsentPayload(viewerName, state) {
  const otherUserName = state.users.find((user) => user !== viewerName) || null;
  return {
    withUserName: otherUserName,
    localConsent: !!state.consents[viewerName],
    remoteConsent: otherUserName ? !!state.consents[otherUserName] : false,
    videoVisible: !!(otherUserName && state.consents[viewerName] && state.consents[otherUserName])
  };
}

function emitVideoConsentStateToUser(userName, otherUserName) {
  const client = getClientByUserName(userName);
  if (!isClientOnline(client)) return;

  const state = getVideoConversationForRead(userName, otherUserName);
  client.socket.emit('videoConsent:update', buildVideoConsentPayload(userName, state));
}

function emitVideoConsentStateToParticipants(user1, user2) {
  emitVideoConsentStateToUser(user1, user2);
  emitVideoConsentStateToUser(user2, user1);
}

function buildVideoCallPayloadForUser(session, userName) {
  const otherUserName = getOtherParticipant(session, userName);
  const muteStates = session.muteStates || {};
  const connectionStates = session.connectionStates || {};
  const includeMedia = session.status === 'connecting' || session.status === 'active';
  return {
    callId: session.callId,
    roomId: session.roomId,
    withUserName: otherUserName,
    initiatedBy: session.initiatedBy,
    status: session.status,
    createdAt: session.createdAt,
    updatedAt: session.updatedAt,
    endedAt: session.endedAt || null,
    reason: session.reason || null,
    localMuted: !!muteStates[userName],
    remoteMuted: otherUserName ? !!muteStates[otherUserName] : false,
    connectionState: connectionStates[userName] || 'new',
    remoteConnectionState: otherUserName ? (connectionStates[otherUserName] || 'new') : 'new',
    media: includeMedia ? {
      mode: 'webrtc-relay',
      relayOnly: true,
      iceTransportPolicy: 'relay',
      iceServers: VIDEO_ICE_SERVERS,
      isCaller: session.initiatedBy === userName
    } : null
  };
}

function emitVideoCallEventToUser(userName, eventName, session) {
  const client = getClientByUserName(userName);
  if (!isClientOnline(client)) return;
  client.socket.emit(eventName, buildVideoCallPayloadForUser(session, userName));
}

function emitVideoCapacityToUser(userName) {
  const client = getClientByUserName(userName);
  if (!isClientOnline(client)) return;
  const activeConnections = getActiveVideoSessionsForUser(userName).length;
  client.socket.emit('videoCall:capacity', {
    activeConnections,
    maxConnections: MAX_ACTIVE_VIDEO_CONNECTIONS,
    reachedMax: activeConnections >= MAX_ACTIVE_VIDEO_CONNECTIONS
  });
}

function getActiveVideoSessionsForUser(userName) {
  return Array.from(videoSessions.values()).filter((session) => (
    session.participants.includes(userName) &&
    ACTIVE_VIDEO_SESSION_STATUSES.has(session.status)
  ));
}

function hasVideoCapacity(userName) {
  return getActiveVideoSessionsForUser(userName).length < MAX_ACTIVE_VIDEO_CONNECTIONS;
}

function findActiveVideoSessionBetween(user1, user2) {
  return Array.from(videoSessions.values()).find((session) => (
    ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) &&
    session.participants.includes(user1) &&
    session.participants.includes(user2)
  )) || null;
}

function createVideoSession(callerUserName, calleeUserName) {
  const now = new Date().toISOString();
  const callId = crypto.randomUUID();
  return {
    callId,
    roomId: `video-${callId}`,
    participants: [callerUserName, calleeUserName],
    initiatedBy: callerUserName,
    status: 'ringing',
    muteStates: {
      [callerUserName]: false,
      [calleeUserName]: false
    },
    connectionStates: {
      [callerUserName]: 'new',
      [calleeUserName]: 'new'
    },
    createdAt: now,
    updatedAt: now,
    endedAt: null,
    reason: null
  };
}

function touchVideoSession(session, status, reason = null) {
  session.status = status;
  session.updatedAt = new Date().toISOString();
  if (reason) {
    session.reason = reason;
  }
  if (TERMINAL_VIDEO_SESSION_STATUSES.has(status)) {
    session.endedAt = session.updatedAt;
  }
}

function registerVideoSession(session) {
  videoSessions.set(session.callId, session);
  const state = getOrCreateVideoConversation(session.participants[0], session.participants[1]);
  state.activeCallIds.add(session.callId);
  return state;
}

function finalizeVideoSession(session) {
  const state = getExistingVideoConversation(session.participants[0], session.participants[1]);
  if (state) {
    state.activeCallIds.delete(session.callId);
  }
  videoSessions.delete(session.callId);
  removeVideoConversationIfEmpty(session.participants[0], session.participants[1]);
}

function sendVideoCallError(socket, code, message, details = {}) {
  socket.emit('videoCall:error', {
    code,
    message,
    ...details
  });
}

function emitVideoCallUpdateToParticipants(session) {
  emitVideoCallEventToUser(session.participants[0], 'videoCall:update', session);
  emitVideoCallEventToUser(session.participants[1], 'videoCall:update', session);
}

function buildVideoSignalPayload(callId, fromUserName, signalType, details = {}) {
  return {
    callId,
    fromUserName,
    signalType,
    ...details
  };
}

function isRelayIceCandidate(candidate) {
  if (!candidate || typeof candidate !== 'object') {
    return false;
  }
  if (candidate.type) {
    return String(candidate.type).toLowerCase() === 'relay';
  }
  const candidateLine = String(candidate.candidate || '');
  return /\btyp relay\b/i.test(candidateLine);
}

function endVideoSession(session, reason = 'ended', initiatorUserName = null) {
  if (!session || TERMINAL_VIDEO_SESSION_STATUSES.has(session.status)) {
    return;
  }

  touchVideoSession(session, 'ended', reason);
  for (const participant of session.participants) {
    const payload = buildVideoCallPayloadForUser(session, participant);
    if (initiatorUserName) {
      payload.endedBy = initiatorUserName;
    }
    const client = getClientByUserName(participant);
    if (isClientOnline(client)) {
      client.socket.emit('videoCall:end', payload);
    }
  }
  finalizeVideoSession(session);
  for (const participant of session.participants) {
    emitVideoCapacityToUser(participant);
  }
}

function endVideoSessionsForPair(user1, user2, reason = 'ended', initiatorUserName = null) {
  for (const session of Array.from(videoSessions.values())) {
    if (
      ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) &&
      session.participants.includes(user1) &&
      session.participants.includes(user2)
    ) {
      endVideoSession(session, reason, initiatorUserName);
    }
  }
}

function endAllVideoSessionsForUser(userName, reason = 'ended', initiatorUserName = null) {
  for (const session of Array.from(videoSessions.values())) {
    if (ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) && session.participants.includes(userName)) {
      endVideoSession(session, reason, initiatorUserName);
    }
  }
}

function logClientLogin(client, __dirname) {
  try {
    const logsDir = join(__dirname, '../logs');
    // Erstelle logs-Verzeichnis falls es nicht existiert
    if (!existsSync(logsDir)) {
      try {
        mkdirSync(logsDir, { recursive: true });
        console.log(`[Log] Logs-Verzeichnis erstellt: ${logsDir}`);
      } catch (mkdirError) {
        console.error(`[Log] Fehler beim Erstellen des Logs-Verzeichnisses: ${mkdirError.message}`);
        return; // Beende Funktion, wenn Verzeichnis nicht erstellt werden kann
      }
    }
    const logPath = join(logsDir, 'logins.log');
    const logEntry = `${new Date().toISOString()},${client.userName},${client.country},${client.age},${client.gender}\n`;
    appendFileSync(logPath, logEntry, 'utf-8');
  } catch (error) {
    console.error('Fehler beim Loggen des Logins:', error.message);
  }
}

function checkAndLogStart(__dirname) {
  try {
    const logsDir = join(__dirname, '../logs');
    // Erstelle logs-Verzeichnis falls es nicht existiert
    if (!existsSync(logsDir)) {
      try {
        mkdirSync(logsDir, { recursive: true });
        console.log(`[Log] Logs-Verzeichnis erstellt: ${logsDir}`);
      } catch (mkdirError) {
        console.error(`[Log] Fehler beim Erstellen des Logs-Verzeichnisses: ${mkdirError.message}`);
        return; // Beende Funktion, wenn Verzeichnis nicht erstellt werden kann
      }
    }
    const logPath = join(logsDir, 'starts.log');
    const logEntry = `${new Date().toISOString()}\n`;
    appendFileSync(logPath, logEntry, 'utf-8');
  } catch (error) {
    console.error('Fehler beim Loggen des Starts:', error.message);
  }
}

export function setupBroadcast(io, __dirname) {
  // Länderliste beim Start laden
  let countriesMap = {};
  
  async function downloadCountries() {
    try {
      const response = await axios.get('https://pkgstore.datahub.io/core/country-list/data_csv/data/d7c9d7cfb42cb69f4422dec222dbbaa8/data_csv.csv');
      const lines = response.data.split('\n');
      countriesMap = {};
      
      // Parse CSV-Zeile mit Berücksichtigung von Anführungszeichen
      const parseCSVLine = (line) => {
        const result = [];
        let current = '';
        let inQuotes = false;
        
        for (let i = 0; i < line.length; i++) {
          const char = line[i];
          if (char === '"') {
            // Ignoriere Anführungszeichen, sie werden nicht zum Wert hinzugefügt
            inQuotes = !inQuotes;
          } else if (char === ',' && !inQuotes) {
            result.push(current.trim());
            current = '';
          } else {
            current += char;
          }
        }
        result.push(current.trim());
        return result;
      };
      
      for (let i = 1; i < lines.length; i++) {
        const line = lines[i].trim();
        if (!line) continue;
        
        const [name, code] = parseCSVLine(line);
        if (name && code) {
          // Entferne alle Anführungszeichen (auch am Anfang/Ende)
          const cleanName = name.replace(/^["']+|["']+$/g, '').replace(/["']/g, '').trim();
          const cleanCode = code.replace(/^["']+|["']+$/g, '').replace(/["']/g, '').trim();
          if (cleanName && cleanCode) {
            countriesMap[cleanName] = cleanCode.toLowerCase();
          }
        }
      }
      
      console.log(`Länderliste geladen: ${Object.keys(countriesMap).length} Länder`);
    } catch (error) {
      console.error('Fehler beim Laden der Länderliste:', error);
    }
  }
  
  downloadCountries();
  setInterval(downloadCountries, 24 * 60 * 60 * 1000); // Täglich aktualisieren

  function sendCommandResult(socket, lines, kind = 'info') {
    const payload = Array.isArray(lines) ? lines : [String(lines)];
    socket.emit('commandResult', { lines: payload, kind });
  }

  function sendCommandTable(socket, title, columns, rows) {
    socket.emit('commandTable', {
      title: String(title || 'Ausgabe'),
      columns: Array.isArray(columns) ? columns.map((c) => String(c)) : [],
      rows: Array.isArray(rows) ? rows : []
    });
  }

  function hasRight(client, right) {
    return !!client.chatAuth && client.chatAuth.rights instanceof Set && client.chatAuth.rights.has(right);
  }

  function getLoginsPath() {
    return join(ensureLogsDir(__dirname), 'logins.log');
  }

  function readLoginRecords() {
    const logPath = getLoginsPath();
    if (!existsSync(logPath)) return [];
    const raw = readFileSync(logPath, 'utf-8');
    return raw
      .split('\n')
      .map(parseLoginRecord)
      .filter(Boolean);
  }

  function aggregateTop(items, keySelector, limit = 10) {
    const counts = new Map();
    for (const item of items) {
      const key = keySelector(item);
      counts.set(key, (counts.get(key) || 0) + 1);
    }
    return Array.from(counts.entries())
      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
      .slice(0, limit);
  }

  function readStartsLogStats() {
    const path = join(ensureLogsDir(__dirname), 'starts.log');
    if (!existsSync(path)) {
      return { count: 0, first: null, last: null };
    }
    const lines = readFileSync(path, 'utf-8')
      .split('\n')
      .map((l) => l.trim())
      .filter(Boolean);
    if (lines.length === 0) {
      return { count: 0, first: null, last: null };
    }
    return { count: lines.length, first: lines[0], last: lines[lines.length - 1] };
  }

  /**
   * Sammelt alle verfügbaren Kennzahlen: Live-Server, starts.log, vollständige Auswertung von logins.log
   * (entspricht inhaltlich den /stat-Unterbefehlen in einer Tabelle).
   */
  function buildFullAllStatsRows(records) {
    const rows = [];
    const push = (a, b) => rows.push([String(a), b == null ? '' : String(b)]);

    const liveOnline = Array.from(clients.values()).filter(
      (c) => c.userName && c.socket && c.socket.connected
    ).length;
    const socketCount =
      io.sockets && io.sockets.sockets && typeof io.sockets.sockets.size === 'number'
        ? io.sockets.sockets.size
        : 0;
    let totalMessages = 0;
    for (const msgs of conversations.values()) {
      totalMessages += Array.isArray(msgs) ? msgs.length : 0;
    }

    const starts = readStartsLogStats();

    push('— Live (Server) —', '');
    push('Nutzer mit Chat-Login und aktiver Verbindung', liveOnline);
    push('Socket.IO-Verbindungen (/)', socketCount);
    push('Client-Sitzungen im Speicher', clients.size);
    push('Unterhaltungen im Speicher (Paare)', conversations.size);
    push('Nachrichten-Einträge gesamt (RAM)', totalMessages);
    push('Server-Starts protokolliert (starts.log)', starts.count);
    if (starts.first) {
      push('Erster Start (Timestamp)', starts.first);
    }
    if (starts.last) {
      push('Letzter Start (Timestamp)', starts.last);
    }

    push('— Login-Protokoll (logins.log, UTC) —', '');
    if (records.length === 0) {
      push('Keine Einträge', '—');
      return rows;
    }

    const sortedByDate = records.slice().sort((a, b) => a.date - b.date);
    const firstTs = sortedByDate[0].timestamp;
    const lastTs = sortedByDate[sortedByDate.length - 1].timestamp;
    const daysSorted = records.map((r) => r.day).sort();
    const dayMin = daysSorted[0];
    const dayMax = daysSorted[daysSorted.length - 1];

    const today = new Date().toISOString().slice(0, 10);
    const dayRecords = records.filter((r) => r.day === today);
    const latestByUserToday = new Map();
    dayRecords
      .slice()
      .sort((a, b) => b.date - a.date)
      .forEach((record) => {
        if (!latestByUserToday.has(record.userName)) {
          latestByUserToday.set(record.userName, record);
        }
      });
    const uniqueToday = latestByUserToday.size;
    const namesToday = Array.from(latestByUserToday.keys()).sort((a, b) => a.localeCompare(b, 'de'));

    const uniqueNames = new Set(records.map((r) => r.userName)).size;
    const ages = records.map((r) => r.age);
    const minAge = Math.min(...ages);
    const maxAge = Math.max(...ages);
    const youngest = records.find((r) => r.age === minAge);
    const oldest = records.find((r) => r.age === maxAge);

    push('Zeitraum (Kalendertage)', `${dayMin} … ${dayMax}`);
    push('Erster Login (Timestamp)', firstTs);
    push('Letzter Login (Timestamp)', lastTs);
    push('Logins gesamt', records.length);
    push(`Logins heute (${today} UTC)`, dayRecords.length);
    push('Verschiedene Nutzer heute (UTC)', uniqueToday);
    const listToday = namesToday.join(', ');
    push(
      'Nutzer heute (Liste)',
      listToday.length > 500
        ? `${uniqueToday} Nutzer — Auszug: ${namesToday.slice(0, 8).join(', ')} … (vollständig: /stat today)`
        : listToday || '—'
    );
    push('Verschiedene Namen (historisch)', uniqueNames);
    push('Ø Logins pro Namen (historisch)', (records.length / uniqueNames).toFixed(2));
    push('Jüngster Nutzer (erster Treffer im Log)', `${youngest.userName} (${youngest.age})`);
    push('Ältester Nutzer (erster Treffer im Log)', `${oldest.userName} (${oldest.age})`);

    const topGenders = aggregateTop(
      records,
      (r) => (r.gender || '').trim() || '?',
      15
    );
    push('Geschlecht (Häufigkeit)', topGenders.map(([g, n]) => `${g}(${n})`).join(', ') || '—');

    const topCountries = aggregateTop(records, (r) => r.country, 20);
    push('Top 20 Länder', topCountries.map(([c, n]) => `${c}(${n})`).join(', ') || '—');

    const topNames = aggregateTop(records, (r) => r.userName, 20);
    const topNamesDetail = topNames
      .map(([name, count]) => {
        const latestRecord = records
          .filter((r) => r.userName === name)
          .sort((a, b) => b.date - a.date)[0];
        return `${name}(${count}, zuletzt ${latestRecord.timestamp})`;
      })
      .join('; ');
    push(
      'Top 20 Namen (Anzahl, letzter Login)',
      topNamesDetail.length > 1200 ? `${topNamesDetail.slice(0, 1197)}…` : topNamesDetail
    );
    push('Hinweis', 'Tabellen je Tag/Zeitraum: /stat today | /stat date | /stat range');

    return rows;
  }

  function executeStatsCommand(socket, client, parts) {
    if (!hasRight(client, CHAT_RIGHTS.STAT)) {
      sendCommandResult(socket, 'Keine Berechtigung: Recht "stat" fehlt.');
      return;
    }

    const records = readLoginRecords();
    if (records.length === 0) {
      sendCommandResult(socket, 'Keine Login-Daten vorhanden.');
      return;
    }

    const sub = (parts[1] || '').toLowerCase();

    if (!sub || sub === 'help') {
      sendCommandTable(socket, 'Hilfe: Statistik-Befehle', ['Befehl', 'Beschreibung'], [
        ['/stat today', 'Logins des heutigen Tages'],
        ['/stat date YYYY-MM-DD', 'Logins an einem bestimmten Datum'],
        ['/stat range YYYY-MM-DD YYYY-MM-DD', 'Logins pro Tag im Zeitraum'],
        ['/stat ages', 'Jüngster und ältester Nutzer'],
        ['/stat names', 'Häufigkeit der verwendeten Namen'],
        ['/stat countries', 'Häufigkeit der Länder'],
        ['/all-stats', 'Alle Kennzahlen: Live-Server + starts.log + komplette logins.log-Auswertung']
      ]);
      return;
    }

    if (sub === 'today') {
      const day = new Date().toISOString().slice(0, 10);
      const dayRecords = records.filter((r) => r.day === day);
      const latestByUserToday = new Map();
      dayRecords
        .slice()
        .sort((a, b) => b.date - a.date)
        .forEach((record) => {
          if (!latestByUserToday.has(record.userName)) {
            latestByUserToday.set(record.userName, record);
          }
        });
      const uniqueUsersToday = Array.from(latestByUserToday.values())
        .sort((a, b) => a.userName.localeCompare(b.userName, 'de'))
        .map((r) => `${r.userName} (${r.age})`);
      sendCommandTable(socket, 'Statistik: Heute', ['Metrik', 'Wert'], [
        ['Tag', day],
        ['Logins', dayRecords.length],
        ['Heute eingeloggt', uniqueUsersToday.length > 0 ? uniqueUsersToday.join(', ') : '-']
      ]);
      return;
    }

    if (sub === 'date') {
      const day = parts[2];
      if (!day || !/^\d{4}-\d{2}-\d{2}$/.test(day)) {
        sendCommandResult(socket, 'Nutzung: /stat date YYYY-MM-DD');
        return;
      }
      const dayRecords = records.filter((r) => r.day === day);
      sendCommandTable(socket, 'Statistik: Datum', ['Tag', 'Logins'], [[day, dayRecords.length]]);
      return;
    }

    if (sub === 'range') {
      const from = parts[2];
      const to = parts[3];
      if (!from || !to || !/^\d{4}-\d{2}-\d{2}$/.test(from) || !/^\d{4}-\d{2}-\d{2}$/.test(to)) {
        sendCommandResult(socket, 'Nutzung: /stat range YYYY-MM-DD YYYY-MM-DD');
        return;
      }
      const filtered = records.filter((r) => r.day >= from && r.day <= to);
      const perDay = aggregateTop(filtered, (r) => r.day, 1000)
        .sort((a, b) => a[0].localeCompare(b[0]))
        .map(([day, count]) => [day, count]);
      sendCommandTable(socket, `Statistik: Zeitraum ${from} bis ${to}`, ['Tag', 'Logins'], perDay);
      return;
    }

    if (sub === 'ages') {
      const ages = records.map((r) => r.age);
      const minAge = Math.min(...ages);
      const maxAge = Math.max(...ages);
      const youngest = records.find((r) => r.age === minAge);
      const oldest = records.find((r) => r.age === maxAge);
      sendCommandTable(socket, 'Statistik: Alter', ['Kategorie', 'Name', 'Alter'], [
        ['Jüngster Nutzer', youngest.userName, youngest.age],
        ['Ältester Nutzer', oldest.userName, oldest.age]
      ]);
      return;
    }

    if (sub === 'names') {
      const topNames = aggregateTop(records, (r) => r.userName, 20);
      sendCommandTable(
        socket,
        `Statistik: Namen (gesamt verschieden: ${new Set(records.map((r) => r.userName)).size})`,
        ['Name', 'Alter', 'Anzahl', 'Letzter Login'],
        topNames.map(([name, count]) => {
          const latestRecord = records
            .filter((r) => r.userName === name)
            .sort((a, b) => b.date - a.date)[0];
          return [name, latestRecord ? latestRecord.age : '-', count, latestRecord ? latestRecord.timestamp : '-'];
        })
      );
      return;
    }

    if (sub === 'countries') {
      const topCountries = aggregateTop(records, (r) => r.country, 20);
      sendCommandTable(
        socket,
        'Statistik: Länder',
        ['Land', 'Anzahl'],
        topCountries.map(([country, count]) => [country, count])
      );
      return;
    }

    sendCommandResult(socket, 'Unbekannter /stat-Befehl. Nutze /stat help');
  }

  function executeAllStatsCommand(socket, client) {
    if (!hasRight(client, CHAT_RIGHTS.STAT)) {
      sendCommandResult(socket, 'Keine Berechtigung: Recht "stat" fehlt.');
      return;
    }
    const rows = buildFullAllStatsRows(readLoginRecords());
    sendCommandTable(socket, 'Statistik: Vollständige Übersicht (/all-stats)', ['Metrik', 'Wert'], rows);
  }

  function executeKickCommand(socket, client, parts) {
    if (!hasRight(client, CHAT_RIGHTS.KICK)) {
      sendCommandResult(socket, 'Keine Berechtigung: Recht "kick" fehlt.');
      return;
    }

    const targetName = (parts[1] || '').trim();
    if (!targetName) {
      sendCommandResult(socket, 'Nutzung: /kick <username>');
      return;
    }

    let targetSessionId = null;
    let targetClient = null;
    for (const [sid, c] of clients.entries()) {
      if (c.userName === targetName && c.socket && c.socket.connected) {
        targetSessionId = sid;
        targetClient = c;
        break;
      }
    }

    if (!targetClient) {
      sendCommandResult(socket, `User "${targetName}" ist nicht online.`);
      return;
    }

    if (targetClient.socket) {
      targetClient.socket.emit('error', { message: 'Du wurdest vom Chat getrennt (kick).' });
      targetClient.socket.disconnect(true);
    }
    clients.delete(targetSessionId);
    broadcastUserList();
    sendCommandResult(socket, `User "${targetName}" wurde gekickt.`);
  }

  function verifyChatUser(username, password) {
    const users = loadChatUsers(__dirname);
    const user = users.find((u) => u.username.toLowerCase() === username.toLowerCase());
    if (!user) return null;

    const [algo, hash] = user.passwordHash.split(':');
    if (algo !== 'sha256' || !hash) return null;
    const inputHash = sha256(password);
    if (inputHash !== hash) return null;

    return {
      username: user.username,
      rights: new Set(user.rights)
    };
  }

  function executeCommand(socket, client, rawInput) {
    const input = rawInput.trim();

    // Laufender Login-Dialog: Nur Eingaben ohne Slash als Username/Passwort behandeln.
    if (client.pendingChatLogin && !input.startsWith('/')) {
      if (client.pendingChatLogin.step === 'username') {
        const enteredUser = input;
        if (!enteredUser) {
          sendCommandResult(socket, 'Username darf nicht leer sein. Bitte Username eingeben:', 'loginPromptUsername');
          return true;
        }
        client.pendingChatLogin = { step: 'password', username: enteredUser };
        sendCommandResult(socket, 'Passwort eingeben:', 'loginPromptPassword');
        return true;
      }

      if (client.pendingChatLogin.step === 'password') {
        const username = client.pendingChatLogin.username;
        const auth = verifyChatUser(username, input);
        client.pendingChatLogin = null;
        if (!auth) {
          sendCommandResult(socket, 'Login fehlgeschlagen. Benutzername oder Passwort falsch.', 'loginError');
          return true;
        }

        client.chatAuth = auth;
        sendCommandResult(
          socket,
          `Login erfolgreich als ${auth.username}. Rechte: ${Array.from(auth.rights).join(', ') || 'keine'}`,
          'loginSuccess'
        );
        return true;
      }
    } else if (client.pendingChatLogin && input.startsWith('/')) {
      // Ein neuer /Befehl bricht den Login-Vorgang ab.
      client.pendingChatLogin = null;
      sendCommandResult(socket, 'Login-Vorgang abgebrochen.', 'loginAbort');
      // und läuft unten als normaler Befehl weiter
    }

    if (!input.startsWith('/')) return false;

    const parts = input.split(/\s+/);
    const command = parts[0].toLowerCase();

    if (command === '/login') {
      const username = (parts[1] || '').trim();
      if (username) {
        client.pendingChatLogin = { step: 'password', username };
        sendCommandResult(socket, 'Passwort eingeben:', 'loginPromptPassword');
      } else {
        client.pendingChatLogin = { step: 'username', username: '' };
        sendCommandResult(socket, 'Username eingeben:', 'loginPromptUsername');
      }
      return true;
    }

    if (command === '/logout-admin') {
      const wasLoggedIn = !!client.chatAuth;
      client.chatAuth = null;
      client.pendingChatLogin = null;
      sendCommandResult(
        socket,
        wasLoggedIn
          ? 'Admin/Command-Login wurde abgemeldet.'
          : 'Es war kein Admin/Command-Login aktiv.',
        'loginLogout'
      );
      return true;
    }

    if (command === '/whoami-rights') {
      if (!client.chatAuth) {
        sendCommandResult(socket, 'Nicht per Command-Login angemeldet.', 'whoami');
        return true;
      }
      sendCommandResult(socket, [
        `Angemeldet als: ${client.chatAuth.username}`,
        `Rechte: ${Array.from(client.chatAuth.rights).join(', ') || 'keine'}`
      ], 'whoami');
      return true;
    }

    if (command === '/help' || command === '/?') {
      sendCommandTable(socket, 'Hilfe: Verfügbare Befehle', ['Befehl', 'Beschreibung'], [
        ['/login [username]', 'Admin-/Command-Login starten'],
        ['/logout-admin', 'Admin-/Command-Login beenden'],
        ['/whoami-rights', 'Aktuelle Admin-Rechte anzeigen'],
        ['/stat help', 'Hilfe zu Statistikbefehlen anzeigen'],
        ['/all-stats', 'Alle Kennzahlen: Live-Server + starts.log + komplette logins.log-Auswertung'],
        ['/kick <username>', 'Benutzer aus dem Chat werfen'],
        ['/help oder /?', 'Diese Hilfe anzeigen']
      ]);
      return true;
    }

    if (command === '/stat') {
      executeStatsCommand(socket, client, parts);
      return true;
    }

    if (command === '/all-stats') {
      executeAllStatsCommand(socket, client);
      return true;
    }

    if (command === '/kick') {
      executeKickCommand(socket, client, parts);
      return true;
    }

    sendCommandResult(socket, `Unbekannter Befehl: ${command}`, 'unknown');
    return true;
  }

  // Socket.IO-Verbindungshandler
  io.on('connection', (socket) => {
    const request = socket.handshake;
    
    // Versuche Session-ID aus Cookie zu extrahieren
    let sessionId = extractSessionId(request);
    
    console.log('Socket.IO Connect - Session-ID (aus Cookie):', sessionId);
    console.log('Socket.IO Connect - Cookie:', request.headers?.cookie);
    
    // Wenn keine gültige Session-ID gefunden wurde, generiere eine temporäre UUID
    // Diese wird beim Login durch die Express-Session-ID ersetzt (siehe handleLogin)
    if (!sessionId || sessionId.length < 10 || !sessionId.match(/^[a-zA-Z0-9_-]+$/)) {
      sessionId = crypto.randomUUID();
      console.log('Socket.IO Connect - Keine gültige Session-ID gefunden, verwende temporäre UUID:', sessionId);
      socket.data.temporarySessionId = true; // Markiere als temporär
    }
    
    // Speichere Socket-ID mit Session-ID
    socket.data.sessionId = sessionId;
    socketToSessionMap.set(socket.id, sessionId);
    
    let client = clients.get(sessionId);
    if (!client) {
      console.log('Socket.IO Connect - Neuer Client erstellt für Session-ID:', sessionId);
      client = new Client(sessionId);
      clients.set(sessionId, client);
    } else {
      console.log('Socket.IO Connect - Bestehender Client gefunden für Session-ID:', sessionId, 'User:', client.userName);
    }
    
    // Speichere Socket mit Session-ID
    client.socket = socket;
    
    // Bestätigung an Client senden, inklusive Benutzerdaten falls bereits eingeloggt
    const connectedData = { sessionId };
    if (client.userName) {
      connectedData.user = {
        userName: client.userName,
        gender: client.gender,
        age: client.age,
        country: client.country,
        isoCountryCode: client.isoCountryCode
      };
      connectedData.loggedIn = true;
    }
    socket.emit('connected', connectedData);

    socket.on('disconnect', (reason) => {
      const currentSessionId = socket.data.sessionId || sessionId;
      socketToSessionMap.delete(socket.id);
      console.log(`[Disconnect] Socket getrennt für Session-ID: ${currentSessionId}, Grund: ${reason}`);
      const client = clients.get(currentSessionId);
      if (client) {
        console.log(`[Disconnect] Client gefunden: ${client.userName || 'unbekannt'}, Socket war verbunden: ${client.socket ? client.socket.connected : 'null'}`);
        if (client.userName) {
          endAllVideoSessionsForUser(client.userName, 'disconnect', client.userName);
        }
        
        // Setze Socket auf null, damit keine Nachrichten mehr an diesen Client gesendet werden
        // ABER: Lösche den Client NICHT, damit die Session beim Reload wiederhergestellt werden kann
        client.socket = null;
        
        // Aktualisiere Benutzerliste, damit andere Clients sehen, dass dieser Benutzer offline ist
        if (client.userName) {
          console.log(`[Disconnect] Aktualisiere Benutzerliste nach Disconnect von ${client.userName}`);
          broadcastUserList();
        }
        // Client bleibt in der Map, damit Session-Wiederherstellung funktioniert
      } else {
        console.log(`[Disconnect] Kein Client gefunden für Session-ID: ${sessionId}`);
      }
    });

    socket.on('error', (error) => {
      console.error('Socket.IO-Fehler:', error);
    });

    // Socket.IO Event-Handler: Setze Express-Session-ID
    socket.on('setSessionId', (data) => {
      const { expressSessionId } = data;
      if (expressSessionId) {
        console.log('setSessionId - Express-Session-ID erhalten:', expressSessionId);
        const currentSessionId = socket.data.sessionId;
        socketToSessionMap.set(socket.id, expressSessionId);
        
        if (currentSessionId !== expressSessionId) {
          console.log('setSessionId - Aktualisiere Session-ID von', currentSessionId, 'zu', expressSessionId);
          
          // Prüfe, ob bereits ein Client mit dieser Session-ID existiert
          let existingClient = clients.get(expressSessionId);
          
          // Wenn kein Client mit dieser Session-ID gefunden wurde, prüfe ob ein Client mit dem aktuellen Socket existiert
          // und bereits eingeloggt ist (für Session-Wiederherstellung nach Reload)
          if (!existingClient) {
            const currentClient = clients.get(currentSessionId);
            if (currentClient && currentClient.userName) {
              console.log('setSessionId - Client mit Session-ID', currentSessionId, 'ist bereits eingeloggt:', currentClient.userName);
              // Verwende bestehenden Client und aktualisiere nur die Session-ID
              existingClient = currentClient;
              clients.delete(currentSessionId);
              clients.set(expressSessionId, existingClient);
              existingClient.sessionId = expressSessionId;
            } else {
              // Wenn kein Client mit der aktuellen Session-ID gefunden wurde, suche nach einem Client,
              // der bereits eingeloggt ist und keinen aktiven Socket hat (für Session-Wiederherstellung)
              // Dies ist ein Fallback für den Fall, dass die Session-ID beim Reload geändert wurde
              for (const [sid, c] of clients.entries()) {
                if (c.userName && (!c.socket || !c.socket.connected)) {
                  console.log('setSessionId - Gefundener Client ohne aktiven Socket:', sid, c.userName);
                  // Verwende diesen Client und aktualisiere die Session-ID
                  existingClient = c;
                  clients.delete(sid);
                  clients.set(expressSessionId, existingClient);
                  existingClient.sessionId = expressSessionId;
                  break;
                }
              }
            }
          }
          
          if (existingClient) {
            // Verwende bestehenden Client
            console.log('setSessionId - Verwende bestehenden Client, User:', existingClient.userName || 'nicht eingeloggt');
            existingClient.socket = socket;
            socket.data.sessionId = expressSessionId;
            
            // Entferne alten Client, falls unterschiedlich
            if (currentSessionId !== expressSessionId && clients.has(currentSessionId)) {
              clients.delete(currentSessionId);
            }
            
            // Sende Login-Status zurück, falls bereits eingeloggt
            if (existingClient.userName) {
              console.log('setSessionId - Sende Login-Status zurück für User:', existingClient.userName);
              socket.emit('connected', {
                sessionId: expressSessionId,
                loggedIn: true,
                user: existingClient.toJSON()
              });
              emitVideoCapacityToUser(existingClient.userName);
              
              // Aktualisiere Userliste für alle Clients, damit der wiederhergestellte Client die Liste erhält
              broadcastUserList();
            }
          } else {
            // Erstelle neuen Client mit Express-Session-ID
            console.log('setSessionId - Erstelle neuen Client');
            const newClient = new Client(expressSessionId);
            newClient.socket = socket;
            clients.set(expressSessionId, newClient);
            socket.data.sessionId = expressSessionId;
            
            // Entferne alten Client
            if (clients.has(currentSessionId)) {
              clients.delete(currentSessionId);
            }
          }
        }
      }
    });

    // Socket.IO Event-Handler
    // WICHTIG: Hole den Client immer dynamisch basierend auf socket.data.sessionId,
    // da sich die Session-ID nach setSessionId ändern kann
    socket.on('login', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        await handleLogin(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der Login-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('message', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleMessage(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der Message-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('requestConversation', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleRequestConversation(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der RequestConversation-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('userSearch', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleUserSearch(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der UserSearch-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('requestHistory', async () => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleRequestHistory(socket, currentClient);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der RequestHistory-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('requestOpenConversations', async () => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleRequestOpenConversations(socket, currentClient);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der RequestOpenConversations-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('blockUser', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleBlockUser(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der BlockUser-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('unblockUser', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleUnblockUser(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten der UnblockUser-Nachricht:', error);
        socket.emit('error', { message: error.message });
      }
    });

    socket.on('videoConsent:set', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoConsentSet(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoConsent:set:', error);
        sendVideoCallError(socket, 'VIDEO_CONSENT_SET_FAILED', error.message);
      }
    });

    socket.on('videoCall:invite', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallInvite(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:invite:', error);
        sendVideoCallError(socket, 'VIDEO_INVITE_FAILED', error.message);
      }
    });

    socket.on('videoCall:accept', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallAccept(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:accept:', error);
        sendVideoCallError(socket, 'VIDEO_ACCEPT_FAILED', error.message);
      }
    });

    socket.on('videoCall:reject', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallReject(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:reject:', error);
        sendVideoCallError(socket, 'VIDEO_REJECT_FAILED', error.message);
      }
    });

    socket.on('videoCall:cancel', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallCancel(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:cancel:', error);
        sendVideoCallError(socket, 'VIDEO_CANCEL_FAILED', error.message);
      }
    });

    socket.on('videoCall:end', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallEnd(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:end:', error);
        sendVideoCallError(socket, 'VIDEO_END_FAILED', error.message);
      }
    });

    socket.on('videoCall:muteState', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallMuteState(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:muteState:', error);
        sendVideoCallError(socket, 'VIDEO_MUTE_STATE_FAILED', error.message);
      }
    });

    socket.on('videoCall:signal', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallSignal(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:signal:', error);
        sendVideoCallError(socket, 'VIDEO_SIGNAL_FAILED', error.message);
      }
    });

    socket.on('videoCall:connectionState', async (data) => {
      try {
        const currentClient = clients.get(socket.data.sessionId);
        if (!currentClient) {
          socket.emit('error', { message: 'Client nicht gefunden' });
          return;
        }
        currentClient.setActivity();
        handleVideoCallConnectionState(socket, currentClient, data);
      } catch (error) {
        console.error('Fehler beim Verarbeiten von videoCall:connectionState:', error);
        sendVideoCallError(socket, 'VIDEO_CONNECTION_STATE_FAILED', error.message);
      }
    });

  });

  async function handleLogin(socket, client, data) {
    const { userName, gender, age, country, expressSessionId } = data;
    
    // Validierung
    if (!userName || userName.trim().length < 3) {
      socket.emit('error', { message: 'Benutzername muss mindestens 3 Zeichen lang sein' });
      return;
    }
    
    // Wenn eine Express-Session-ID übergeben wurde, verwende diese statt der Socket-ID
    if (expressSessionId) {
      console.log('handleLogin - Express-Session-ID erhalten:', expressSessionId);
      
      // Entferne alten Client mit temporärer Socket-ID, falls vorhanden
      const oldSessionId = socket.data.sessionId;
      if (oldSessionId && oldSessionId !== expressSessionId && clients.has(oldSessionId)) {
        console.log('handleLogin - Entferne alten Client mit Session-ID:', oldSessionId);
        clients.delete(oldSessionId);
      }
      
      // Prüfe, ob bereits ein Client mit dieser Session-ID existiert
      let existingClient = clients.get(expressSessionId);
      if (existingClient) {
        // Verwende bestehenden Client
        console.log('handleLogin - Verwende bestehenden Client mit Session-ID:', expressSessionId);
        client = existingClient;
        // Aktualisiere Socket-Verbindung
        client.socket = socket;
        socket.data.sessionId = expressSessionId;
      } else {
        // Erstelle neuen Client mit Express-Session-ID
        console.log('handleLogin - Erstelle neuen Client mit Session-ID:', expressSessionId);
        client = new Client(expressSessionId);
        clients.set(expressSessionId, client);
        client.socket = socket;
        socket.data.sessionId = expressSessionId;
      }
    } else {
      console.log('handleLogin - Keine Express-Session-ID erhalten, verwende Socket-ID');
    }
    
    // Prüfe, ob Name bereits verwendet wird
    for (const [sid, c] of clients.entries()) {
      if (c.userName === userName && sid !== client.sessionId) {
        socket.emit('error', { message: 'Dieser Benutzername ist bereits vergeben' });
        return;
      }
    }
    
    client.userName = userName.trim();
    client.gender = gender;
    client.age = age;
    client.country = country;
    
    // ISO-Code aus Länderliste ermitteln
    client.isoCountryCode = countriesMap[country] || 'unknown';
    
    client.loginTimeStamp = new Date();
    client.setActivity();
    
    // Stelle sicher, dass der Socket gesetzt ist
    if (!client.socket) {
      console.log('handleLogin - WARNUNG: Socket nicht gesetzt, setze ihn jetzt');
      client.socket = socket;
    }
    
    console.log('handleLogin - Client nach Login:', {
      sessionId: client.sessionId,
      userName: client.userName,
      hasSocket: !!client.socket,
      socketConnected: client.socket ? client.socket.connected : false
    });
    
    logClientLogin(client, __dirname);
    checkAndLogStart(__dirname);
    
    // Benutzerliste an alle senden
    broadcastUserList();
    
    // Aktualisiere ungelesene Nachrichten für den neuen Benutzer
    updateUnreadCount(client);
    
    console.log('handleLogin - Sende loginSuccess an Socket');
    socket.emit('loginSuccess', { 
      sessionId: client.sessionId,
      user: client.toJSON()
    });
    emitVideoCapacityToUser(client.userName);
  }

  function handleMessage(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const { toUserName, message, messageId, isImage, imageType, imageUrl } = data;

    // Chat-Befehle werden direkt serverseitig verarbeitet
    if (!isImage && typeof message === 'string' && executeCommand(socket, client, message)) {
      return;
    }
    
    if (!toUserName) {
      socket.emit('error', { message: 'Empfänger fehlt' });
      return;
    }
    
    // Finde Empfänger
    let receiver = null;
    for (const [sid, c] of clients.entries()) {
      if (c.userName === toUserName) {
        receiver = c;
        break;
      }
    }
    
    if (!receiver) {
      socket.emit('error', { message: 'Benutzer nicht gefunden' });
      return;
    }
    
    // Prüfe, ob Empfänger noch verbunden ist
    if (!receiver.socket || !receiver.socket.connected) {
      // Empfänger ist nicht mehr verbunden, entferne ihn aus der Liste
      clients.delete(receiver.sessionId);
      broadcastUserList();
      socket.emit('error', { message: 'Benutzer nicht gefunden' });
      return;
    }
    
    // Prüfe Blockierung
    if (receiver.blockedUsers.has(client.userName)) {
      socket.emit('error', { message: 'Du wurdest von diesem Benutzer blockiert' });
      return;
    }
    
    // Speichere Nachricht in Konversation
    const convKey = getConversationKey(client.userName, toUserName);
    if (!conversations.has(convKey)) {
      conversations.set(convKey, []);
    }
    
    const conversation = conversations.get(convKey);
    conversation.push({
      from: client.userName,
      to: toUserName,
      message: isImage && imageUrl ? imageUrl : message, // Verwende URL für Bilder
      messageId,
      timestamp: new Date().toISOString(),
      read: false,
      isImage: isImage || false,
      imageType: imageType || null,
      imageUrl: imageUrl || null,
      imageCode: isImage ? message : null
    });
    
    // Sende an Empfänger (wenn online)
    const messagePayload = {
      from: client.userName,
      message: isImage && imageUrl ? imageUrl : message, // Verwende URL für Bilder
      messageId,
      timestamp: new Date().toISOString(),
      isImage: isImage || false,
      imageType: imageType || null,
      imageUrl: imageUrl || null,
      imageCode: isImage ? message : null // Code für Server-Referenz
    };
    
    // Debug-Logging für Bilder
    if (isImage) {
      console.log(`[Bild] Sende Bild von ${client.userName} an ${toUserName}, Größe: ${message ? message.length : 0} Zeichen, Typ: ${imageType || 'unbekannt'}`);
      console.log(`[Bild] Absender Socket verbunden: ${socket.connected}, Empfänger Socket verbunden: ${receiver.socket ? receiver.socket.connected : 'null'}`);
    }
    
    // Prüfe, ob Absender noch verbunden ist
    if (!socket.connected) {
      console.error(`[Bild] Absender ${client.userName} Socket nicht mehr verbunden beim Senden!`);
      return;
    }
    
    // Prüfe, ob Empfänger-Socket noch existiert und verbunden ist
    if (!receiver.socket || !receiver.socket.connected) {
      console.error(`[Bild] Empfänger ${toUserName} Socket nicht mehr verbunden beim Senden!`);
      socket.emit('error', { message: 'Empfänger ist nicht mehr online' });
      return;
    }
    
    try {
      receiver.socket.emit('message', messagePayload);
      
      // Bestätigung an Absender (nur wenn noch verbunden)
      if (socket.connected) {
        socket.emit('messageSent', { 
          messageId,
          to: toUserName
        });
      }
    } catch (error) {
      console.error(`[Bild] Fehler beim Senden der Nachricht:`, error);
      if (socket.connected) {
        socket.emit('error', { message: 'Fehler beim Senden der Nachricht' });
      }
    }
    
    // Aktualisiere ungelesene Nachrichten für den Empfänger
    updateUnreadCount(receiver);
  }

  function handleRequestConversation(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const { withUserName } = data;
    const convKey = getConversationKey(client.userName, withUserName);
    const conversation = conversations.get(convKey) || [];
    
    // Markiere alle Nachrichten von diesem Benutzer als gelesen
    for (const msg of conversation) {
      if (msg.to === client.userName && msg.from === withUserName) {
        msg.read = true;
      }
    }
    
    // Aktualisiere ungelesene Nachrichten nach dem Markieren als gelesen
    updateUnreadCount(client);
    
    socket.emit('conversation', {
      with: withUserName,
      messages: conversation.map(msg => ({
        from: msg.from,
        message: msg.message,
        timestamp: msg.timestamp,
        isImage: msg.isImage || false,
        imageType: msg.imageType || null
      }))
    });
    emitVideoConsentStateToUser(client.userName, withUserName);

    const session = findActiveVideoSessionBetween(client.userName, withUserName);
    if (session) {
      socket.emit('videoCall:update', buildVideoCallPayloadForUser(session, client.userName));
    }
  }

  function handleVideoConsentSet(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }

    const withUserName = String(data?.withUserName || '').trim();
    const allowed = !!data?.allowed;

    if (!withUserName || withUserName === client.userName) {
      sendVideoCallError(socket, 'VIDEO_INVALID_PARTNER', 'Ungültiger Gesprächspartner.');
      return;
    }

    const state = getOrCreateVideoConversation(client.userName, withUserName);
    state.consents[client.userName] = allowed;

    if (!allowed) {
      endVideoSessionsForPair(client.userName, withUserName, 'consent_revoked', client.userName);
    }

    emitVideoConsentStateToParticipants(client.userName, withUserName);
  }

  function assertCanUseVideoWith(socket, client, targetUserName) {
    if (!client.userName) {
      sendVideoCallError(socket, 'VIDEO_NOT_LOGGED_IN', 'Nicht eingeloggt.');
      return null;
    }

    const targetClient = getClientByUserName(targetUserName);
    if (!targetClient || !targetClient.userName) {
      sendVideoCallError(socket, 'VIDEO_PARTNER_NOT_FOUND', 'Gesprächspartner nicht gefunden.', { withUserName: targetUserName });
      return null;
    }

    if (!isClientOnline(targetClient)) {
      sendVideoCallError(socket, 'VIDEO_PARTNER_OFFLINE', 'Gesprächspartner ist nicht online.', { withUserName: targetUserName });
      return null;
    }

    if (targetClient.blockedUsers.has(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_BLOCKED_BY_PARTNER', 'Du wurdest von diesem Benutzer blockiert.', { withUserName: targetUserName });
      return null;
    }

    if (client.blockedUsers.has(targetUserName)) {
      sendVideoCallError(socket, 'VIDEO_PARTNER_BLOCKED', 'Du hast diesen Benutzer blockiert.', { withUserName: targetUserName });
      return null;
    }

    const state = getOrCreateVideoConversation(client.userName, targetUserName);
    if (!state.consents[client.userName] || !state.consents[targetUserName]) {
      sendVideoCallError(socket, 'VIDEO_CONSENT_REQUIRED', 'Videochat ist erst nach beidseitiger Freigabe sichtbar.', { withUserName: targetUserName });
      return null;
    }

    return { targetClient, state };
  }

  function handleVideoCallInvite(socket, client, data) {
    const withUserName = String(data?.withUserName || '').trim();
    if (!withUserName || withUserName === client.userName) {
      sendVideoCallError(socket, 'VIDEO_INVALID_PARTNER', 'Ungültiger Gesprächspartner.');
      return;
    }

    if (!VIDEO_MEDIA_RELAY_CONFIGURED) {
      sendVideoCallError(socket, 'VIDEO_MEDIA_NOT_CONFIGURED', 'Video-Medienserver ist derzeit nicht konfiguriert.');
      return;
    }

    const check = assertCanUseVideoWith(socket, client, withUserName);
    if (!check) return;

    if (!hasVideoCapacity(client.userName)) {
      emitVideoCapacityToUser(client.userName);
      sendVideoCallError(socket, 'VIDEO_CAPACITY_REACHED', 'Maximal drei Videoverbindungen gleichzeitig erlaubt.', {
        withUserName,
        activeConnections: getActiveVideoSessionsForUser(client.userName).length,
        maxConnections: MAX_ACTIVE_VIDEO_CONNECTIONS
      });
      return;
    }

    if (!hasVideoCapacity(withUserName)) {
      emitVideoCapacityToUser(withUserName);
      sendVideoCallError(socket, 'VIDEO_PARTNER_CAPACITY_REACHED', 'Der Gesprächspartner hat bereits die maximale Anzahl an Videoverbindungen erreicht.', {
        withUserName
      });
      return;
    }

    const existingSession = findActiveVideoSessionBetween(client.userName, withUserName);
    if (existingSession) {
      sendVideoCallError(socket, 'VIDEO_CALL_ALREADY_EXISTS', 'Für diesen Gesprächspartner existiert bereits ein laufender Videochat.', {
        withUserName,
        callId: existingSession.callId
      });
      return;
    }

    const session = createVideoSession(client.userName, withUserName);
    registerVideoSession(session);

    emitVideoCallEventToUser(client.userName, 'videoCall:invite', session);
    emitVideoCallEventToUser(withUserName, 'videoCall:incoming', session);
    emitVideoCapacityToUser(client.userName);
    emitVideoCapacityToUser(withUserName);
  }

  function handleVideoCallAccept(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const session = videoSessions.get(callId);

    if (!session || session.status !== 'ringing' || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    if (session.initiatedBy === client.userName) {
      sendVideoCallError(socket, 'VIDEO_CALL_INVALID_ACCEPT', 'Der Anrufer kann den eigenen Anruf nicht annehmen.', { callId });
      return;
    }

    if (!VIDEO_MEDIA_RELAY_CONFIGURED) {
      sendVideoCallError(socket, 'VIDEO_MEDIA_NOT_CONFIGURED', 'Video-Medienserver ist derzeit nicht konfiguriert.', { callId });
      return;
    }

    const otherUserName = getOtherParticipant(session, client.userName);
    const check = assertCanUseVideoWith(socket, client, otherUserName);
    if (!check) {
      touchVideoSession(session, 'failed', 'preconditions_failed');
      emitVideoCallEventToUser(session.participants[0], 'videoCall:end', session);
      emitVideoCallEventToUser(session.participants[1], 'videoCall:end', session);
      finalizeVideoSession(session);
      emitVideoCapacityToUser(session.participants[0]);
      emitVideoCapacityToUser(session.participants[1]);
      return;
    }

    touchVideoSession(session, 'connecting');
    emitVideoCallEventToUser(session.participants[0], 'videoCall:start', session);
    emitVideoCallEventToUser(session.participants[1], 'videoCall:start', session);
    emitVideoCapacityToUser(session.participants[0]);
    emitVideoCapacityToUser(session.participants[1]);
  }

  function handleVideoCallReject(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    if (session.status !== 'ringing' || session.initiatedBy === client.userName) {
      sendVideoCallError(socket, 'VIDEO_CALL_INVALID_REJECT', 'Nur der Angerufene kann einen klingelnden Anruf ablehnen.', { callId });
      return;
    }

    touchVideoSession(session, 'rejected', 'rejected');
    emitVideoCallEventToUser(session.participants[0], 'videoCall:reject', session);
    emitVideoCallEventToUser(session.participants[1], 'videoCall:reject', session);
    finalizeVideoSession(session);
    emitVideoCapacityToUser(session.participants[0]);
    emitVideoCapacityToUser(session.participants[1]);
  }

  function handleVideoCallCancel(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    if (session.status !== 'ringing') {
      sendVideoCallError(socket, 'VIDEO_CALL_INVALID_CANCEL', 'Nur klingelnde Anrufe können abgebrochen werden.', { callId });
      return;
    }

    if (session.initiatedBy !== client.userName) {
      sendVideoCallError(socket, 'VIDEO_CALL_INVALID_CANCEL', 'Nur der Anrufer kann einen klingelnden Anruf abbrechen.', { callId });
      return;
    }

    touchVideoSession(session, 'cancelled', 'cancelled');
    emitVideoCallEventToUser(session.participants[0], 'videoCall:cancel', session);
    emitVideoCallEventToUser(session.participants[1], 'videoCall:cancel', session);
    finalizeVideoSession(session);
    emitVideoCapacityToUser(session.participants[0]);
    emitVideoCapacityToUser(session.participants[1]);
  }

  function handleVideoCallEnd(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    endVideoSession(session, 'ended', client.userName);
  }

  function handleVideoCallMuteState(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const muted = !!data?.muted;
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    session.muteStates = session.muteStates || {};
    session.muteStates[client.userName] = muted;
    session.updatedAt = new Date().toISOString();

    emitVideoCallEventToUser(session.participants[0], 'videoCall:muteState', session);
    emitVideoCallEventToUser(session.participants[1], 'videoCall:muteState', session);
  }

  function handleVideoCallSignal(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const signalType = String(data?.signalType || '').trim();
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    const otherUserName = getOtherParticipant(session, client.userName);
    const targetClient = getClientByUserName(otherUserName);
    if (!isClientOnline(targetClient)) {
      endVideoSession(session, 'partner_disconnected', client.userName);
      return;
    }

    if (signalType === 'description') {
      const description = data?.description;
      const descriptionType = String(description?.type || '').trim();
      const sdp = String(description?.sdp || '').trim();
      if (!descriptionType || !sdp || !['offer', 'answer'].includes(descriptionType)) {
        sendVideoCallError(socket, 'VIDEO_SIGNAL_INVALID_DESCRIPTION', 'Ungültige Video-Signalisierung.', { callId });
        return;
      }

      targetClient.socket.emit('videoCall:signal', buildVideoSignalPayload(callId, client.userName, signalType, {
        description: {
          type: descriptionType,
          sdp
        }
      }));
      return;
    }

    if (signalType === 'candidate') {
      const candidate = data?.candidate;
      if (!isRelayIceCandidate(candidate)) {
        sendVideoCallError(socket, 'VIDEO_SIGNAL_NON_RELAY_CANDIDATE', 'Nur Relay-Kandidaten sind für Videochat erlaubt.', { callId });
        return;
      }
      targetClient.socket.emit('videoCall:signal', buildVideoSignalPayload(callId, client.userName, signalType, { candidate }));
      return;
    }

    sendVideoCallError(socket, 'VIDEO_SIGNAL_UNSUPPORTED', 'Nicht unterstütztes Video-Signalisierungsformat.', { callId });
  }

  function handleVideoCallConnectionState(socket, client, data) {
    const callId = String(data?.callId || '').trim();
    const nextState = String(data?.connectionState || '').trim().toLowerCase();
    const session = videoSessions.get(callId);

    if (!session || !ACTIVE_VIDEO_SESSION_STATUSES.has(session.status) || !session.participants.includes(client.userName)) {
      sendVideoCallError(socket, 'VIDEO_CALL_NOT_FOUND', 'Videoanruf nicht gefunden.', { callId });
      return;
    }

    if (!VIDEO_CONNECTION_STATES.has(nextState)) {
      sendVideoCallError(socket, 'VIDEO_CONNECTION_STATE_INVALID', 'Ungültiger Video-Verbindungsstatus.', { callId });
      return;
    }

    session.connectionStates = session.connectionStates || {};
    session.connectionStates[client.userName] = nextState;
    session.updatedAt = new Date().toISOString();

    if (nextState === 'failed' || nextState === 'closed') {
      endVideoSession(session, 'media_connection_failed', client.userName);
      return;
    }

    if (
      session.status === 'connecting' &&
      session.participants.every((participant) => session.connectionStates[participant] === 'connected')
    ) {
      touchVideoSession(session, 'active');
    }

    emitVideoCallUpdateToParticipants(session);
  }

  function handleUserSearch(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const { nameIncludes, minAge, maxAge, countries, genders } = data;
    
    const results = [];
    for (const [sid, c] of clients.entries()) {
      if (!c.userName || c.userName === client.userName) continue;
      
      // Name-Filter
      if (nameIncludes && !c.userName.toLowerCase().includes(nameIncludes.toLowerCase())) {
        continue;
      }
      
      // Alter-Filter
      if (minAge && c.age < minAge) continue;
      if (maxAge && c.age > maxAge) continue;
      
      // Länder-Filter
      if (countries && countries.length > 0 && !countries.includes(c.country)) {
        continue;
      }
      
      // Geschlecht-Filter
      if (genders && genders.length > 0 && !genders.includes(c.gender)) {
        continue;
      }
      
      results.push(c.toJSON());
    }
    
    socket.emit('searchResults', {
      results
    });
  }

  function handleRequestHistory(socket, client) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const history = [];
    for (const [convKey, messages] of conversations.entries()) {
      const [user1, user2] = convKey.split(':');
      if (user1 === client.userName || user2 === client.userName) {
        const otherUser = user1 === client.userName ? user2 : user1;
        history.push({
          userName: otherUser,
          lastMessage: messages.length > 0 ? messages[messages.length - 1] : null
        });
      }
    }
    
    socket.emit('historyResults', {
      results: history
    });
  }

  function handleRequestOpenConversations(socket, client) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const inbox = [];
    for (const [convKey, messages] of conversations.entries()) {
      const [user1, user2] = convKey.split(':');
      if (user1 === client.userName || user2 === client.userName) {
        const otherUser = user1 === client.userName ? user2 : user1;
        const unreadCount = messages.filter(m => 
          m.to === client.userName && !m.read
        ).length;
        
        if (unreadCount > 0) {
          inbox.push({
            userName: otherUser,
            unreadCount
          });
        }
      }
    }
    
    socket.emit('inboxResults', {
      results: inbox
    });
  }

  function handleBlockUser(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const { userName } = data;
    client.blockedUsers.add(userName);
    getOrCreateVideoConversation(client.userName, userName).consents[client.userName] = false;
    endVideoSessionsForPair(client.userName, userName, 'blocked', client.userName);
    emitVideoConsentStateToParticipants(client.userName, userName);
    
    socket.emit('userBlocked', {
      userName
    });
  }

  function handleUnblockUser(socket, client, data) {
    if (!client.userName) {
      socket.emit('error', { message: 'Nicht eingeloggt' });
      return;
    }
    
    const { userName } = data;
    client.blockedUsers.delete(userName);
    emitVideoConsentStateToParticipants(client.userName, userName);
    
    socket.emit('userUnblocked', {
      userName
    });
  }

  function updateUnreadCount(client) {
    if (!client.userName || !client.socket || !client.socket.connected) {
      return;
    }
    
    // Zähle Personen mit ungelesenen Nachrichten für diesen Benutzer
    let unreadPersons = 0;
    for (const [convKey, messages] of conversations.entries()) {
      const [user1, user2] = convKey.split(':');
      if (user1 === client.userName || user2 === client.userName) {
        const unreadCount = messages.filter(m => 
          m.to === client.userName && !m.read
        ).length;
        if (unreadCount > 0) {
          unreadPersons++;
        }
      }
    }
    
    // Sende Update an Client
    client.socket.emit('unreadChats', {
      count: unreadPersons
    });
  }

  function broadcastUserList() {
    // Filtere nur eingeloggte Benutzer mit aktiver Verbindung
    const userList = Array.from(clients.values())
      .filter(c => {
        const hasUserName = !!c.userName;
        const hasSocket = !!c.socket;
        const isConnected = c.socket && c.socket.connected;
        if (hasUserName && (!hasSocket || !isConnected)) {
          console.log('broadcastUserList - Client ohne Socket oder nicht verbunden:', c.userName, 'socket:', hasSocket, 'connected:', isConnected);
        }
        return hasUserName && hasSocket && isConnected;
      })
      .map(c => c.toJSON());
    
    console.log('broadcastUserList - Sende Userliste mit', userList.length, 'Benutzern:', userList.map(u => u.userName));
    
    // Sende an alle verbundenen Clients
    io.emit('userList', {
      users: userList
    });
  }

  function broadcastToUser(userName, data) {
    // Finde den Client mit diesem Benutzernamen und sende die Nachricht
    for (const [sid, c] of clients.entries()) {
      if (c.userName === userName && c.socket) {
        c.socket.emit(data.type, data);
        return;
      }
    }
  }

  // Timeout-Check alle 60 Sekunden
  setInterval(() => {
    for (const [sid, client] of clients.entries()) {
      if (client.activitiesTimedOut()) {
        console.log(`Client ${client.userName} hat Timeout erreicht`);
        if (client.userName) {
          endAllVideoSessionsForUser(client.userName, 'timeout', client.userName);
        }
        if (client.socket?.id) {
          socketToSessionMap.delete(client.socket.id);
        }
        clients.delete(sid);
        broadcastUserList();
      }
    }
  }, 60000);
}