A!leys Galerie

#!/usr/bin/env python3
"""
GlowChat - Retrowave Socket Chat Server
Unterhaltsamer Chat-Server mit retro-aesthetischem Design und unerwarteten Effekten
"""
import socket
import threading
import time
import random
from typing import Dict, List, Tuple
import colorama
from colorama import Fore, Back, Style, init

# Retrowave Farbpalette (C64 + Synthwave)
COLORS = {
    "cyan": Fore.CYAN,
    "magenta": Fore.MAGENTA,
    "yellow": Fore.YELLOW,
    "blue": Fore.BLUE,
    "green": Fore.GREEN,
    "white": Fore.WHITE,
    "black": Back.BLACK,
}

# Animatierte Effekte
EFFECTS = [
    ("scanlines", lambda text: text + "\n" * random.randint(0, 2)),
    ("glitch", lambda text: text.replace("l", "l‚").replace("i", "i‚")),
    ("lightscan", lambda text: text + "\n" + "=" * random.randint(10, 20)),
]

# Retourne einen zufälligen Farb-Effekt
def get_random_effect() -> Tuple[str, callable]:
    effect = random.choice(list(EFFECTS))
    return effect[0], effect[1]

# Chat Server mit Retrowave-Styling
class RetrowaveServer:
    def __init__(self, host: str = "0.0.0.0", port: int = 5555):
        self.host = host
        self.port = port
        self.clients: Dict[threading.Thread, socket.socket] = {}
        self.messages: List[Tuple[str, str]] = []
        self.running = False
        self.server_socket: socket.socket

    def start(self) -> None:
        """Startet den Server und hört auf eingehende Verbindungen"""
        self.running = True
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.bind((self.host, self.port))
        self.server_socket.listen(5)
        print(f"{COLORS['cyan']}Server gestartet: {COLORS['yellow']}{self.host}:{COLORS['cyan']}{self.port}")

        while self.running:
            try:
                client_socket, addr = self.server_socket.accept()
                print(f"{COLORS['green']}Neue Verbindung: {COLORS['white']}{addr[0]}:{addr[1]}")
                client_thread = threading.Thread(
                    target=self.handle_client,
                    args=(client_socket, addr),
                    daemon=True
                )
                client_thread.start()
                self.clients[client_thread] = client_socket
            except OSError:
                break

    def handle_client(self, client_socket: socket.socket, addr: Tuple[str, int]) -> None:
        """Behandelt Nachrichten von einem Client mit Retrowave-Effekten"""
        with client_socket:
            while self.running:
                try:
                    data = client_socket.recv(1024).decode("utf-8")
                    if not data:
                        break

                    # Wende zufälligen Retrowave-Effekt an
                    effect_name, effect_func = get_random_effect()
                    colored_data = f"{random.choice(list(COLORS.values()))}{data}{Style.RESET_ALL}"

                    # Speichere Nachricht mit Client-Info
                    self.messages.append((f"{addr[0]}:{addr[1]}", colored_data))

                    # Broadcaste die Nachricht an alle Clients
                    broadcast_message = f"[{addr[0]}:{addr[1]}] {effect_func(colored_data)}"
                    for thread, sock in list(self.clients.items()):
                        if sock != client_socket and self.running:
                            sock.sendall(broadcast_message.encode("utf-8"))

                except (ConnectionResetError, OSError):
                    break

    def stop(self) -> None:
        """Beendet den Server und alle Client-Verbindungen"""
        self.running = False
        for sock in self.clients.values():
            sock.close()
        self.server_socket.close()
        print(f"{COLORS['magenta']}Server geschlossen{Style.RESET_ALL}")

def main() -> None:
    # Initialisiere Colorama mit Retrowave-Farben
    init(autoreset=True)
    print(f"{COLORS['cyan']}GLOWCHAT - Retrowave Chat Server{Style.RESET_ALL}")
    print(f"{COLORS['white']}Verbindung closes sich automatisch, wenn du 3 Sekunden kein Text schreibst{Style.RESET_ALL}")

    # Starte den Server in einem separaten Thread
    server = RetrowaveServer()
    server_thread = threading.Thread(target=server.start, daemon=True)
    server_thread.start()

    # Warte 10 Sekunden oder bis der Nutzer abortiert
    try:
        time.sleep(10)
    except KeyboardInterrupt:
        server.stop()
        print(f"{COLORS['yellow']}Sch exotic.{Style.RESET_ALL}")

if __name__ == "__main__":
    main()