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 app.schemas import (
    EventCreate, EventResponse, ActiveEventResponse, EventEffects,
    MessageResponse, SwapRequest, ChallengeResponse, GameShort, SwapCandidate,
    SwapRequestCreate, SwapRequestResponse, SwapRequestChallengeInfo, MySwapRequests,
    CommonEnemyLeaderboard,
)
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")


@router.post("/marathons/{marathon_id}/rematch/{assignment_id}", response_model=MessageResponse)
async def rematch_assignment(
    marathon_id: int,
    assignment_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Retry a dropped assignment (during rematch event)"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

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

    # Check no current active assignment
    result = await db.execute(
        select(Assignment).where(
            Assignment.participant_id == participant.id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
        )
    )
    if result.scalar_one_or_none():
        raise HTTPException(status_code=400, detail="You already have an active assignment")

    # Get the dropped assignment
    result = await db.execute(
        select(Assignment)
        .options(selectinload(Assignment.challenge))
        .where(
            Assignment.id == assignment_id,
            Assignment.participant_id == participant.id,
            Assignment.status == AssignmentStatus.DROPPED.value,
        )
    )
    dropped = result.scalar_one_or_none()
    if not dropped:
        raise HTTPException(status_code=404, detail="Dropped assignment not found")

    # Create new assignment for the same challenge (with rematch event_type for 50% points)
    new_assignment = Assignment(
        participant_id=participant.id,
        challenge_id=dropped.challenge_id,
        status=AssignmentStatus.ACTIVE.value,
        event_type=EventType.REMATCH.value,
    )
    db.add(new_assignment)

    # Log activity
    activity = Activity(
        marathon_id=marathon_id,
        user_id=current_user.id,
        type=ActivityType.REMATCH.value,
        data={
            "challenge": dropped.challenge.title,
            "original_assignment_id": assignment_id,
        },
    )
    db.add(activity)

    await db.commit()

    return MessageResponse(message="Rematch started! Complete for 50% points")


class DroppedAssignmentResponse(BaseModel):
    id: int
    challenge: ChallengeResponse
    dropped_at: datetime

    class Config:
        from_attributes = True


@router.get("/marathons/{marathon_id}/dropped-assignments", response_model=list[DroppedAssignmentResponse])
async def get_dropped_assignments(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
):
    """Get dropped assignments that can be rematched"""
    await get_marathon_or_404(db, marathon_id)
    participant = await require_participant(db, current_user.id, marathon_id)

    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game)
        )
        .where(
            Assignment.participant_id == participant.id,
            Assignment.status == AssignmentStatus.DROPPED.value,
        )
        .order_by(Assignment.started_at.desc())
    )
    dropped = result.scalars().all()

    return [
        DroppedAssignmentResponse(
            id=a.id,
            challenge=ChallengeResponse(
                id=a.challenge.id,
                title=a.challenge.title,
                description=a.challenge.description,
                type=a.challenge.type,
                difficulty=a.challenge.difficulty,
                points=a.challenge.points,
                estimated_time=a.challenge.estimated_time,
                proof_type=a.challenge.proof_type,
                proof_hint=a.challenge.proof_hint,
                game=GameShort(
                    id=a.challenge.game.id,
                    title=a.challenge.game.title,
                    cover_url=None,
                ),
                is_generated=a.challenge.is_generated,
                created_at=a.challenge.created_at,
            ),
            dropped_at=a.completed_at or a.started_at,
        )
        for a in dropped
    ]


@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