from fastapi import APIRouter, Depends, HTTPException, status
from api.dependency import get_inspiration_service, get_project_id
from api.endpoints.auth import get_current_user
from api.models.InspirationRequest import InspirationCreateRequest, InspirationResponse, InspirationListResponse
from api.service.inspiration_service import InspirationService
from models.Inspiration import Inspiration

router = APIRouter(prefix="/api/inspirations", tags=["Inspirations"])


@router.post("", response_model=InspirationResponse, status_code=status.HTTP_201_CREATED)
async def create_inspiration(
    request: InspirationCreateRequest,
    project_id: str | None = Depends(get_project_id),
    current_user: dict = Depends(get_current_user),
    service: InspirationService = Depends(get_inspiration_service)
):
    pid = project_id or request.project_id
    
    inspiration = await service.create_inspiration(
        source_url=request.source_url,
        created_by=str(current_user["_id"]),
        project_id=pid,
        caption=request.caption
    )
    return inspiration


@router.get("", response_model=InspirationListResponse)
async def get_inspirations(
    project_id: str | None = Depends(get_project_id),
    limit: int = 20,
    offset: int = 0,
    current_user: dict = Depends(get_current_user),
    service: InspirationService = Depends(get_inspiration_service)
):
    # If project_id is provided, filter by it. Otherwise, filter by user.
    # Or maybe we want to see all user's inspirations if no project is selected?
    # Let's follow the pattern: if project_id is present, show project's inspirations.
    # If not, show user's personal inspirations (where project_id is None) OR all user's inspirations?
    # Usually "My Inspirations" means created by me.
    
    # Let's assume:
    # If project_id -> filter by project_id (and maybe created_by if we want strict ownership, but usually project members share)
    # If no project_id -> filter by created_by (personal)
    
    pid = project_id
    uid = str(current_user["_id"])
    
    inspirations = await service.get_inspirations(project_id=pid, created_by=uid if not pid else None, limit=limit, offset=offset)
    total_count = await service.dao.inspirations.count_inspirations(project_id=pid, created_by=uid if not pid else None)
    
    return InspirationListResponse(
        inspirations=[InspirationResponse(**inspiration.model_dump()) for inspiration in inspirations],
        total_count=total_count
    )


@router.get("/{inspiration_id}", response_model=InspirationResponse)
async def get_inspiration(
    inspiration_id: str,
    service: InspirationService = Depends(get_inspiration_service),
    current_user: dict = Depends(get_current_user)
):
    inspiration = await service.get_inspiration(inspiration_id)
    if not inspiration:
        raise HTTPException(status_code=404, detail="Inspiration not found")
    return inspiration


@router.patch("/{inspiration_id}/complete", response_model=InspirationResponse)
async def mark_inspiration_complete(
    inspiration_id: str,
    is_completed: bool = True,
    service: InspirationService = Depends(get_inspiration_service),
    current_user: dict = Depends(get_current_user)
):
    inspiration = await service.mark_as_completed(inspiration_id, is_completed)
    if not inspiration:
        raise HTTPException(status_code=404, detail="Inspiration not found")
    return inspiration


@router.delete("/{inspiration_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_inspiration(
    inspiration_id: str,
    service: InspirationService = Depends(get_inspiration_service),
    current_user: dict = Depends(get_current_user)
):
    success = await service.delete_inspiration(inspiration_id)
    if not success:
        raise HTTPException(status_code=404, detail="Inspiration not found")
    return None