from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, status, Request
from pydantic import BaseModel

from api.models.GenerationRequest import GenerationResponse
from models.Album import Album
from repos.dao import DAO

router = APIRouter(prefix="/api/albums", tags=["Albums"])

class AlbumCreateRequest(BaseModel):
    name: str
    description: Optional[str] = None

class AlbumUpdateRequest(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None

class AlbumResponse(BaseModel):
    id: str
    name: str
    description: Optional[str] = None
    generation_ids: List[str] = []
    cover_asset_id: Optional[str] = None # Not implemented yet

@router.post("", response_model=AlbumResponse)
async def create_album(request: Request, album_in: AlbumCreateRequest):
    service: AlbumService = request.app.state.album_service
    album = await service.create_album(name=album_in.name, description=album_in.description)
    return AlbumResponse(**album.model_dump())

@router.get("", response_model=List[AlbumResponse])
async def get_albums(request: Request, limit: int = 10, offset: int = 0):
    service: AlbumService = request.app.state.album_service
    albums = await service.get_albums(limit=limit, offset=offset)
    return [AlbumResponse(**album.model_dump()) for album in albums]

@router.get("/{album_id}", response_model=AlbumResponse)
async def get_album(request: Request, album_id: str):
    service: AlbumService = request.app.state.album_service
    album = await service.get_album(album_id)
    if not album:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Album not found")
    return AlbumResponse(**album.model_dump())

@router.put("/{album_id}", response_model=AlbumResponse)
async def update_album(request: Request, album_id: str, album_in: AlbumUpdateRequest):
    service: AlbumService = request.app.state.album_service
    album = await service.update_album(album_id, name=album_in.name, description=album_in.description)
    if not album:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Album not found")
    return AlbumResponse(**album.model_dump())

@router.delete("/{album_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_album(request: Request, album_id: str):
    service: AlbumService = request.app.state.album_service
    deleted = await service.delete_album(album_id)
    if not deleted:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Album not found")

@router.post("/{album_id}/generations/{generation_id}")
async def add_generation_to_album(request: Request, album_id: str, generation_id: str):
    service: AlbumService = request.app.state.album_service
    success = await service.add_generation_to_album(album_id, generation_id)
    if not success:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Album or Generation not found")
    return {"status": "success"}

@router.delete("/{album_id}/generations/{generation_id}")
async def remove_generation_from_album(request: Request, album_id: str, generation_id: str):
    service: AlbumService = request.app.state.album_service
    success = await service.remove_generation_from_album(album_id, generation_id)
    if not success:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Album or Generation not found")
    return {"status": "success"}

@router.get("/{album_id}/generations", response_model=List[GenerationResponse])
async def get_album_generations(request: Request, album_id: str, limit: int = 10, offset: int = 0):
    service: AlbumService = request.app.state.album_service
    generations = await service.get_generations_by_album(album_id, limit=limit, offset=offset)
    return [GenerationResponse(**gen.model_dump()) for gen in generations]