from fastapi import APIRouter, Depends, HTTPException, status
from fastapi.params import Path, Query
from sqlalchemy.orm import Session
from src.apps.wine.global_noise.services.global_noise import (
    get_all_global_noise_service,
    get_global_noise_by_id_service,
    create_global_noise,
    update_global_noise,
    delete_global_noise,
    download_noise_service
)
from src.apps.wine.global_noise.schemas.global_noise import (
    GlobalNoiseCreateSchema,
    GlobalNoiseFilterSchema,
    GlobalNoiseOutputSchema,
    GlobalNoiseUpdateSchema
)
from src.core.dependencies import get_db
from src.utils import constants
from src.utils.guard import get_current_user
from src.apps.base.schemas.response_model import ResponseModel

router = APIRouter()


@router.get("", response_model=ResponseModel, summary="Get all global noise entries")
async def get_all_global_noise_list(
    payload: GlobalNoiseFilterSchema = Depends(),
    sort_by: str = Query(
        default="-created_at",
        description=(
            "Sort by fields, prefix with '-' for descending order. "
            "Allowed fields: create_at, updated_at, noise. "
            "Multiple fields can be separated by commas."
        ),
    ),
    page: int = Query(default=1, ge=1, description="Page number"),
    per_page: int = Query(
        default=constants.DEFAULT_PER_PAGE,
        ge=1,
        le=constants.MAX_PER_PAGE,
        description="Items per page",
    ),
    db: Session = Depends(get_db),
):
    response= await get_all_global_noise_service(
        db=db, 
        page=page, 
        per_page=per_page, 
        payload=payload, 
        sort_by=sort_by.split(",") if sort_by else []
    )
    return ResponseModel(
        data=response, 
        status_code=status.HTTP_200_OK, 
        success=True,
        message="Record fetched successfully"
    )
    
@router.get("/download", summary="Download all global noise entries")
async def download_global_noise_list(
    payload: GlobalNoiseFilterSchema = Depends(),
    db: Session = Depends(get_db),
):
    return await download_noise_service(db=db, payload=payload)
  
    
@router.post("", response_model=ResponseModel, status_code=status.HTTP_201_CREATED, summary="Create a new global noise entry")
async def create_new_global_noise(
    payload: GlobalNoiseCreateSchema,
    db: Session = Depends(get_db),
):
    response = await create_global_noise(db, payload)
    return ResponseModel(
        data=response, 
        status_code=status.HTTP_201_CREATED, 
        success=True,
        message="Record created successfully"
    )
  
    
@router.get("/{global_noise_id}", response_model=ResponseModel, summary="Get a global noise entry by ID")
async def get_global_noise_by_id(
    global_noise_id: int,
    db: Session = Depends(get_db),
):
    response = await get_global_noise_by_id_service(db, global_noise_id)
    return ResponseModel(
        data=GlobalNoiseOutputSchema.model_validate(response), 
        status_code=status.HTTP_200_OK, 
        success=True,
        message="Record fetched successfully"
    )
    
@router.put("/{global_noise_id}", response_model=ResponseModel, summary="Update a global noise entry by ID")
async def update_global_noise_by_id(
    global_noise_id: int,
    payload: GlobalNoiseUpdateSchema,
    db: Session = Depends(get_db),
):
    response = await update_global_noise(db, global_noise_id, payload)
    return ResponseModel(
        data=response, 
        status_code=status.HTTP_200_OK, 
        success=True,
        message="Record updated successfully"
    )
    
@router.delete("/{global_noise_id}", response_model=ResponseModel, summary="Delete a global noise entry by ID")
async def delete_global_noise_by_id(
    global_noise_id: int,
    db: Session = Depends(get_db),
):
    response = await delete_global_noise(db, global_noise_id)
    return ResponseModel(
        data=response, 
        status_code=status.HTTP_200_OK, 
        success=True,
        message="Record deleted successfully"
    )