"""
DenialPattern API Router
Enterprise-grade FastAPI router with full CRUD operations
Architecture: Routers → Services/CRUD → SQLAlchemy Models + Pydantic Schemas
"""
from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session
from uuid import UUID

from src.config.database import get_db
from src.services.denial_pattern_service import DenialPatternCRUD
from src.validation.denial_pattern_schemas import (
    DenialPatternCreate,
    DenialPatternUpdate,
    DenialPatternResponse,
    DenialPatternListResponse,
)

router = APIRouter(prefix="/denialpatterns", tags=["DenialPattern"])

def get_crud(db: Session = Depends(get_db)) -> DenialPatternCRUD:
    """Dependency injection for DenialPatternCRUD"""
    return DenialPatternCRUD(db)

@router.get("/", response_model=DenialPatternListResponse)
async def list_denial_patterns(
    skip: int = Query(0, ge=0, description="Number of records to skip"),
    limit: int = Query(100, ge=1, le=1000, description="Maximum records to return"),
    crud: DenialPatternCRUD = Depends(get_crud),
):
    """
    List all denialpatterns with pagination and filtering.
    
    - **skip**: Number of records to skip (for pagination)
    - **limit**: Maximum number of records to return
    """
    items, total = await crud.get_all(skip=skip, limit=limit)
    
    return DenialPatternListResponse(
        items=items,
        total=total,
        skip=skip,
        limit=limit,
        has_more=skip + limit < total
    )

@router.get("/{ denial_pattern_id }", response_model=DenialPatternResponse)
async def get_denial_pattern(
    denial_pattern_id: UUID,
    crud: DenialPatternCRUD = Depends(get_crud),
):
    """
    Get a specific denialpattern by ID.
    
    - **denial_pattern_id**: The UUID of the denialpattern
    """
    db_denial_pattern = await crud.get_by_id(denial_pattern_id)
    if not db_denial_pattern:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"DenialPattern with id { denial_pattern_id} not found"
        )
    return db_denial_pattern

@router.post("/", response_model=DenialPatternResponse, status_code=status.HTTP_201_CREATED)
async def create_denial_pattern(
    denial_pattern_in: DenialPatternCreate,
    crud: DenialPatternCRUD = Depends(get_crud),
):
    """
    Create a new denialpattern.
    
    - **denial_pattern_in**: The denialpattern data to create
    """
    return await crud.create(denial_pattern_in)

@router.put("/{ denial_pattern_id }", response_model=DenialPatternResponse)
async def update_denial_pattern(
    denial_pattern_id: UUID,
    denial_pattern_in: DenialPatternUpdate,
    crud: DenialPatternCRUD = Depends(get_crud),
):
    """
    Update an existing denialpattern.
    
    - **denial_pattern_id**: The UUID of the denialpattern to update
    - **denial_pattern_in**: The updated denialpattern data
    """
    db_denial_pattern = await crud.get_by_id(denial_pattern_id)
    if not db_denial_pattern:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"DenialPattern with id { denial_pattern_id} not found"
        )
    return await crud.update(denial_pattern_id, denial_pattern_in)

@router.delete("/{ denial_pattern_id }", status_code=status.HTTP_204_NO_CONTENT)
async def delete_denial_pattern(
    denial_pattern_id: UUID,
    crud: DenialPatternCRUD = Depends(get_crud),
):
    """
    Delete a denialpattern.
    
    - **denial_pattern_id**: The UUID of the denialpattern to delete
    """
    db_denial_pattern = await crud.get_by_id(denial_pattern_id)
    if not db_denial_pattern:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"DenialPattern with id { denial_pattern_id} not found"
        )
    await crud.delete(denial_pattern_id)
    return None