from fastapi import APIRouter, Depends, Query, status
from sqlalchemy.orm import Session
from typing import Optional, List
from utils.utils import get_db
from . import handler
from .schema import DisputeCreate, DisputeUpdate, DisputeResponse, DisputeDetailResponse

router = APIRouter(prefix="/disputes", tags=["Disputes"])

@router.post(
    "/",
    response_model=DisputeResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Create Dispute",
    description="Creates a new dispute for an order. Validates that the order exists, is delivered or completed, and that the complainant is either the buyer or seller. Returns 400 if the order status is invalid or complainant is not authorized. Returns 404 if order or users not found. Returns 409 if an active dispute already exists for the order."
)
def create_dispute_route(data: DisputeCreate, db: Session = Depends(get_db)):
    return handler.create_dispute(db, data)

@router.get(
    "/{dispute_id}",
    response_model=DisputeResponse,
    summary="Get Dispute",
    description="Returns a single dispute by ID. Returns 404 if the dispute does not exist."
)
def get_dispute_route(dispute_id: str, db: Session = Depends(get_db)):
    return handler.get_dispute(db, dispute_id)

@router.get(
    "/",
    response_model=List[DisputeResponse],
    summary="List Disputes",
    description="Returns a paginated list of disputes. Supports optional filters for status, complainant_id, respondent_id, and order_id. Results are ordered by creation date descending."
)
def list_disputes_route(
    limit: int = Query(20, ge=1, le=100),
    offset: int = Query(0, ge=0),
    status: Optional[str] = None,
    complainant_id: Optional[str] = None,
    respondent_id: Optional[str] = None,
    order_id: Optional[str] = None,
    db: Session = Depends(get_db)
):
    return handler.list_disputes(db, limit, offset, status, complainant_id, respondent_id, order_id)

@router.put(
    "/{dispute_id}",
    response_model=DisputeResponse,
    summary="Update Dispute",
    description="Updates an existing dispute. Validates that referenced order and users exist. Returns 404 if dispute, order, or users not found."
)
def update_dispute_route(dispute_id: str, data: DisputeUpdate, db: Session = Depends(get_db)):
    return handler.update_dispute(db, dispute_id, data)

@router.delete(
    "/{dispute_id}",
    status_code=status.HTTP_200_OK,
    summary="Delete Dispute",
    description="Deletes a dispute by ID. Returns 404 if the dispute does not exist."
)
def delete_dispute_route(dispute_id: str, db: Session = Depends(get_db)):
    return handler.delete_dispute(db, dispute_id)

@router.get(
    "/{dispute_id}/details",
    response_model=DisputeDetailResponse,
    summary="Get Dispute Details",
    description="Returns detailed dispute information including order details with order items and card names, complainant and respondent user emails, and resolver user email if resolved. Uses eager loading to prevent N+1 queries. Returns 404 if dispute not found."
)
def get_dispute_details_route(dispute_id: str, db: Session = Depends(get_db)):
    return handler.get_dispute_details(db, dispute_id)

@router.post(
    "/{dispute_id}/resolve",
    response_model=DisputeResponse,
    summary="Resolve Dispute",
    description="Resolves an open, under review, or escalated dispute by recording the resolution details and marking it as resolved. Updates status to RESOLVED, sets resolution text, resolved_by_id, and resolved_at timestamp. Returns 400 if dispute is not in a resolvable state. Returns 404 if dispute or resolver user not found."
)
def resolve_dispute_route(
    dispute_id: str,
    resolution: str = Query(..., description="Resolution details"),
    resolved_by_id: str = Query(..., description="ID of user resolving the dispute"),
    db: Session = Depends(get_db)
):
    return handler.resolve_dispute_service(db, dispute_id, resolution, resolved_by_id)