teecup/app/routers/messaging.py

"""
Kommunikasjon (ADR-025): lag-intern chat («det hemmelige rommet») og
offentlig runde-feed («Banter Board»). Delt `message`-tabell (migrasjon 013)
med en scope-diskriminator, men to helt ulike autorisasjonsmodeller:

- Lag-chat (`router`, /orgs/...): org-medlemskap (get_authorized_org) +
  `user_is_rostered_on_team` -- BEVISST INGEN org-admin-unntak, ulikt resten
  av appen. Ekte privat.
- Offentlig feed (`public_router`, /public/tournaments/...): LESING
  gjenbruker registration.py sitt trenivå-visibility-mønster uendret
  (inkl. anonym tilgang for `public`-synlige turneringer). POSTING/SLETTING
  er strengere -- krever ekte innlogging OG org-medlemskap ELLER faktisk
  deltakelse i akkurat denne turneringen (ikke bare "kan se den").

Sanntid via WebSockets (ADR-025 Beslutning B): et rent in-memory
tilkoblingsregister PER PROSESS -- trygt med dagens ene `teecup_api`-
container, men deles IKKE på tvers av flere prosesser/containere (samme
klasse begrensning som den allerede aksepterte in-memory-cachen, se
ARCHITECTURE_DECISIONS.md sine "Åpne spørsmål"). WS-rutene kan ikke bruke
get_current_user/get_authorized_org direkte (de er Request-typet, ikke
WebSocket-kompatible via Depends()) -- egne, minimale kopier av samme
sjekker brukes i stedet.
"""

from collections import defaultdict

from fastapi import APIRouter, Depends, File, Form, UploadFile, WebSocket, WebSocketDisconnect
from pydantic import BaseModel

from ..auth import CurrentUser, get_current_user, get_current_user_optional
from ..auth import get_current_user_from_websocket
from ..db import org_connection, plain_connection
from ..errors import app_error, translate_db_errors
from ..realtime import live_sockets_for
from ..team_authz import is_org_admin, user_is_rostered_on_team
from .. import storage
from .registration import check_visibility, code_matches, is_participant, resolve_org

router = APIRouter(tags=["messaging"])
public_router = APIRouter(prefix="/public/tournaments", tags=["public-messaging"])

_MESSAGE_COLUMNS = """
    id::text, author_user_id::text, author_display_name, body, image_key, created_at
"""


class MessageOut(BaseModel):
    id: str
    author_user_id: str
    author_display_name: str
    body: str | None
    image_url: str | None
    created_at: str


def _row_to_message(row) -> MessageOut:
    return MessageOut(
        id=row["id"],
        author_user_id=row["author_user_id"],
        author_display_name=row["author_display_name"],
        body=row["body"],
        image_url=storage.public_url(row["image_key"]) if row["image_key"] else None,
        created_at=row["created_at"].isoformat(),
    )


async def _resolve_author_display_name(conn, organization_id: str, user_id: str) -> str:
    """Fryses ved skrivetidspunkt (samme prinsipp som handicap_index_snapshot,
    ADR-007) -- avsenderens player.display_name i DENNE org-en hvis den
    finnes, ellers e-postens lokaldel (dekker org-ansatte uten egen
    spillerprofil som poster i den offentlige feeden)."""
    name = await conn.fetchval(
        "SELECT display_name FROM player WHERE organization_id = $1 AND user_id = $2 LIMIT 1",
        organization_id,
        user_id,
    )
    if name:
        return name
    async with plain_connection() as plain:
        email = await plain.fetchval("SELECT email FROM app_user WHERE id = $1", user_id)
    return email.split("@")[0] if email else "Ukjent"


async def _read_optional_image(image: UploadFile | None) -> bytes | None:
    if image is None:
        return None
    if image.content_type not in storage.ALLOWED_INPUT_CONTENT_TYPES:
        raise app_error(400, "VALIDATION_FAILED", "Ustøttet bildeformat.")
    raw = await image.read(storage.MAX_UPLOAD_BYTES + 1)
    if len(raw) > storage.MAX_UPLOAD_BYTES:
        raise app_error(400, "VALIDATION_FAILED", "Bildet er for stort (maks 8 MB).")
    return raw


# --- Sanntid: in-memory tilkoblingsregister (se moduldocstring) ------------

_team_sockets: dict[str, set[WebSocket]] = defaultdict(set)
_feed_sockets: dict[str, set[WebSocket]] = defaultdict(set)


async def _broadcast(sockets: set[WebSocket], payload: dict) -> None:
    dead = []
    for ws in list(sockets):
        try:
            await ws.send_json(payload)
        except Exception:
            dead.append(ws)
    for ws in dead:
        sockets.discard(ws)


async def _is_org_member(user_id: str, organization_id: str) -> bool:
    """WS-variant av get_authorized_org sin medlemskapssjekk -- samme grunn
    som get_current_user_from_websocket: ingen HTTP Request å binde
    Depends() til i en WS-scope."""
    async with plain_connection() as conn:
        return bool(
            await conn.fetchval(
                "SELECT EXISTS (SELECT 1 FROM organization_membership WHERE user_id = $1 AND organization_id = $2)",
                user_id,
                organization_id,
            )
        )


# ---------------------------------------------------------------------------
# Lag-chat (privat) -- /orgs/...
# ---------------------------------------------------------------------------


@router.get("/orgs/{organization_id}/teams/{team_id}/messages", response_model=list[MessageOut])
async def list_team_messages(
    team_id: str,
    organization_id: str,
    user: CurrentUser = Depends(get_current_user),
) -> list[MessageOut]:
    async with org_connection(organization_id) as conn:
        exists = await conn.fetchval("SELECT id FROM team WHERE id = $1", team_id)
        if exists is None:
            raise app_error(404, "NOT_FOUND", "Laget finnes ikke.")
        if not await user_is_rostered_on_team(conn, team_id, user.user_id):
            raise app_error(403, "NOT_ROSTERED_ON_TEAM", "Du er ikke rostret på dette laget.")
        rows = await conn.fetch(
            f"""
            SELECT {_MESSAGE_COLUMNS} FROM message
            WHERE team_id = $1 AND scope = 'team'
            ORDER BY created_at
            """,
            team_id,
        )
    return [_row_to_message(r) for r in rows]


@router.post(
    "/orgs/{organization_id}/teams/{team_id}/messages", response_model=MessageOut, status_code=201
)
async def send_team_message(
    team_id: str,
    organization_id: str,
    body: str | None = Form(default=None),
    image: UploadFile | None = File(default=None),
    user: CurrentUser = Depends(get_current_user),
) -> MessageOut:
    if not body and image is None:
        raise app_error(400, "VALIDATION_FAILED", "Meldingen må ha tekst eller bilde.")
    raw = await _read_optional_image(image)

    async with org_connection(organization_id) as conn, translate_db_errors():
        team = await conn.fetchrow(
            "SELECT tournament_id::text AS tournament_id FROM team WHERE id = $1", team_id
        )
        if team is None:
            raise app_error(404, "NOT_FOUND", "Laget finnes ikke.")
        if not await user_is_rostered_on_team(conn, team_id, user.user_id):
            raise app_error(403, "NOT_ROSTERED_ON_TEAM", "Du er ikke rostret på dette laget.")

        image_key = None
        if raw is not None:
            try:
                image_key = await storage.upload_image("messages", team_id, raw)
            except storage.InvalidImageError:
                raise app_error(400, "VALIDATION_FAILED", "Filen er ikke et gyldig bilde.")

        display_name = await _resolve_author_display_name(conn, organization_id, user.user_id)

        row = await conn.fetchrow(
            f"""
            INSERT INTO message
                (organization_id, scope, tournament_id, team_id, author_user_id, author_display_name, body, image_key)
            VALUES ($1, 'team', $2, $3, $4, $5, $6, $7)
            RETURNING {_MESSAGE_COLUMNS}
            """,
            organization_id,
            team["tournament_id"],
            team_id,
            user.user_id,
            display_name,
            body,
            image_key,
        )
    message = _row_to_message(row)
    await _broadcast(_team_sockets[team_id], message.model_dump())
    return message


@router.delete(
    "/orgs/{organization_id}/teams/{team_id}/messages/{message_id}", status_code=204
)
async def delete_team_message(
    team_id: str,
    message_id: str,
    organization_id: str,
    user: CurrentUser = Depends(get_current_user),
) -> None:
    """Kun forfatteren selv -- INGEN org-admin-unntak (samme begrunnelse som
    lesetilgangen: et ekte privat rom har ingen ekstern moderator)."""
    async with org_connection(organization_id) as conn:
        row = await conn.fetchrow(
            """
            SELECT author_user_id::text AS author_user_id FROM message
            WHERE id = $1 AND team_id = $2 AND scope = 'team'
            """,
            message_id,
            team_id,
        )
        if row is None:
            raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.")
        if row["author_user_id"] != user.user_id:
            raise app_error(403, "NOT_MESSAGE_AUTHOR", "Du kan kun slette dine egne meldinger.")
        await conn.execute("DELETE FROM message WHERE id = $1", message_id)


@router.websocket("/ws/orgs/{organization_id}/teams/{team_id}/messages")
async def team_chat_ws(websocket: WebSocket, organization_id: str, team_id: str) -> None:
    user = await get_current_user_from_websocket(websocket)
    if user is None:
        await websocket.close(code=4401)
        return
    if not await _is_org_member(user.user_id, organization_id):
        await websocket.close(code=4403)
        return
    async with org_connection(organization_id) as conn:
        allowed = await user_is_rostered_on_team(conn, team_id, user.user_id)
    if not allowed:
        await websocket.close(code=4403)
        return

    await websocket.accept()
    _team_sockets[team_id].add(websocket)
    try:
        while True:
            # Klienten sender ingenting -- denne løkken finnes kun for å
            # oppdage disconnect (receive() kaster WebSocketDisconnect da).
            await websocket.receive_text()
    except WebSocketDisconnect:
        pass
    finally:
        _team_sockets[team_id].discard(websocket)


# ---------------------------------------------------------------------------
# Offentlig runde-feed -- /public/tournaments/...
# ---------------------------------------------------------------------------


async def _may_post_to_feed(conn, user: CurrentUser, organization_id: str, tournament_id: str) -> bool:
    """Strengere enn LESING (check_visibility): en 'public'-synlig turnering
    kan leses helt anonymt, men posting krever alltid ekte innlogging OG
    tilknytning -- org-medlem ELLER faktisk deltaker/registrert i NØYAKTIG
    denne turneringen. Hindrer at en helt urelatert innlogget bruker (konto
    et helt annet sted i systemet) kan poste på en fremmed offentlig side."""
    is_member = await conn.fetchval(
        "SELECT EXISTS (SELECT 1 FROM organization_membership WHERE user_id = $1 AND organization_id = $2)",
        user.user_id,
        organization_id,
    )
    if is_member:
        return True
    return await is_participant(conn, user.user_id, organization_id, tournament_id)


@public_router.get("/{tournament_id}/feed", response_model=list[MessageOut])
async def get_feed(
    tournament_id: str,
    code: str | None = None,
    user: CurrentUser | None = Depends(get_current_user_optional),
) -> list[MessageOut]:
    organization_id = await resolve_org(tournament_id)
    async with org_connection(organization_id) as conn:
        row = await conn.fetchrow(
            "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id
        )
        if row is None:
            raise app_error(404, "NOT_FOUND", "Turneringen finnes ikke.")
        if not code_matches(row["join_code"], code):
            await check_visibility(conn, row["visibility"], organization_id, tournament_id, user)

        rows = await conn.fetch(
            f"""
            SELECT {_MESSAGE_COLUMNS} FROM message
            WHERE tournament_id = $1 AND scope = 'tournament_feed'
            ORDER BY created_at
            """,
            tournament_id,
        )
    return [_row_to_message(r) for r in rows]


@public_router.post("/{tournament_id}/feed", response_model=MessageOut, status_code=201)
async def post_to_feed(
    tournament_id: str,
    body: str | None = Form(default=None),
    image: UploadFile | None = File(default=None),
    code: str | None = Form(default=None),
    user: CurrentUser = Depends(get_current_user),
) -> MessageOut:
    if not body and image is None:
        raise app_error(400, "VALIDATION_FAILED", "Meldingen må ha tekst eller bilde.")
    raw = await _read_optional_image(image)

    organization_id = await resolve_org(tournament_id)
    async with org_connection(organization_id) as conn, translate_db_errors():
        row = await conn.fetchrow(
            "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id
        )
        if row is None:
            raise app_error(404, "NOT_FOUND", "Turneringen finnes ikke.")
        if not code_matches(row["join_code"], code):
            await check_visibility(conn, row["visibility"], organization_id, tournament_id, user)
        if not await _may_post_to_feed(conn, user, organization_id, tournament_id):
            raise app_error(
                403,
                "NOT_A_PARTICIPANT",
                "Du må være medlem av organisasjonen eller delta i turneringen for å poste.",
            )

        image_key = None
        if raw is not None:
            try:
                image_key = await storage.upload_image("messages", tournament_id, raw)
            except storage.InvalidImageError:
                raise app_error(400, "VALIDATION_FAILED", "Filen er ikke et gyldig bilde.")

        display_name = await _resolve_author_display_name(conn, organization_id, user.user_id)

        inserted = await conn.fetchrow(
            f"""
            INSERT INTO message
                (organization_id, scope, tournament_id, team_id, author_user_id, author_display_name, body, image_key)
            VALUES ($1, 'tournament_feed', $2, NULL, $3, $4, $5, $6)
            RETURNING {_MESSAGE_COLUMNS}
            """,
            organization_id,
            tournament_id,
            user.user_id,
            display_name,
            body,
            image_key,
        )
    message = _row_to_message(inserted)
    await _broadcast(_feed_sockets[tournament_id], message.model_dump())
    return message


@public_router.delete("/{tournament_id}/feed/{message_id}", status_code=204)
async def delete_feed_message(
    tournament_id: str,
    message_id: str,
    user: CurrentUser = Depends(get_current_user),
) -> None:
    """Forfatteren selv, ELLER org-eier/admin (moderering) -- ulikt lag-
    chatten, siden feeden er offentlig og derfor trenger en reell
    moderasjonsvei."""
    organization_id = await resolve_org(tournament_id)
    async with org_connection(organization_id) as conn:
        row = await conn.fetchrow(
            """
            SELECT author_user_id::text AS author_user_id FROM message
            WHERE id = $1 AND tournament_id = $2 AND scope = 'tournament_feed'
            """,
            message_id,
            tournament_id,
        )
        if row is None:
            raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.")
        if row["author_user_id"] != user.user_id and not await is_org_admin(
            conn, organization_id, user.user_id
        ):
            raise app_error(
                403, "NOT_MESSAGE_AUTHOR", "Du kan kun slette dine egne meldinger (eller som organisasjonsadministrator)."
            )
        await conn.execute("DELETE FROM message WHERE id = $1", message_id)


@router.websocket("/ws/public/tournaments/{tournament_id}/feed")
async def feed_ws(websocket: WebSocket, tournament_id: str, code: str | None = None) -> None:
    user = await get_current_user_from_websocket(websocket)
    organization_id = await resolve_org(tournament_id)
    async with org_connection(organization_id) as conn:
        row = await conn.fetchrow(
            "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id
        )
        if row is None:
            await websocket.close(code=4404)
            return
        if not code_matches(row["join_code"], code):
            try:
                await check_visibility(conn, row["visibility"], organization_id, tournament_id, user)
            except Exception:
                await websocket.close(code=4403)
                return

    await websocket.accept()
    _feed_sockets[tournament_id].add(websocket)
    try:
        while True:
            await websocket.receive_text()
    except WebSocketDisconnect:
        pass
    finally:
        _feed_sockets[tournament_id].discard(websocket)


@router.websocket("/ws/public/tournaments/{tournament_id}/live")
async def tournament_live_ws(websocket: WebSocket, tournament_id: str, code: str | None = None) -> None:
    """ADR-027: "Følg live"-siden (leaderboard/matcher/scorekort,
    registration.py) sin sanntid. Sender kun et "noe endret seg"-signal --
    se app/realtime.py sin moduldocstring for hvorfor -- klienten reagerer
    ved å hente de vanlige REST-endepunktene på nytt. Samme visibility-sjekk
    som selve de offentlige lese-endepunktene den speiler."""
    user = await get_current_user_from_websocket(websocket)
    organization_id = await resolve_org(tournament_id)
    async with org_connection(organization_id) as conn:
        row = await conn.fetchrow(
            "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id
        )
        if row is None:
            await websocket.close(code=4404)
            return
        if not code_matches(row["join_code"], code):
            try:
                await check_visibility(conn, row["visibility"], organization_id, tournament_id, user)
            except Exception:
                await websocket.close(code=4403)
                return

    await websocket.accept()
    sockets = live_sockets_for(tournament_id)
    sockets.add(websocket)
    try:
        while True:
            await websocket.receive_text()
    except WebSocketDisconnect:
        pass
    finally:
        sockets.discard(websocket)