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

import random
from datetime import datetime
from fastapi import APIRouter, HTTPException, UploadFile, File, Form
from sqlalchemy import select, func
from sqlalchemy.orm import selectinload

from app.api.deps import DbSession, CurrentUser
from app.core.config import settings
from app.models import (
    Marathon, MarathonStatus, Game, Challenge, Participant,
    Assignment, AssignmentStatus, Activity, ActivityType,
    EventType, Difficulty, User, BonusAssignment, BonusAssignmentStatus, GameType,
    DisputeStatus,
)
from app.schemas import (
    SpinResult, AssignmentResponse, CompleteResult, DropResult,
    GameResponse, ChallengeResponse, GameShort, UserPublic, MessageResponse,
)
from app.schemas.game import PlaythroughInfo
from app.services.points import PointsService
from app.services.events import event_service
from app.services.storage import storage_service
from app.services.coins import coins_service
from app.services.consumables import consumables_service
from app.api.v1.games import get_available_games_for_participant

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

points_service = PointsService()


async def get_participant_or_403(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="You are not a participant of this marathon")
    return participant


async def get_active_assignment(db, participant_id: int, is_event: bool = False) -> Assignment | None:
    """Get active assignment for participant.

    Args:
        db: Database session
        participant_id: Participant ID
        is_event: If True, get event assignment (Common Enemy). If False, get regular assignment.
    """
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game),
            selectinload(Assignment.game).selectinload(Game.challenges),  # For playthrough
            selectinload(Assignment.bonus_assignments).selectinload(BonusAssignment.challenge),  # For playthrough bonuses
        )
        .where(
            Assignment.participant_id == participant_id,
            Assignment.status == AssignmentStatus.ACTIVE.value,
            Assignment.is_event_assignment == is_event,
        )
    )
    return result.scalar_one_or_none()


async def get_oldest_returned_assignment(db, participant_id: int) -> Assignment | None:
    """Get the oldest returned assignment that needs to be redone."""
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game),
            selectinload(Assignment.game).selectinload(Game.challenges),  # For playthrough
            selectinload(Assignment.bonus_assignments).selectinload(BonusAssignment.challenge),  # For playthrough bonuses
        )
        .where(
            Assignment.participant_id == participant_id,
            Assignment.status == AssignmentStatus.RETURNED.value,
            Assignment.is_event_assignment == False,
        )
        .order_by(Assignment.completed_at.asc())  # Oldest first
        .limit(1)
    )
    return result.scalar_one_or_none()


async def activate_returned_assignment(db, returned_assignment: Assignment) -> None:
    """
    Re-activate a returned assignment.
    Simply changes the status back to ACTIVE.
    """
    returned_assignment.status = AssignmentStatus.ACTIVE.value
    returned_assignment.started_at = datetime.utcnow()
    # Clear previous proof data for fresh attempt
    returned_assignment.proof_path = None
    returned_assignment.proof_url = None
    returned_assignment.proof_comment = None
    returned_assignment.completed_at = None
    returned_assignment.points_earned = 0


@router.post("/marathons/{marathon_id}/spin", response_model=SpinResult)
async def spin_wheel(marathon_id: int, current_user: CurrentUser, db: DbSession):
    """Spin the wheel to get a random game and challenge (or playthrough)"""
    # Check marathon is active
    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")

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

    # Check if marathon has expired by end_date
    if marathon.end_date and datetime.utcnow() > marathon.end_date:
        raise HTTPException(status_code=400, detail="Marathon has ended")

    participant = await get_participant_or_403(db, current_user.id, marathon_id)

    # Check no active regular assignment (event assignments are separate)
    active = await get_active_assignment(db, participant.id, is_event=False)
    if active:
        raise HTTPException(status_code=400, detail="You already have an active assignment")

    # Get available games (filtered by completion status)
    available_games, _ = await get_available_games_for_participant(db, participant, marathon_id)

    if not available_games:
        raise HTTPException(status_code=400, detail="No games available for spin")

    # Check active event
    active_event = await event_service.get_active_event(db, marathon_id)

    game = None
    challenge = None
    is_playthrough = False

    # Handle special event cases (excluding Common Enemy - it has separate flow)
    # Events only apply to challenges-type games, not playthrough
    if active_event:
        if active_event.type == EventType.JACKPOT.value:
            # Jackpot: Get hard challenge only (from challenges-type games)
            challenge = await event_service.get_random_hard_challenge(db, marathon_id)
            if challenge:
                # Check if this game is available for the participant
                result = await db.execute(
                    select(Game).where(Game.id == challenge.game_id)
                )
                game = result.scalar_one_or_none()
                if game and game.id in [g.id for g in available_games]:
                    # Consume jackpot (one-time use)
                    await event_service.consume_jackpot(db, active_event.id)
                else:
                    # Game not available, fall back to normal selection
                    game = None
                    challenge = None
        # Note: Common Enemy is handled separately via event-assignment endpoints

    # Normal random selection if no special event handling
    if not game:
        game = random.choice(available_games)

        if game.game_type == GameType.PLAYTHROUGH.value:
            # Playthrough game - no challenge selection, ignore events
            is_playthrough = True
            challenge = None
            active_event = None  # Ignore events for playthrough
        else:
            # Challenges game - select random challenge
            if not game.challenges:
                # Reload challenges if not loaded
                result = await db.execute(
                    select(Game)
                    .options(selectinload(Game.challenges))
                    .where(Game.id == game.id)
                )
                game = result.scalar_one()

            # Filter out already completed challenges
            completed_result = await db.execute(
                select(Assignment.challenge_id)
                .where(
                    Assignment.participant_id == participant.id,
                    Assignment.challenge_id.in_([c.id for c in game.challenges]),
                    Assignment.status == AssignmentStatus.COMPLETED.value,
                )
            )
            completed_ids = set(completed_result.scalars().all())
            available_challenges = [c for c in game.challenges if c.id not in completed_ids]

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

            challenge = random.choice(available_challenges)

    # Create assignment
    if is_playthrough:
        # Playthrough assignment - link to game, not challenge
        assignment = Assignment(
            participant_id=participant.id,
            game_id=game.id,
            is_playthrough=True,
            status=AssignmentStatus.ACTIVE.value,
            # No event_type for playthrough
        )
        db.add(assignment)
        await db.flush()  # Get assignment.id for bonus assignments

        # Create bonus assignments for all challenges
        bonus_challenges = []
        if game.challenges:
            for ch in game.challenges:
                bonus = BonusAssignment(
                    main_assignment_id=assignment.id,
                    challenge_id=ch.id,
                )
                db.add(bonus)
                bonus_challenges.append(ch)

        # Log activity
        activity_data = {
            "game": game.title,
            "is_playthrough": True,
            "points": game.playthrough_points,
            "bonus_challenges_count": len(bonus_challenges),
        }
    else:
        # Regular challenge assignment
        assignment = Assignment(
            participant_id=participant.id,
            challenge_id=challenge.id,
            status=AssignmentStatus.ACTIVE.value,
            event_type=active_event.type if active_event else None,
        )
        db.add(assignment)

        # Log activity
        activity_data = {
            "game": game.title,
            "challenge": challenge.title,
            "difficulty": challenge.difficulty,
            "points": challenge.points,
        }
        if active_event:
            activity_data["event_type"] = active_event.type

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

    await db.commit()
    await db.refresh(assignment)

    # Calculate drop penalty
    if is_playthrough:
        drop_penalty = points_service.calculate_drop_penalty(
            participant.drop_count, game.playthrough_points, None  # No events for playthrough
        )
    else:
        drop_penalty = points_service.calculate_drop_penalty(
            participant.drop_count, challenge.points, active_event
        )

    # Get challenges count
    challenges_count = 0
    if 'challenges' in game.__dict__:
        challenges_count = len(game.challenges)
    else:
        challenges_count = await db.scalar(
            select(func.count()).select_from(Challenge).where(Challenge.game_id == game.id)
        )

    # Build response
    game_response = GameResponse(
        id=game.id,
        title=game.title,
        cover_url=storage_service.get_url(game.cover_path, "covers"),
        download_url=game.download_url,
        genre=game.genre,
        added_by=None,
        challenges_count=challenges_count,
        created_at=game.created_at,
        game_type=game.game_type,
        playthrough_points=game.playthrough_points,
        playthrough_description=game.playthrough_description,
        playthrough_proof_type=game.playthrough_proof_type,
        playthrough_proof_hint=game.playthrough_proof_hint,
    )

    if is_playthrough:
        # Return playthrough result
        return SpinResult(
            assignment_id=assignment.id,
            game=game_response,
            challenge=None,
            is_playthrough=True,
            playthrough_info=PlaythroughInfo(
                description=game.playthrough_description,
                points=game.playthrough_points,
                proof_type=game.playthrough_proof_type,
                proof_hint=game.playthrough_proof_hint,
            ),
            bonus_challenges=[
                ChallengeResponse(
                    id=ch.id,
                    title=ch.title,
                    description=ch.description,
                    type=ch.type,
                    difficulty=ch.difficulty,
                    points=ch.points,
                    estimated_time=ch.estimated_time,
                    proof_type=ch.proof_type,
                    proof_hint=ch.proof_hint,
                    game=GameShort(id=game.id, title=game.title, cover_url=None, download_url=game.download_url, game_type=game.game_type),
                    is_generated=ch.is_generated,
                    created_at=ch.created_at,
                )
                for ch in bonus_challenges
            ],
            can_drop=True,
            drop_penalty=drop_penalty,
        )
    else:
        # Return challenge result
        return SpinResult(
            assignment_id=assignment.id,
            game=game_response,
            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=None, download_url=game.download_url, game_type=game.game_type),
                is_generated=challenge.is_generated,
                created_at=challenge.created_at,
            ),
            is_playthrough=False,
            can_drop=True,
            drop_penalty=drop_penalty,
        )


@router.get("/marathons/{marathon_id}/current-assignment", response_model=AssignmentResponse | None)
async def get_current_assignment(marathon_id: int, current_user: CurrentUser, db: DbSession):
    """Get current active regular assignment (not event assignments)"""
    participant = await get_participant_or_403(db, current_user.id, marathon_id)
    assignment = await get_active_assignment(db, participant.id, is_event=False)

    # If no active assignment, check for returned assignments
    if not assignment:
        returned = await get_oldest_returned_assignment(db, participant.id)
        if returned:
            # Activate the returned assignment
            await activate_returned_assignment(db, returned)
            await db.commit()
            # Reload with all relationships
            assignment = await get_active_assignment(db, participant.id, is_event=False)

    if not assignment:
        return None

    # Handle playthrough assignments
    if assignment.is_playthrough:
        game = assignment.game
        active_event = None  # No events for playthrough
        drop_penalty = points_service.calculate_drop_penalty(
            participant.drop_count, game.playthrough_points, None
        )

        # Build bonus challenges response
        from app.schemas.assignment import BonusAssignmentResponse
        bonus_responses = []
        for ba in assignment.bonus_assignments:
            bonus_responses.append(BonusAssignmentResponse(
                id=ba.id,
                challenge=ChallengeResponse(
                    id=ba.challenge.id,
                    title=ba.challenge.title,
                    description=ba.challenge.description,
                    type=ba.challenge.type,
                    difficulty=ba.challenge.difficulty,
                    points=ba.challenge.points,
                    estimated_time=ba.challenge.estimated_time,
                    proof_type=ba.challenge.proof_type,
                    proof_hint=ba.challenge.proof_hint,
                    game=GameShort(id=game.id, title=game.title, cover_url=None, download_url=game.download_url, game_type=game.game_type),
                    is_generated=ba.challenge.is_generated,
                    created_at=ba.challenge.created_at,
                ),
                status=ba.status,
                proof_url=ba.proof_url,
                proof_comment=ba.proof_comment,
                points_earned=ba.points_earned,
                completed_at=ba.completed_at,
            ))

        return AssignmentResponse(
            id=assignment.id,
            challenge=None,
            game=GameShort(id=game.id, title=game.title, cover_url=None, download_url=game.download_url, game_type=game.game_type),
            is_playthrough=True,
            playthrough_info=PlaythroughInfo(
                description=game.playthrough_description,
                points=game.playthrough_points,
                proof_type=game.playthrough_proof_type,
                proof_hint=game.playthrough_proof_hint,
            ),
            status=assignment.status,
            proof_url=storage_service.get_url(assignment.proof_path, "proofs") 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,
            drop_penalty=drop_penalty,
            bonus_challenges=bonus_responses,
        )

    # Regular challenge assignment
    challenge = assignment.challenge
    game = challenge.game

    # Calculate drop penalty (considers active event for double_risk)
    active_event = await event_service.get_active_event(db, marathon_id)
    drop_penalty = points_service.calculate_drop_penalty(participant.drop_count, challenge.points, active_event)

    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=None, download_url=game.download_url, game_type=game.game_type),
            is_generated=challenge.is_generated,
            created_at=challenge.created_at,
        ),
        status=assignment.status,
        proof_url=storage_service.get_url(assignment.proof_path, "proofs") 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,
        drop_penalty=drop_penalty,
    )


@router.post("/assignments/{assignment_id}/complete", response_model=CompleteResult)
async def complete_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),  # Legacy single file support
    proof_files: list[UploadFile] = File([]),  # Multiple files support
):
    """Complete a regular assignment with proof (not event assignments)"""
    # Get assignment with all needed relationships
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.participant),
            selectinload(Assignment.challenge).selectinload(Challenge.game),
            selectinload(Assignment.game),  # For playthrough
            selectinload(Assignment.bonus_assignments).selectinload(BonusAssignment.challenge),  # For bonus points
            selectinload(Assignment.dispute),  # To check if it was previously disputed
        )
        .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")

    # Event assignments should be completed via /event-assignments/{id}/complete
    if assignment.is_event_assignment:
        raise HTTPException(status_code=400, detail="Use /event-assignments/{id}/complete for event assignments")

    # Combine legacy single file with new multiple files
    all_files = []
    if proof_file:
        all_files.append(proof_file)
    if proof_files:
        all_files.extend(proof_files)

    # For playthrough: need either file(s) or URL or comment (proof is flexible)
    # For challenges: need either file(s) or URL
    if assignment.is_playthrough:
        if not all_files and not proof_url and not comment:
            raise HTTPException(status_code=400, detail="Proof is required (file, URL, or comment)")
    else:
        if not all_files and not proof_url:
            raise HTTPException(status_code=400, detail="Proof is required (file or URL)")

    # Handle multiple file uploads
    if all_files:
        from app.models import AssignmentProof

        for idx, file in enumerate(all_files):
            contents = await file.read()
            if len(contents) > settings.MAX_UPLOAD_SIZE:
                raise HTTPException(
                    status_code=400,
                    detail=f"File {file.filename} too large. Maximum size is {settings.MAX_UPLOAD_SIZE // 1024 // 1024} MB",
                )

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

            # Determine file type (image or video)
            file_type = "video" if ext in ["mp4", "webm", "mov", "avi"] else "image"

            # Upload file to storage
            filename = storage_service.generate_filename(f"{assignment_id}_{idx}", file.filename)
            file_path = await storage_service.upload_file(
                content=contents,
                folder="proofs",
                filename=filename,
                content_type=file.content_type or "application/octet-stream",
            )

            # Create AssignmentProof record
            proof_record = AssignmentProof(
                assignment_id=assignment_id,
                file_path=file_path,
                file_type=file_type,
                order_index=idx
            )
            db.add(proof_record)

            # Legacy: set proof_path on first file for backward compatibility
            if idx == 0:
                assignment.proof_path = file_path

    # Set proof URL if provided
    if proof_url:
        assignment.proof_url = proof_url

    assignment.proof_comment = comment

    participant = assignment.participant

    # Handle playthrough completion
    if assignment.is_playthrough:
        game = assignment.game
        marathon_id = game.marathon_id
        base_points = game.playthrough_points

        # No events for playthrough
        total_points, streak_bonus, _ = points_service.calculate_completion_points(
            base_points, participant.current_streak, None
        )

        # Calculate bonus points from completed bonus assignments
        bonus_points = sum(
            ba.points_earned for ba in assignment.bonus_assignments
            if ba.status == BonusAssignmentStatus.COMPLETED.value
        )
        total_points += bonus_points

        # Apply boost multiplier from consumable
        boost_multiplier = consumables_service.get_active_boost_multiplier(participant)
        if boost_multiplier > 1.0:
            total_points = int(total_points * boost_multiplier)

        # Update assignment
        assignment.status = AssignmentStatus.COMPLETED.value
        assignment.points_earned = total_points
        assignment.streak_at_completion = participant.current_streak + 1
        assignment.completed_at = datetime.utcnow()

        # Update participant
        participant.total_points += total_points
        participant.current_streak += 1
        participant.drop_count = 0

        # Get marathon and award coins if certified
        marathon_result = await db.execute(select(Marathon).where(Marathon.id == marathon_id))
        marathon = marathon_result.scalar_one()
        coins_earned = 0
        if marathon.is_certified:
            coins_earned = await coins_service.award_playthrough_coins(
                db, current_user, participant, marathon, total_points, assignment.id
            )

        # Check if this is a redo of a previously disputed assignment
        is_redo = (
            assignment.dispute is not None and
            assignment.dispute.status == DisputeStatus.RESOLVED_INVALID.value
        )

        # Log activity
        activity_data = {
            "assignment_id": assignment.id,
            "game": game.title,
            "is_playthrough": True,
            "points": total_points,
            "base_points": base_points,
            "bonus_points": bonus_points,
            "streak": participant.current_streak,
        }
        if is_redo:
            activity_data["is_redo"] = True
        if boost_multiplier > 1.0:
            activity_data["boost_multiplier"] = boost_multiplier
        if coins_earned > 0:
            activity_data["coins_earned"] = coins_earned

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

        await db.commit()

        # Check for returned assignments
        returned_assignment = await get_oldest_returned_assignment(db, participant.id)
        if returned_assignment:
            await activate_returned_assignment(db, returned_assignment)
            await db.commit()

        return CompleteResult(
            points_earned=total_points,
            streak_bonus=streak_bonus,
            total_points=participant.total_points,
            new_streak=participant.current_streak,
            coins_earned=coins_earned,
        )

    # Regular challenge completion
    challenge = assignment.challenge
    marathon_id = challenge.game.marathon_id

    # Check active event for point multipliers
    active_event = await event_service.get_active_event(db, marathon_id)

    # For jackpot: use the event_type stored in assignment (since event may be over)
    effective_event = active_event

    # Handle assignment-level event types (jackpot)
    if assignment.event_type == EventType.JACKPOT.value:
        class MockEvent:
            def __init__(self, event_type):
                self.type = event_type
        effective_event = MockEvent(assignment.event_type)

    total_points, streak_bonus, event_bonus = points_service.calculate_completion_points(
        challenge.points, participant.current_streak, effective_event
    )

    # 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 += common_enemy_bonus
        print(f"[COMMON_ENEMY] bonus={common_enemy_bonus}, closed={common_enemy_closed}, winners={common_enemy_winners}")

    # Apply boost multiplier from consumable
    boost_multiplier = consumables_service.get_active_boost_multiplier(participant)
    if boost_multiplier > 1.0:
        total_points = int(total_points * boost_multiplier)

    # Update assignment
    assignment.status = AssignmentStatus.COMPLETED.value
    assignment.points_earned = total_points
    assignment.streak_at_completion = participant.current_streak + 1
    assignment.completed_at = datetime.utcnow()

    # Update participant
    participant.total_points += total_points
    participant.current_streak += 1
    participant.drop_count = 0

    # Get marathon and award coins if certified
    marathon_result = await db.execute(select(Marathon).where(Marathon.id == marathon_id))
    marathon = marathon_result.scalar_one()
    coins_earned = 0
    if marathon.is_certified:
        coins_earned = await coins_service.award_challenge_coins(
            db, current_user, participant, marathon, challenge.difficulty, assignment.id
        )

    # Check if this is a redo of a previously disputed assignment
    is_redo = (
        assignment.dispute is not None and
        assignment.dispute.status == DisputeStatus.RESOLVED_INVALID.value
    )

    # Log activity
    activity_data = {
        "assignment_id": assignment.id,
        "game": challenge.game.title,
        "challenge": challenge.title,
        "difficulty": challenge.difficulty,
        "points": total_points,
        "streak": participant.current_streak,
    }
    if is_redo:
        activity_data["is_redo"] = True
    if boost_multiplier > 1.0:
        activity_data["boost_multiplier"] = boost_multiplier
    if coins_earned > 0:
        activity_data["coins_earned"] = coins_earned
    if assignment.event_type == EventType.JACKPOT.value:
        activity_data["event_type"] = assignment.event_type
        activity_data["event_bonus"] = event_bonus
    elif active_event:
        activity_data["event_type"] = active_event.type
        activity_data["event_bonus"] = event_bonus
    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:
        from app.schemas.event import EVENT_INFO, COMMON_ENEMY_BONUSES
        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
        ]
        print(f"[COMMON_ENEMY] Creating event_end activity with winners: {winners_data}")

        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()

    # Check for returned assignments
    returned_assignment = await get_oldest_returned_assignment(db, participant.id)
    if returned_assignment:
        await activate_returned_assignment(db, returned_assignment)
        await db.commit()
        print(f"[WHEEL] Auto-activated returned assignment {returned_assignment.id} for participant {participant.id}")

    return CompleteResult(
        points_earned=total_points,
        streak_bonus=streak_bonus,
        total_points=participant.total_points,
        new_streak=participant.current_streak,
        coins_earned=coins_earned,
    )


@router.post("/assignments/{assignment_id}/drop", response_model=DropResult)
async def drop_assignment(assignment_id: int, current_user: CurrentUser, db: DbSession):
    """Drop current assignment"""
    # Get assignment with all needed relationships
    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.participant),
            selectinload(Assignment.challenge).selectinload(Challenge.game),
            selectinload(Assignment.game),  # For playthrough
            selectinload(Assignment.bonus_assignments),  # For resetting bonuses on drop
        )
        .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")

    participant = assignment.participant

    # Handle playthrough drop
    if assignment.is_playthrough:
        game = assignment.game
        marathon_id = game.marathon_id

        # No events for playthrough
        penalty = points_service.calculate_drop_penalty(
            participant.drop_count, game.playthrough_points, None
        )

        # Check for shield - if active, no penalty
        shield_used = False
        if consumables_service.consume_shield(participant):
            penalty = 0
            shield_used = True

        # Update assignment
        assignment.status = AssignmentStatus.DROPPED.value
        assignment.completed_at = datetime.utcnow()

        # Reset all bonus assignments (lose any completed bonuses)
        completed_bonuses_count = 0
        for ba in assignment.bonus_assignments:
            if ba.status == BonusAssignmentStatus.COMPLETED.value:
                completed_bonuses_count += 1
            ba.status = BonusAssignmentStatus.PENDING.value
            ba.proof_path = None
            ba.proof_url = None
            ba.proof_comment = None
            ba.points_earned = 0
            ba.completed_at = None

        # Update participant
        participant.total_points = max(0, participant.total_points - penalty)
        participant.current_streak = 0
        participant.drop_count += 1

        # Log activity
        activity_data = {
            "game": game.title,
            "is_playthrough": True,
            "penalty": penalty,
            "lost_bonuses": completed_bonuses_count,
        }
        if shield_used:
            activity_data["shield_used"] = True

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

        await db.commit()

        return DropResult(
            penalty=penalty,
            total_points=participant.total_points,
            new_drop_count=participant.drop_count,
            shield_used=shield_used,
        )

    # Regular challenge drop
    marathon_id = assignment.challenge.game.marathon_id

    # Check active event for free drops (double_risk)
    active_event = await event_service.get_active_event(db, marathon_id)

    # Calculate penalty (0 if double_risk event is active)
    penalty = points_service.calculate_drop_penalty(participant.drop_count, assignment.challenge.points, active_event)

    # Check for shield - if active, no penalty
    shield_used = False
    if consumables_service.consume_shield(participant):
        penalty = 0
        shield_used = True

    # Update assignment
    assignment.status = AssignmentStatus.DROPPED.value
    assignment.completed_at = datetime.utcnow()

    # Update participant
    participant.total_points = max(0, participant.total_points - penalty)
    participant.current_streak = 0
    participant.drop_count += 1

    # Log activity
    activity_data = {
        "game": assignment.challenge.game.title,
        "challenge": assignment.challenge.title,
        "difficulty": assignment.challenge.difficulty,
        "penalty": penalty,
    }
    if shield_used:
        activity_data["shield_used"] = True
    if active_event:
        activity_data["event_type"] = active_event.type
        if active_event.type == EventType.DOUBLE_RISK.value:
            activity_data["free_drop"] = True

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

    await db.commit()

    return DropResult(
        penalty=penalty,
        total_points=participant.total_points,
        new_drop_count=participant.drop_count,
        shield_used=shield_used,
    )


@router.get("/marathons/{marathon_id}/my-history", response_model=list[AssignmentResponse])
async def get_my_history(
    marathon_id: int,
    current_user: CurrentUser,
    db: DbSession,
    limit: int = 20,
    offset: int = 0,
):
    """Get history of user's assignments in marathon"""
    participant = await get_participant_or_403(db, current_user.id, marathon_id)

    result = await db.execute(
        select(Assignment)
        .options(
            selectinload(Assignment.challenge).selectinload(Challenge.game),
            selectinload(Assignment.game),  # For playthrough
            selectinload(Assignment.bonus_assignments).selectinload(BonusAssignment.challenge),  # For playthrough bonuses
        )
        .where(Assignment.participant_id == participant.id)
        .order_by(Assignment.started_at.desc())
        .limit(limit)
        .offset(offset)
    )
    assignments = result.scalars().all()

    responses = []
    for a in assignments:
        if a.is_playthrough:
            # Playthrough assignment
            game = a.game
            from app.schemas.assignment import BonusAssignmentResponse
            bonus_responses = [
                BonusAssignmentResponse(
                    id=ba.id,
                    challenge=ChallengeResponse(
                        id=ba.challenge.id,
                        title=ba.challenge.title,
                        description=ba.challenge.description,
                        type=ba.challenge.type,
                        difficulty=ba.challenge.difficulty,
                        points=ba.challenge.points,
                        estimated_time=ba.challenge.estimated_time,
                        proof_type=ba.challenge.proof_type,
                        proof_hint=ba.challenge.proof_hint,
                        game=GameShort(id=game.id, title=game.title, cover_url=None, download_url=game.download_url, game_type=game.game_type),
                        is_generated=ba.challenge.is_generated,
                        created_at=ba.challenge.created_at,
                    ),
                    status=ba.status,
                    proof_url=ba.proof_url,
                    proof_comment=ba.proof_comment,
                    points_earned=ba.points_earned,
                    completed_at=ba.completed_at,
                )
                for ba in a.bonus_assignments
            ]

            responses.append(AssignmentResponse(
                id=a.id,
                challenge=None,
                game=GameShort(id=game.id, title=game.title, cover_url=None, download_url=game.download_url, game_type=game.game_type),
                is_playthrough=True,
                playthrough_info=PlaythroughInfo(
                    description=game.playthrough_description,
                    points=game.playthrough_points,
                    proof_type=game.playthrough_proof_type,
                    proof_hint=game.playthrough_proof_hint,
                ),
                status=a.status,
                proof_url=storage_service.get_url(a.proof_path, "proofs") if a.proof_path else a.proof_url,
                proof_comment=a.proof_comment,
                points_earned=a.points_earned,
                streak_at_completion=a.streak_at_completion,
                started_at=a.started_at,
                completed_at=a.completed_at,
                bonus_challenges=bonus_responses,
            ))
        else:
            # Regular challenge assignment
            responses.append(AssignmentResponse(
                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,
                        download_url=a.challenge.game.download_url,
                        game_type=a.challenge.game.game_type,
                    ),
                    is_generated=a.challenge.is_generated,
                    created_at=a.challenge.created_at,
                ),
                status=a.status,
                proof_url=storage_service.get_url(a.proof_path, "proofs") if a.proof_path else a.proof_url,
                proof_comment=a.proof_comment,
                points_earned=a.points_earned,
                streak_at_completion=a.streak_at_completion,
                started_at=a.started_at,
                completed_at=a.completed_at,
            ))

    return responses