from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session

from app.database import get_db
from app.dependencies import require_admin_token
from app.models import User
from app.schemas import (
    ContentPageOut,
    FaqCreateRequest,
    FaqIdRequest,
    FaqListResponse,
    FaqOut,
    FaqUpdateRequest,
    Message,
    SaveContentRequest,
)
from app.services.admin_service import (
    create_faq,
    delete_faq,
    get_content_page,
    get_faq,
    list_faqs,
    save_content_page,
    serialize_content_page,
    serialize_faq,
    update_faq,
)

router = APIRouter(tags=["admin-content"])


@router.get(
    "/get-content",
    response_model=ContentPageOut,
    summary="Get Privacy Policy or Terms & Conditions content",
)
def get_content(
    content_type: str = Query(
        ...,
        description="privacy_policy | terms_conditions (aliases: privacy, terms)",
    ),
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    try:
        page = get_content_page(db, content_type)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
    return serialize_content_page(page)


@router.post(
    "/save-content",
    response_model=ContentPageOut,
    summary="Save Privacy Policy or Terms & Conditions (Save Changes button)",
)
def save_content(
    body: SaveContentRequest,
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    if not body.title.strip():
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Title is required")
    try:
        page = save_content_page(
            db,
            content_type=body.content_type,
            title=body.title,
            content=body.content,
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
    return serialize_content_page(page)


@router.get(
    "/list-faqs",
    response_model=FaqListResponse,
    summary="List FAQs with search and pagination",
)
def list_faq_items(
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
    search: str | None = Query(None, description="Search question or answer"),
    skip: int = Query(0, ge=0),
    limit: int = Query(50, ge=1, le=200),
):
    rows, total = list_faqs(db, search=search, skip=skip, limit=limit)
    return FaqListResponse(
        total=total,
        skip=skip,
        limit=limit,
        faqs=[serialize_faq(f) for f in rows],
    )


@router.get(
    "/get-faq",
    response_model=FaqOut,
    summary="Get one FAQ by id",
)
def get_faq_item(
    faq_id: int = Query(..., ge=1),
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    faq = get_faq(db, faq_id)
    if not faq:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="FAQ not found")
    return serialize_faq(faq)


@router.post(
    "/add-faq",
    response_model=FaqOut,
    status_code=status.HTTP_201_CREATED,
    summary="Add new FAQ",
)
def add_faq(
    body: FaqCreateRequest,
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    if not body.question.strip():
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Question is required")
    if not body.answer.strip():
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Answer is required")
    try:
        faq = create_faq(db, question=body.question, answer=body.answer, status=body.status)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
    return serialize_faq(faq)


@router.post(
    "/edit-faq",
    response_model=FaqOut,
    summary="Update FAQ",
)
def edit_faq(
    body: FaqUpdateRequest,
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    if not body.question.strip():
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Question is required")
    if not body.answer.strip():
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Answer is required")
    try:
        faq = update_faq(
            db,
            body.faq_id,
            question=body.question,
            answer=body.answer,
            status=body.status,
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
    if not faq:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="FAQ not found")
    return serialize_faq(faq)


@router.post(
    "/delete-faq",
    response_model=Message,
    summary="Delete FAQ",
)
def delete_faq_item(
    body: FaqIdRequest,
    db: Session = Depends(get_db),
    _: User = Depends(require_admin_token),
):
    if not delete_faq(db, body.faq_id):
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="FAQ not found")
    return Message(message="FAQ deleted")