game-marathon/backend/app/api/v1/events.py

from datetime import datetime
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from sqlalchemy import select, and_, or_
from sqlalchemy.orm import selectinload

from app.api.deps import DbSession, CurrentUser
from app.models import (
    Marathon, MarathonStatus, Participant, ParticipantRole,
    Event, EventType, Activity, ActivityType, Assignment, AssignmentStatus, Challenge,
    SwapRequest as SwapRequestModel, SwapRequestStatus, User,
)
from fastapi import UploadFile, File, Form
from pathlib import Path
import uuid

from app.schemas import (
    EventCreate, EventResponse, ActiveEventResponse, EventEffects,
    MessageResponse, SwapRequest, ChallengeResponse, GameShort, SwapCandidate,
    SwapRequestCreate, SwapRequestResponse, SwapRequestChallengeInfo, MySwapRequests,
    CommonEnemyLeaderboard, EventAssignmentResponse, AssignmentResponse, CompleteResult,
)
from app.core.config import settings
from app.schemas.event import EVENT_INFO, COMMON_ENEMY_BONUSES
from app.schemas.user import UserPublic
from app.services.events import event_service

router = APIRouter(tags=["events"])


async def get_marathon_or_404(db, marathon_id: int) -> Marathon:
    result = await db.execute(select(Marathon).where(Marathon.id == marathon_id))
    marathon = result.scalar_one_or_none()
    if not marathon:
        raise HTTPException(status_code=404, detail="Marathon not found")
    return marathon


async def require_organizer(db, user_id: int, marathon_id: int) -> Participant:
    result = await db.execute(
        select(Participant).where(
            Participant.user_id == user_id,
            Participant.marathon_id == marathon_id,
        )
    )
    participant = result.scalar_one_or_none()
    if not participant:
        raise HTTPException(status_code=403, detail="Not a participant")
    if participant.role != ParticipantRole.ORGANIZER.value:
        raise HTTPException(status_code=403, detail="Only organizers can manage events")
    return participant


async def require_participant(db, user_id: int, marathon_id: int) -> Participant:
    result = await db.execute(
        select(Participant).where(
            Participant.user_id == user_id,
            Participant.marathon_id == marathon_id,
        )
    )
    participant = result.scalar_one_or_none()
    if not participant:
        raise HTTPException(status_code=403, detail="Not a participant")
    return participant


def event_to_response(event: Event) -> EventResponse:
    return EventResponse(
        id=event.id,
        type=event.type,
        start_time=event.start_time,
        end_time=event.end_time,
        is_active=event.is_active,
        created_by=UserPublic(
            id=event.created_by.id,
            login=event.created_by.login,
            nickname=event.created_by.nickname,
            avatar_url=None,
            role=event.created_by.role,
            created_at=event.created_by.created_at,
        ) if event.created_by else None,
        data=event.data,
        created_at=event.created_at,
    )


@router.get("/marathons/{marathon_id}/event", response_model=ActiveEventResponse)
async def get_active_event(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession
):
    """Get currently active event for marathon"""
    await get_marathon_or_404(db, marathon_id)
    await require_participant(db, current_user.id, marathon_id)

    event = await event_service.get_active_event(db, marathon_id)
    effects = event_service.get_event_effects(event)
    time_remaining = event_service.get_time_remaining(event)

    return ActiveEventResponse(
        event=event_to_response(event) if event else None,
        effects=effects,
        time_remaining_seconds=time_remaining,
    )


@router.get("/marathons/{marathon_id}/events", response_model=list[EventResponse])
async def list_events(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
    limit: int = 20,
    offset: int = 0,
):
    """Get event history for marathon"""
    await get_marathon_or_404(db, marathon_id)
    await require_participant(db, current_user.id, marathon_id)

    result = await db.execute(
        select(Event)
        .options(selectinload(Event.created_by))
        .where(Event.marathon_id == marathon_id)
        .order_by(Event.created_at.desc())
        .limit(limit)
        .offset(offset)
    )
    events = result.scalars().all()

    return [event_to_response(e) for e in events]


@router.post("/marathons/{marathon_id}/events", response_model=EventResponse)
async def start_event(
    marathon_id: int,
    data: EventCreate,
    current_user: CurrentUser,
    db: DbSession,
):
    """Start a new event (organizer only)"""
    marathon = await get_marathon_or_404(db, marathon_id)
    await require_organizer(db, current_user.id, marathon_id)

    if marathon.status != MarathonStatus.ACTIVE.value:
        raise HTTPException(status_code=400, detail="Marathon is not active")

    # Validate common_enemy requires challenge_id
    if data.type == EventType.COMMON_ENEMY.value and not data.challenge_id:
        raise HTTPException(
            status_code=400,
            detail="Common enemy event requires challenge_id"
        )

    try:
        event = await event_service.start_event(
            db=db,
            marathon_id=marathon_id,
            event_type=data.type,
            created_by_id=current_user.id,
            duration_minutes=data.duration_minutes,
            challenge_id=data.challenge_id,
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

    # Log activity
    event_info = EVENT_INFO.get(EventType(data.type), {})
    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.EVENT_START.value,
        data={
            "event_type": data.type,
            "event_name": event_info.get("name", data.type),
        },
    )
    db.add(activity)
    await db.commit()

    # Reload with relationship
    await db.refresh(event, ["created_by"])

    return event_to_response(event)


@router.delete("/marathons/{marathon_id}/event", response_model=MessageResponse)
async def stop_event(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Stop active event (organizer only)"""
    await get_marathon_or_404(db, marathon_id)
    await require_organizer(db, current_user.id, marathon_id)

    event = await event_service.get_active_event(db, marathon_id)
    if not event:
        raise HTTPException(status_code=404, detail="No active event")

    # Build activity data before ending event
    event_info = EVENT_INFO.get(EventType(event.type), {})
    activity_data = {
        "event_type": event.type,
        "event_name": event_info.get("name", event.type),
        "auto_closed": False,
    }

    # For common_enemy, include winners in activity
    if event.type == EventType.COMMON_ENEMY.value:
        event_data = event.data or {}
        completions = event_data.get("completions", [])
        if completions:
            activity_data["winners"] = [
                {
                    "user_id": c["user_id"],
                    "rank": c["rank"],
                    "bonus_points": COMMON_ENEMY_BONUSES.get(c["rank"], 0),
                }
                for c in completions[:3]  # Top 3
            ]

    await event_service.end_event(db, event.id)

    # Log activity
    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.EVENT_END.value,
        data=activity_data,
    )
    db.add(activity)
    await db.commit()

    return MessageResponse(message="Event stopped")


def build_swap_request_response(
    swap_req: SwapRequestModel,
) -> SwapRequestResponse:
    """Build SwapRequestResponse from model with loaded relationships"""
    return SwapRequestResponse(
        id=swap_req.id,
        status=swap_req.status,
        from_user=UserPublic(
            id=swap_req.from_participant.user.id,
            login=swap_req.from_participant.user.login,
            nickname=swap_req.from_participant.user.nickname,
            avatar_url=None,
            role=swap_req.from_participant.user.role,
            created_at=swap_req.from_participant.user.created_at,
        ),
        to_user=UserPublic(
            id=swap_req.to_participant.user.id,
            login=swap_req.to_participant.user.login,
            nickname=swap_req.to_participant.user.nickname,
            avatar_url=None,
            role=swap_req.to_participant.user.role,
            created_at=swap_req.to_participant.user.created_at,
        ),
        from_challenge=SwapRequestChallengeInfo(
            title=swap_req.from_assignment.challenge.title,
            description=swap_req.from_assignment.challenge.description,
            points=swap_req.from_assignment.challenge.points,
            difficulty=swap_req.from_assignment.challenge.difficulty,
            game_title=swap_req.from_assignment.challenge.game.title,
        ),
        to_challenge=SwapRequestChallengeInfo(
            title=swap_req.to_assignment.challenge.title,
            description=swap_req.to_assignment.challenge.description,
            points=swap_req.to_assignment.challenge.points,
            difficulty=swap_req.to_assignment.challenge.difficulty,
            game_title=swap_req.to_assignment.challenge.game.title,
        ),
        created_at=swap_req.created_at,
        responded_at=swap_req.responded_at,
    )


@router.post("/marathons/{marathon_id}/swap-requests", response_model=SwapRequestResponse)
async def create_swap_request(
    marathon_id: int,
    data: SwapRequestCreate,
    current_user: CurrentUser,
    db: DbSession,
):
    """Create a swap request to another participant (requires their confirmation)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active swap event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.SWAP.value:
        raise HTTPException(status_code=400, detail="No active swap event")

    # Get target participant
    result = await db.execute(
        select(Participant)
        .options(selectinload(Participant.user))
        .where(
            Participant.id == data.target_participant_id,
            Participant.marathon_id == marathon_id,
        )
    )
    target = result.scalar_one_or_none()
    if not target:
        raise HTTPException(status_code=404, detail="Target participant not found")

    if target.id == participant.id:
        raise HTTPException(status_code=400, detail="Cannot swap with yourself")

    # Get both active assignments
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game)
        )
        .where(
            Assignment.participant_id == participant.id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
        )
    )
    my_assignment = result.scalar_one_or_none()

    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game)
        )
        .where(
            Assignment.participant_id == target.id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
        )
    )
    target_assignment = result.scalar_one_or_none()

    if not my_assignment or not target_assignment:
        raise HTTPException(
            status_code=400,
            detail="Both participants must have active assignments to swap"
        )

    # Check if there's already a pending request between these participants
    result = await db.execute(
        select(SwapRequestModel).where(
            SwapRequestModel.event_id == event.id,
            SwapRequestModel.status == SwapRequestStatus.PENDING.value,
            or_(
                and_(
                    SwapRequestModel.from_participant_id == participant.id,
                    SwapRequestModel.to_participant_id == target.id,
                ),
                and_(
                    SwapRequestModel.from_participant_id == target.id,
                    SwapRequestModel.to_participant_id == participant.id,
                ),
            )
        )
    )
    existing = result.scalar_one_or_none()
    if existing:
        raise HTTPException(
            status_code=400,
            detail="A pending swap request already exists between you and this participant"
        )

    # Create swap request
    swap_request = SwapRequestModel(
        event_id=event.id,
        from_participant_id=participant.id,
        to_participant_id=target.id,
        from_assignment_id=my_assignment.id,
        to_assignment_id=target_assignment.id,
        status=SwapRequestStatus.PENDING.value,
    )
    db.add(swap_request)
    await db.commit()
    await db.refresh(swap_request)

    # Load relationships for response
    result = await db.execute(
        select(SwapRequestModel)
        .options(
            selectinload(SwapRequestModel.from_participant).selectinload(Participant.user),
            selectinload(SwapRequestModel.to_participant).selectinload(Participant.user),
            selectinload(SwapRequestModel.from_assignment)
                .selectinload(Assignment.challenge)
                .selectinload(Challenge.game),
            selectinload(SwapRequestModel.to_assignment)
                .selectinload(Assignment.challenge)
                .selectinload(Challenge.game),
        )
        .where(SwapRequestModel.id == swap_request.id)
    )
    swap_request = result.scalar_one()

    return build_swap_request_response(swap_request)


@router.get("/marathons/{marathon_id}/swap-requests", response_model=MySwapRequests)
async def get_my_swap_requests(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get current user's incoming and outgoing swap requests"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active swap event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.SWAP.value:
        return MySwapRequests(incoming=[], outgoing=[])

    # Get all pending requests for this event involving this participant
    result = await db.execute(
        select(SwapRequestModel)
        .options(
            selectinload(SwapRequestModel.from_participant).selectinload(Participant.user),
            selectinload(SwapRequestModel.to_participant).selectinload(Participant.user),
            selectinload(SwapRequestModel.from_assignment)
                .selectinload(Assignment.challenge)
                .selectinload(Challenge.game),
            selectinload(SwapRequestModel.to_assignment)
                .selectinload(Assignment.challenge)
                .selectinload(Challenge.game),
        )
        .where(
            SwapRequestModel.event_id == event.id,
            SwapRequestModel.status == SwapRequestStatus.PENDING.value,
            or_(
                SwapRequestModel.from_participant_id == participant.id,
                SwapRequestModel.to_participant_id == participant.id,
            )
        )
        .order_by(SwapRequestModel.created_at.desc())
    )
    requests = result.scalars().all()

    incoming = []
    outgoing = []
    for req in requests:
        response = build_swap_request_response(req)
        if req.to_participant_id == participant.id:
            incoming.append(response)
        else:
            outgoing.append(response)

    return MySwapRequests(incoming=incoming, outgoing=outgoing)


@router.post("/marathons/{marathon_id}/swap-requests/{request_id}/accept", response_model=MessageResponse)
async def accept_swap_request(
    marathon_id: int,
    request_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Accept a swap request (performs the actual swap)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active swap event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.SWAP.value:
        raise HTTPException(status_code=400, detail="No active swap event")

    # Get the swap request
    result = await db.execute(
        select(SwapRequestModel)
        .options(
            selectinload(SwapRequestModel.from_participant).selectinload(Participant.user),
            selectinload(SwapRequestModel.to_participant),
            selectinload(SwapRequestModel.from_assignment),
            selectinload(SwapRequestModel.to_assignment),
        )
        .where(
            SwapRequestModel.id == request_id,
            SwapRequestModel.event_id == event.id,
        )
    )
    swap_request = result.scalar_one_or_none()
    if not swap_request:
        raise HTTPException(status_code=404, detail="Swap request not found")

    # Check that current user is the target
    if swap_request.to_participant_id != participant.id:
        raise HTTPException(status_code=403, detail="You can only accept requests sent to you")

    if swap_request.status != SwapRequestStatus.PENDING.value:
        raise HTTPException(status_code=400, detail="This request is no longer pending")

    # Verify both assignments are still active
    result = await db.execute(
        select(Assignment).where(Assignment.id == swap_request.from_assignment_id)
    )
    from_assignment = result.scalar_one_or_none()

    result = await db.execute(
        select(Assignment).where(Assignment.id == swap_request.to_assignment_id)
    )
    to_assignment = result.scalar_one_or_none()

    if not from_assignment or not to_assignment:
        swap_request.status = SwapRequestStatus.CANCELLED.value
        swap_request.responded_at = datetime.utcnow()
        await db.commit()
        raise HTTPException(status_code=400, detail="One or both assignments no longer exist")

    if from_assignment.status != AssignmentStatus.ACTIVE.value or to_assignment.status != AssignmentStatus.ACTIVE.value:
        swap_request.status = SwapRequestStatus.CANCELLED.value
        swap_request.responded_at = datetime.utcnow()
        await db.commit()
        raise HTTPException(status_code=400, detail="One or both assignments are no longer active")

    # Perform the swap
    from_challenge_id = from_assignment.challenge_id
    from_assignment.challenge_id = to_assignment.challenge_id
    to_assignment.challenge_id = from_challenge_id

    # Update request status
    swap_request.status = SwapRequestStatus.ACCEPTED.value
    swap_request.responded_at = datetime.utcnow()

    # Cancel any other pending requests involving these participants in this event
    await db.execute(
        select(SwapRequestModel)
        .where(
            SwapRequestModel.event_id == event.id,
            SwapRequestModel.status == SwapRequestStatus.PENDING.value,
            SwapRequestModel.id != request_id,
            or_(
                SwapRequestModel.from_participant_id.in_([swap_request.from_participant_id, swap_request.to_participant_id]),
                SwapRequestModel.to_participant_id.in_([swap_request.from_participant_id, swap_request.to_participant_id]),
            )
        )
    )
    # Update those to cancelled
    from sqlalchemy import update
    await db.execute(
        update(SwapRequestModel)
        .where(
            SwapRequestModel.event_id == event.id,
            SwapRequestModel.status == SwapRequestStatus.PENDING.value,
            SwapRequestModel.id != request_id,
            or_(
                SwapRequestModel.from_participant_id.in_([swap_request.from_participant_id, swap_request.to_participant_id]),
                SwapRequestModel.to_participant_id.in_([swap_request.from_participant_id, swap_request.to_participant_id]),
            )
        )
        .values(status=SwapRequestStatus.CANCELLED.value, responded_at=datetime.utcnow())
    )

    # Log activity
    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.SWAP.value,
        data={
            "swapped_with_user_id": swap_request.from_participant.user_id,
            "swapped_with_nickname": swap_request.from_participant.user.nickname,
        },
    )
    db.add(activity)

    await db.commit()

    return MessageResponse(message="Swap completed successfully!")


@router.post("/marathons/{marathon_id}/swap-requests/{request_id}/decline", response_model=MessageResponse)
async def decline_swap_request(
    marathon_id: int,
    request_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Decline a swap request"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active swap event (allow declining even if event ended)
    event = await event_service.get_active_event(db, marathon_id)

    # Get the swap request
    result = await db.execute(
        select(SwapRequestModel).where(SwapRequestModel.id == request_id)
    )
    swap_request = result.scalar_one_or_none()
    if not swap_request:
        raise HTTPException(status_code=404, detail="Swap request not found")

    # Check that current user is the target
    if swap_request.to_participant_id != participant.id:
        raise HTTPException(status_code=403, detail="You can only decline requests sent to you")

    if swap_request.status != SwapRequestStatus.PENDING.value:
        raise HTTPException(status_code=400, detail="This request is no longer pending")

    # Update status
    swap_request.status = SwapRequestStatus.DECLINED.value
    swap_request.responded_at = datetime.utcnow()

    await db.commit()

    return MessageResponse(message="Swap request declined")


@router.delete("/marathons/{marathon_id}/swap-requests/{request_id}", response_model=MessageResponse)
async def cancel_swap_request(
    marathon_id: int,
    request_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Cancel your own outgoing swap request"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Get the swap request
    result = await db.execute(
        select(SwapRequestModel).where(SwapRequestModel.id == request_id)
    )
    swap_request = result.scalar_one_or_none()
    if not swap_request:
        raise HTTPException(status_code=404, detail="Swap request not found")

    # Check that current user is the sender
    if swap_request.from_participant_id != participant.id:
        raise HTTPException(status_code=403, detail="You can only cancel your own requests")

    if swap_request.status != SwapRequestStatus.PENDING.value:
        raise HTTPException(status_code=400, detail="This request is no longer pending")

    # Update status
    swap_request.status = SwapRequestStatus.CANCELLED.value
    swap_request.responded_at = datetime.utcnow()

    await db.commit()

    return MessageResponse(message="Swap request cancelled")


# ==================== Game Choice Event Endpoints ====================


class GameChoiceChallengeResponse(BaseModel):
    """Challenge option for game choice event"""
    id: int
    title: str
    description: str
    difficulty: str
    points: int
    estimated_time: int | None
    proof_type: str
    proof_hint: str | None


class GameChoiceChallengesResponse(BaseModel):
    """Response with available challenges for game choice"""
    game_id: int
    game_title: str
    challenges: list[GameChoiceChallengeResponse]


class GameChoiceSelectRequest(BaseModel):
    """Request to select a challenge during game choice event"""
    challenge_id: int


@router.get("/marathons/{marathon_id}/game-choice/challenges", response_model=GameChoiceChallengesResponse)
async def get_game_choice_challenges(
    marathon_id: int,
    game_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get 3 random challenges from a game for game choice event"""
    from app.models import Game
    from sqlalchemy.sql.expression import func

    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active game_choice event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.GAME_CHOICE.value:
        raise HTTPException(status_code=400, detail="No active game choice event")

    # Get the game
    result = await db.execute(
        select(Game).where(Game.id == game_id, Game.marathon_id == marathon_id)
    )
    game = result.scalar_one_or_none()
    if not game:
        raise HTTPException(status_code=404, detail="Game not found")

    # Get 3 random challenges from this game
    result = await db.execute(
        select(Challenge)
        .where(Challenge.game_id == game_id)
        .order_by(func.random())
        .limit(3)
    )
    challenges = result.scalars().all()

    if not challenges:
        raise HTTPException(status_code=400, detail="No challenges available for this game")

    return GameChoiceChallengesResponse(
        game_id=game.id,
        game_title=game.title,
        challenges=[
            GameChoiceChallengeResponse(
                id=c.id,
                title=c.title,
                description=c.description,
                difficulty=c.difficulty,
                points=c.points,
                estimated_time=c.estimated_time,
                proof_type=c.proof_type,
                proof_hint=c.proof_hint,
            )
            for c in challenges
        ],
    )


@router.post("/marathons/{marathon_id}/game-choice/select", response_model=MessageResponse)
async def select_game_choice_challenge(
    marathon_id: int,
    data: GameChoiceSelectRequest,
    current_user: CurrentUser,
    db: DbSession,
):
    """Select a challenge during game choice event (replaces current assignment if any)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active game_choice event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.GAME_CHOICE.value:
        raise HTTPException(status_code=400, detail="No active game choice event")

    # Get the challenge
    result = await db.execute(
        select(Challenge)
        .options(selectinload(Challenge.game))
        .where(Challenge.id == data.challenge_id)
    )
    challenge = result.scalar_one_or_none()
    if not challenge:
        raise HTTPException(status_code=404, detail="Challenge not found")

    # Verify challenge belongs to this marathon
    if challenge.game.marathon_id != marathon_id:
        raise HTTPException(status_code=400, detail="Challenge does not belong to this marathon")

    # Check for current active assignment (non-event)
    result = await db.execute(
        select(Assignment)
        .options(selectinload(Assignment.challenge))
        .where(
            Assignment.participant_id == participant.id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
            Assignment.is_event_assignment == False,
        )
    )
    current_assignment = result.scalar_one_or_none()

    # If there's a current assignment, replace it (free drop during this event)
    old_challenge_title = None
    if current_assignment:
        old_challenge_title = current_assignment.challenge.title
        # Mark old assignment as dropped (no penalty during game_choice event)
        current_assignment.status = AssignmentStatus.DROPPED.value
        current_assignment.completed_at = datetime.utcnow()

    # Create new assignment with chosen challenge
    new_assignment = Assignment(
        participant_id=participant.id,
        challenge_id=data.challenge_id,
        status=AssignmentStatus.ACTIVE.value,
        event_type=EventType.GAME_CHOICE.value,
    )
    db.add(new_assignment)

    # Log activity
    activity_data = {
        "game": challenge.game.title,
        "challenge": challenge.title,
        "event_type": EventType.GAME_CHOICE.value,
    }
    if old_challenge_title:
        activity_data["replaced_challenge"] = old_challenge_title

    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.SPIN.value,  # Treat as a spin activity
        data=activity_data,
    )
    db.add(activity)

    await db.commit()

    if old_challenge_title:
        return MessageResponse(message=f"Задание заменено! Теперь у вас: {challenge.title}")
    else:
        return MessageResponse(message=f"Задание выбрано: {challenge.title}")


@router.get("/marathons/{marathon_id}/swap-candidates", response_model=list[SwapCandidate])
async def get_swap_candidates(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get participants with active assignments available for swap (during swap event)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Check active swap event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.SWAP.value:
        raise HTTPException(status_code=400, detail="No active swap event")

    # Get all participants except current user with active assignments
    from app.models import Game
    result = await db.execute(
        select(Participant, Assignment, Challenge, Game)
        .join(Assignment, Assignment.participant_id == Participant.id)
        .join(Challenge, Assignment.challenge_id == Challenge.id)
        .join(Game, Challenge.game_id == Game.id)
        .options(selectinload(Participant.user))
        .where(
            Participant.marathon_id == marathon_id,
            Participant.id != participant.id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
        )
    )
    rows = result.all()

    return [
        SwapCandidate(
            participant_id=p.id,
            user=UserPublic(
                id=p.user.id,
                login=p.user.login,
                nickname=p.user.nickname,
                avatar_url=None,
                role=p.user.role,
                created_at=p.user.created_at,
            ),
            challenge_title=challenge.title,
            challenge_description=challenge.description,
            challenge_points=challenge.points,
            challenge_difficulty=challenge.difficulty,
            game_title=game.title,
        )
        for p, assignment, challenge, game in rows
    ]


@router.get("/marathons/{marathon_id}/common-enemy-leaderboard", response_model=list[CommonEnemyLeaderboard])
async def get_common_enemy_leaderboard(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get leaderboard for common enemy event (who completed the challenge)"""
    await get_marathon_or_404(db, marathon_id)
    await require_participant(db, current_user.id, marathon_id)

    # Get active common enemy event
    event = await event_service.get_active_event(db, marathon_id)
    if not event or event.type != EventType.COMMON_ENEMY.value:
        return []

    # Get completions from event data
    data = event.data or {}
    completions = data.get("completions", [])

    if not completions:
        return []

    # Get user info for all participants who completed
    user_ids = [c["user_id"] for c in completions]
    result = await db.execute(
        select(User).where(User.id.in_(user_ids))
    )
    users_by_id = {u.id: u for u in result.scalars().all()}

    # Build leaderboard
    leaderboard = []
    for completion in completions:
        user = users_by_id.get(completion["user_id"])
        if user:
            leaderboard.append(
                CommonEnemyLeaderboard(
                    participant_id=completion["participant_id"],
                    user=UserPublic(
                        id=user.id,
                        login=user.login,
                        nickname=user.nickname,
                        avatar_url=None,
                        role=user.role,
                        created_at=user.created_at,
                    ),
                    completed_at=completion.get("completed_at"),
                    rank=completion.get("rank"),
                    bonus_points=COMMON_ENEMY_BONUSES.get(completion.get("rank", 0), 0),
                )
            )

    return leaderboard


# ==================== Event Assignment Endpoints ====================


def assignment_to_response(assignment: Assignment) -> AssignmentResponse:
    """Convert Assignment model to AssignmentResponse"""
    challenge = assignment.challenge
    game = challenge.game
    return AssignmentResponse(
        id=assignment.id,
        challenge=ChallengeResponse(
            id=challenge.id,
            title=challenge.title,
            description=challenge.description,
            type=challenge.type,
            difficulty=challenge.difficulty,
            points=challenge.points,
            estimated_time=challenge.estimated_time,
            proof_type=challenge.proof_type,
            proof_hint=challenge.proof_hint,
            game=GameShort(
                id=game.id,
                title=game.title,
                cover_url=f"/uploads/covers/{game.cover_path.split('/')[-1]}" if game.cover_path else None,
            ),
            is_generated=challenge.is_generated,
            created_at=challenge.created_at,
        ),
        status=assignment.status,
        proof_url=f"/uploads/proofs/{assignment.proof_path.split('/')[-1]}" if assignment.proof_path else assignment.proof_url,
        proof_comment=assignment.proof_comment,
        points_earned=assignment.points_earned,
        streak_at_completion=assignment.streak_at_completion,
        started_at=assignment.started_at,
        completed_at=assignment.completed_at,
    )


@router.get("/marathons/{marathon_id}/event-assignment", response_model=EventAssignmentResponse)
async def get_event_assignment(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get current user's event assignment (Common Enemy)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    # Get active common enemy event
    event = await event_service.get_active_event(db, marathon_id)

    # Find event assignment for this participant
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game)
        )
        .where(
            Assignment.participant_id == participant.id,
            Assignment.is_event_assignment == True,
        )
        .order_by(Assignment.started_at.desc())
    )
    assignment = result.scalar_one_or_none()

    # Check if completed
    is_completed = assignment.status == AssignmentStatus.COMPLETED.value if assignment else False

    # If no active event but we have an assignment, it might be from a past event
    # Only return it if the event is still active
    if not event or event.type != EventType.COMMON_ENEMY.value:
        # Check if assignment belongs to an inactive event
        if assignment and assignment.event_id:
            result = await db.execute(
                select(Event).where(Event.id == assignment.event_id)
            )
            assignment_event = result.scalar_one_or_none()
            if assignment_event and not assignment_event.is_active:
                # Event ended, don't return the assignment
                return EventAssignmentResponse(
                    assignment=None,
                    event_id=None,
                    challenge_id=None,
                    is_completed=False,
                )

    return EventAssignmentResponse(
        assignment=assignment_to_response(assignment) if assignment else None,
        event_id=event.id if event else None,
        challenge_id=event.data.get("challenge_id") if event and event.data else None,
        is_completed=is_completed,
    )


@router.post("/event-assignments/{assignment_id}/complete", response_model=CompleteResult)
async def complete_event_assignment(
    assignment_id: int,
    current_user: CurrentUser,
    db: DbSession,
    proof_url: str | None = Form(None),
    comment: str | None = Form(None),
    proof_file: UploadFile | None = File(None),
):
    """Complete an event assignment (Common Enemy) with proof"""
    from app.services.points import PointsService
    points_service = PointsService()

    # Get assignment
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.participant),
            selectinload(Assignment.challenge).selectinload(Challenge.game),
        )
        .where(Assignment.id == assignment_id)
    )
    assignment = result.scalar_one_or_none()

    if not assignment:
        raise HTTPException(status_code=404, detail="Assignment not found")

    if assignment.participant.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="This is not your assignment")

    if assignment.status != AssignmentStatus.ACTIVE.value:
        raise HTTPException(status_code=400, detail="Assignment is not active")

    # Must be event assignment
    if not assignment.is_event_assignment:
        raise HTTPException(status_code=400, detail="This is not an event assignment")

    # Need either file or URL
    if not proof_file and not proof_url:
        raise HTTPException(status_code=400, detail="Proof is required (file or URL)")

    # Handle file upload
    if proof_file:
        contents = await proof_file.read()
        if len(contents) > settings.MAX_UPLOAD_SIZE:
            raise HTTPException(
                status_code=400,
                detail=f"File too large. Maximum size is {settings.MAX_UPLOAD_SIZE // 1024 // 1024} MB",
            )

        ext = proof_file.filename.split(".")[-1].lower() if proof_file.filename else "jpg"
        if ext not in settings.ALLOWED_EXTENSIONS:
            raise HTTPException(
                status_code=400,
                detail=f"Invalid file type. Allowed: {settings.ALLOWED_EXTENSIONS}",
            )

        filename = f"{assignment_id}_{uuid.uuid4().hex}.{ext}"
        filepath = Path(settings.UPLOAD_DIR) / "proofs" / filename
        filepath.parent.mkdir(parents=True, exist_ok=True)

        with open(filepath, "wb") as f:
            f.write(contents)

        assignment.proof_path = str(filepath)
    else:
        assignment.proof_url = proof_url

    assignment.proof_comment = comment

    # Get marathon_id
    marathon_id = assignment.challenge.game.marathon_id

    # Get active event for bonus calculation
    active_event = await event_service.get_active_event(db, marathon_id)

    # Calculate base points (no streak bonus for event assignments)
    participant = assignment.participant
    challenge = assignment.challenge
    base_points = challenge.points

    # Handle common enemy bonus
    common_enemy_bonus = 0
    common_enemy_closed = False
    common_enemy_winners = None

    if active_event and active_event.type == EventType.COMMON_ENEMY.value:
        common_enemy_bonus, common_enemy_closed, common_enemy_winners = await event_service.record_common_enemy_completion(
            db, active_event, participant.id, current_user.id
        )

    total_points = base_points + common_enemy_bonus

    # Update assignment
    assignment.status = AssignmentStatus.COMPLETED.value
    assignment.points_earned = total_points
    assignment.completed_at = datetime.utcnow()

    # Update participant points (event assignments add to total but don't affect streak)
    participant.total_points += total_points

    # Log activity
    activity_data = {
        "assignment_id": assignment.id,
        "game": challenge.game.title,
        "challenge": challenge.title,
        "difficulty": challenge.difficulty,
        "points": total_points,
        "event_type": EventType.COMMON_ENEMY.value,
        "is_event_assignment": True,
    }
    if common_enemy_bonus:
        activity_data["common_enemy_bonus"] = common_enemy_bonus

    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.COMPLETE.value,
        data=activity_data,
    )
    db.add(activity)

    # If common enemy event auto-closed, log the event end with winners
    if common_enemy_closed and common_enemy_winners:
        # Load winner nicknames
        winner_user_ids = [w["user_id"] for w in common_enemy_winners]
        users_result = await db.execute(
            select(User).where(User.id.in_(winner_user_ids))
        )
        users_map = {u.id: u.nickname for u in users_result.scalars().all()}

        winners_data = [
            {
                "user_id": w["user_id"],
                "nickname": users_map.get(w["user_id"], "Unknown"),
                "rank": w["rank"],
                "bonus_points": COMMON_ENEMY_BONUSES.get(w["rank"], 0),
            }
            for w in common_enemy_winners
        ]

        event_end_activity = Activity(
            marathon_id=marathon_id,
            user_id=current_user.id,
            type=ActivityType.EVENT_END.value,
            data={
                "event_type": EventType.COMMON_ENEMY.value,
                "event_name": EVENT_INFO.get(EventType.COMMON_ENEMY, {}).get("name", "Общий враг"),
                "auto_closed": True,
                "winners": winners_data,
            },
        )
        db.add(event_end_activity)

    await db.commit()

    return CompleteResult(
        points_earned=total_points,
        streak_bonus=0,  # Event assignments don't give streak bonus
        total_points=participant.total_points,
        new_streak=participant.current_streak,  # Streak unchanged
    )