from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session

from app.db.session import get_db
from app.models.message import Message
from app.schemas.message import MessageCreate, MessageResponse

router = APIRouter(tags=["Messages"])


@router.get("/", response_model=List[MessageResponse])
def list_messages(
    sender: Optional[str] = Query(None, description="Filter messages by sender"),
    recipient: Optional[str] = Query(None, description="Filter messages by recipient"),
    is_read: Optional[bool] = Query(None, description="Filter messages by read status"),
    skip: int = Query(0, description="Number of messages to skip"),
    limit: int = Query(100, description="Maximum number of messages to return"),
    db: Session = Depends(get_db),
):
    """
    Get a list of messages with optional filtering.
    """
    query = db.query(Message)
    
    if sender:
        query = query.filter(Message.sender == sender)
    if recipient:
        query = query.filter(Message.recipient == recipient)
    if is_read is not None:
        query = query.filter(Message.is_read == is_read)
    
    messages = query.order_by(Message.timestamp.desc()).offset(skip).limit(limit).all()
    return messages


@router.get("/{message_id}", response_model=MessageResponse)
def get_message(message_id: int, db: Session = Depends(get_db)):
    """
    Get a specific message by ID.
    """
    message = db.query(Message).filter(Message.id == message_id).first()
    if not message:
        raise HTTPException(status_code=404, detail="Message not found")
    return message


@router.post("/", response_model=MessageResponse, status_code=201)
def create_message(message: MessageCreate, db: Session = Depends(get_db)):
    """
    Create a new message.
    """
    db_message = Message(
        sender=message.sender,
        recipient=message.recipient,
        content=message.content,
    )
    db.add(db_message)
    db.commit()
    db.refresh(db_message)
    return db_message


@router.put("/{message_id}/read", response_model=MessageResponse)
def mark_message_as_read(message_id: int, db: Session = Depends(get_db)):
    """
    Mark a message as read.
    """
    message = db.query(Message).filter(Message.id == message_id).first()
    if not message:
        raise HTTPException(status_code=404, detail="Message not found")
    
    message.is_read = True
    db.commit()
    db.refresh(message)
    return message


@router.delete("/{message_id}", status_code=204)
def delete_message(message_id: int, db: Session = Depends(get_db)):
    """
    Delete a message.
    """
    message = db.query(Message).filter(Message.id == message_id).first()
    if not message:
        raise HTTPException(status_code=404, detail="Message not found")
    
    db.delete(message)
    db.commit()
    return None