server.py

import os
from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect, status, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import json
import uvicorn
from typing import Dict, Set, Optional, Any
import logging

# Logging konfigurieren
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(title="EFT Group Map API")

# CORS optimiert
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # In Produktion spezifische Origins verwenden
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")

# Caching für Maps-Daten
maps_data = {}
try:
    with open("data.json", "r", encoding="utf8") as file:
        maps_data = json.load(file)
except FileNotFoundError:
    logger.error("data.json nicht gefunden")
    maps_data = {}


@app.get("/", response_class=FileResponse)  # <-- Geändert: FileResponse
async def read_index(request: Request):
    return templates.TemplateResponse("map.html", {"request": request, "maps": maps_data})


@app.get("/map/{normalized_name}", response_class=FileResponse)  # <-- Geändert: FileResponse
async def get_map_by_normalized_name(request: Request, normalized_name: str):
    map_entry = maps_data.get(normalized_name)
    filtered_maps = [map_entry] if map_entry else []
    return templates.TemplateResponse("map.html", {"request": request, "maps": filtered_maps})


# Neuer API-Endpunkt für Map-Daten
@app.get("/api/map/{map_name}")
async def get_map_data(map_name: str):
    """API-Endpunkt zum Abrufen von Kartendaten"""
    map_entry = maps_data.get(map_name)
    if not map_entry:
        raise HTTPException(status_code=404, detail="Map not found")
    return JSONResponse(content=map_entry)


class ConnectionManager:
    def __init__(self):
        self.groups: Dict[str, Set[WebSocket]] = {}
        self.connections: Dict[WebSocket, str] = {}
        self.client_types: Dict[WebSocket, str] = {}  # Neue Speicherung für Client-Typen
        self.message_stats = {"total_sent": 0, "total_received": 0}
        self.group_leaders: Dict[str, WebSocket] = {}  # Speichert den ersten Client jeder Gruppe

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        logger.info(f"Neue WebSocket-Verbindung: {websocket.client}")

    def disconnect(self, websocket: WebSocket):
        if websocket in self.connections:
            group_name = self.connections[websocket]
            self.remove_from_group(websocket, group_name)
            logger.info(f"Client disconnected from group '{group_name}'")

    async def join_group(self, websocket: WebSocket, group_name: str, client_type: str = "web"):
        """
        Client einer Gruppe hinzufügen

        Args:
            websocket: WebSocket-Verbindung
            group_name: Name der Gruppe
            client_type: Typ des Clients ("monitor" oder "web")
        """
        # Remove from previous group if exists
        if websocket in self.connections:
            old_group = self.connections[websocket]
            self.remove_from_group(websocket, old_group)

        # Add to new group
        if group_name not in self.groups:
            self.groups[group_name] = set()
            self.group_leaders[group_name] = websocket  # Erster Client ist der Gruppenleiter
            logger.info(f"Neue Gruppe '{group_name}' erstellt von {client_type}-Client")

        self.groups[group_name].add(websocket)
        self.connections[websocket] = group_name
        self.client_types[websocket] = client_type  # Speichere den Client-Typ

        # Prüfe ob dies der erste Client in der Gruppe ist
        is_first_client = self.group_leaders.get(group_name) == websocket
        client_info = {
            "type": "joined",
            "group": group_name,
            "client_type": client_type,
            "is_first": is_first_client,
            "message": f"Erfolgreich Gruppe '{group_name}' beigetreten als {client_type}-Client",
        }

        logger.info(f"Client ({client_type}) joined group '{group_name}' (First: {is_first_client})")
        return client_info

    def remove_from_group(self, websocket: WebSocket, group_name: str):
        if group_name in self.groups and websocket in self.groups[group_name]:
            self.groups[group_name].remove(websocket)
            # Wenn der Gruppenleiter sich trennt, wähle einen neuen
            if self.group_leaders.get(group_name) == websocket and self.groups[group_name]:
                # Wähle den nächsten Client als neuen Leiter
                self.group_leaders[group_name] = next(iter(self.groups[group_name]))
                logger.info(f"Neuer Gruppenleiter für '{group_name}' gewählt")
            elif not self.groups[group_name]:  # Leere Gruppen entfernen
                del self.groups[group_name]
                if group_name in self.group_leaders:
                    del self.group_leaders[group_name]
                logger.info(f"Group '{group_name}' deleted (no members)")

        if websocket in self.connections:
            del self.connections[websocket]
        if websocket in self.client_types:
            del self.client_types[websocket]

    async def broadcast_to_group(self, message: str, group_name: str, exclude: Optional[WebSocket] = None):
        if group_name in self.groups:
            disconnected = set()
            for connection in self.groups[group_name].copy():  # Kopie für sichere Iteration
                # Optional: Nachricht an bestimmten Client ausschließen
                if connection == exclude:
                    continue

                try:
                    await connection.send_text(message)
                    self.message_stats["total_sent"] += 1
                except Exception as e:
                    logger.error(f"Fehler beim Senden an Client: {e}")
                    disconnected.add(connection)

            # Entferne defekte Verbindungen
            for conn in disconnected:
                self.disconnect(conn)

    def get_stats(self):
        return {"active_groups": len(self.groups), "total_connections": len(self.connections), **self.message_stats}

    def get_group_info(self, group_name: str) -> Dict[str, Any]:
        """Gibt Informationen über eine Gruppe zurück"""
        if group_name not in self.groups:
            return {"group": group_name, "members": 0, "clients": []}

        members = []
        for ws in self.groups[group_name]:
            client_type = self.client_types.get(ws, "unknown")
            is_leader = self.group_leaders.get(group_name) == ws
            members.append({"client_type": client_type, "is_leader": is_leader})

        return {"group": group_name, "members": len(members), "clients": members}


manager = ConnectionManager()


@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            manager.message_stats["total_received"] += 1

            try:
                message = json.loads(data)

                # Handle join messages
                if message.get("type") == "join":
                    group_name = message.get("group")
                    client_type = message.get("client_type", "web")  # Standard: web
                    if group_name:
                        join_info = await manager.join_group(websocket, group_name, client_type)
                        # Bestätigungsmessage
                        await websocket.send_text(json.dumps(join_info))

                        # Benachrichtige andere Gruppenmitglieder über neuen Client
                        notification = {
                            "type": "client_joined",
                            "group": group_name,
                            "client_type": client_type,
                            "message": f"Neuer {client_type}-Client ist der Gruppe beigetreten",
                        }
                        await manager.broadcast_to_group(json.dumps(notification), group_name, exclude=websocket)  # Sende nicht an den neu verbundenen Client
                    else:
                        error_msg = {"type": "error", "message": "Missing group name in join request"}
                        await websocket.send_text(json.dumps(error_msg))

                # Ping/Pong für Verbindungsprüfung
                elif message.get("type") == "ping":
                    await websocket.send_text(json.dumps({"type": "pong"}))

                # Broadcast all other messages to the group
                else:
                    if websocket in manager.connections:
                        group_name = manager.connections[websocket]
                        await manager.broadcast_to_group(data, group_name)
                    else:
                        error_msg = {"type": "error", "message": "Join a group before sending messages"}
                        await websocket.send_text(json.dumps(error_msg))

            except json.JSONDecodeError:
                logger.warning(f"Invalid JSON received: {data}")
                if websocket in manager.connections:
                    group_name = manager.connections[websocket]
                    await manager.broadcast_to_group(data, group_name)

    except WebSocketDisconnect:
        logger.info("WebSocket disconnected")
        manager.disconnect(websocket)
    except Exception as e:
        logger.error(f"Unerwarteter Fehler: {e}")
        manager.disconnect(websocket)


# Health Check Endpoint
@app.get("/health")
async def health_check():
    return {"status": "healthy", "websocket_stats": manager.get_stats()}


# Neuer Endpoint für Gruppeninformationen
@app.get("/api/group/{group_name}")
async def get_group_info(group_name: str):
    """API-Endpunkt zum Abrufen von Gruppeninformationen"""
    group_info = manager.get_group_info(group_name)
    if group_info["members"] == 0:
        raise HTTPException(status_code=404, detail="Group not found")
    return JSONResponse(content=group_info)


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")