bakery-ia/services/demo_session/app/api/demo_sessions.py

"""
Demo Sessions API - Atomic CRUD operations on DemoSession model
"""

from fastapi import APIRouter, Depends, HTTPException, Path, Query, Request
from typing import Optional
from uuid import UUID
import structlog
import jwt

from app.api.schemas import DemoSessionCreate, DemoSessionResponse
from app.services import DemoSessionManager
from app.core import get_db, get_redis, RedisClient
from sqlalchemy.ext.asyncio import AsyncSession
from shared.routing import RouteBuilder

router = APIRouter(tags=["demo-sessions"])
logger = structlog.get_logger()

route_builder = RouteBuilder('demo')


async def _background_cloning_task(session_id: str, session_obj_id: UUID, base_tenant_id: str):
    """Background task for orchestrated cloning - creates its own DB session"""
    from app.core.database import db_manager
    from app.models import DemoSession
    from sqlalchemy import select

    # Create new database session for background task
    async with db_manager.session_factory() as db:
        try:
            # Get Redis client
            redis = await get_redis()

            # Fetch the session from the database
            result = await db.execute(
                select(DemoSession).where(DemoSession.id == session_obj_id)
            )
            session = result.scalar_one_or_none()

            if not session:
                logger.error("Session not found for cloning", session_id=session_id)
                return

            # Create session manager with new DB session
            session_manager = DemoSessionManager(db, redis)
            await session_manager.trigger_orchestrated_cloning(session, base_tenant_id)

        except Exception as e:
            logger.error(
                "Background cloning failed",
                session_id=session_id,
                error=str(e),
                exc_info=True
            )


@router.post(
    route_builder.build_base_route("sessions", include_tenant_prefix=False),
    response_model=DemoSessionResponse,
    status_code=201
)
async def create_demo_session(
    request: DemoSessionCreate,
    http_request: Request,
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """Create a new isolated demo session (ATOMIC)"""
    logger.info("Creating demo session", demo_account_type=request.demo_account_type)

    try:
        ip_address = request.ip_address or http_request.client.host
        user_agent = request.user_agent or http_request.headers.get("user-agent", "")

        session_manager = DemoSessionManager(db, redis)
        session = await session_manager.create_session(
            demo_account_type=request.demo_account_type,
            user_id=request.user_id,
            ip_address=ip_address,
            user_agent=user_agent
        )

        # Trigger async orchestrated cloning in background
        import asyncio
        from app.core.config import settings
        from app.models import DemoSession

        # Get base tenant ID from config
        demo_config = settings.DEMO_ACCOUNTS.get(request.demo_account_type, {})
        base_tenant_id = demo_config.get("base_tenant_id", str(session.base_demo_tenant_id))

        # Start cloning in background task with session ID (not session object)
        asyncio.create_task(
            _background_cloning_task(session.session_id, session.id, base_tenant_id)
        )

        # Generate session token
        session_token = jwt.encode(
            {
                "session_id": session.session_id,
                "virtual_tenant_id": str(session.virtual_tenant_id),
                "demo_account_type": request.demo_account_type,
                "exp": session.expires_at.timestamp()
            },
            "demo-secret-key",
            algorithm="HS256"
        )

        return {
            "session_id": session.session_id,
            "virtual_tenant_id": str(session.virtual_tenant_id),
            "demo_account_type": session.demo_account_type,
            "status": session.status.value,
            "created_at": session.created_at,
            "expires_at": session.expires_at,
            "demo_config": session.session_metadata.get("demo_config", {}),
            "session_token": session_token
        }

    except Exception as e:
        logger.error("Failed to create demo session", error=str(e))
        raise HTTPException(status_code=500, detail=f"Failed to create demo session: {str(e)}")


@router.get(
    route_builder.build_resource_detail_route("sessions", "session_id", include_tenant_prefix=False),
    response_model=dict
)
async def get_session_info(
    session_id: str = Path(...),
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """Get demo session information (ATOMIC READ)"""
    session_manager = DemoSessionManager(db, redis)
    session = await session_manager.get_session(session_id)

    if not session:
        raise HTTPException(status_code=404, detail="Session not found")

    return session.to_dict()


@router.get(
    route_builder.build_resource_detail_route("sessions", "session_id", include_tenant_prefix=False) + "/status",
    response_model=dict
)
async def get_session_status(
    session_id: str = Path(...),
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """
    Get demo session provisioning status

    Returns current status of data cloning and readiness.
    Use this endpoint for polling (recommended interval: 1-2 seconds).
    """
    session_manager = DemoSessionManager(db, redis)
    status = await session_manager.get_session_status(session_id)

    if not status:
        raise HTTPException(status_code=404, detail="Session not found")

    return status


@router.post(
    route_builder.build_resource_detail_route("sessions", "session_id", include_tenant_prefix=False) + "/retry",
    response_model=dict
)
async def retry_session_cloning(
    session_id: str = Path(...),
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """
    Retry failed cloning operations

    Only available for sessions in "failed" or "partial" status.
    """
    try:
        session_manager = DemoSessionManager(db, redis)
        result = await session_manager.retry_failed_cloning(session_id)

        return {
            "message": "Cloning retry initiated",
            "session_id": session_id,
            "result": result
        }

    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error("Failed to retry cloning", error=str(e))
        raise HTTPException(status_code=500, detail=str(e))


@router.delete(
    route_builder.build_resource_detail_route("sessions", "session_id", include_tenant_prefix=False),
    response_model=dict
)
async def destroy_demo_session(
    session_id: str = Path(...),
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """Destroy demo session and cleanup resources (ATOMIC DELETE)"""
    try:
        session_manager = DemoSessionManager(db, redis)
        await session_manager.destroy_session(session_id)

        return {"message": "Session destroyed successfully", "session_id": session_id}

    except Exception as e:
        logger.error("Failed to destroy session", error=str(e))
        raise HTTPException(status_code=500, detail=str(e))


@router.post(
    route_builder.build_resource_detail_route("sessions", "session_id", include_tenant_prefix=False) + "/destroy",
    response_model=dict
)
async def destroy_demo_session_post(
    session_id: str = Path(...),
    db: AsyncSession = Depends(get_db),
    redis: RedisClient = Depends(get_redis)
):
    """Destroy demo session via POST (for frontend compatibility)"""
    try:
        session_manager = DemoSessionManager(db, redis)
        await session_manager.destroy_session(session_id)

        return {"message": "Session destroyed successfully", "session_id": session_id}

    except Exception as e:
        logger.error("Failed to destroy session", error=str(e))
        raise HTTPException(status_code=500, detail=str(e))