from typing import Any, List, Optional
from datetime import datetime

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

from app.db.session import get_db
from app.models.device import Device
from app.models.log import Log, LogLevel
from app.schemas.log import LogCreate, LogResponse

router = APIRouter()


@router.post("/", response_model=LogResponse)
def create_log(
    *,
    db: Session = Depends(get_db),
    log_in: LogCreate,
) -> Any:
    """
    Create new log entry.
    """
    # Check if device exists
    device = db.query(Device).filter(Device.id == log_in.device_id).first()
    if not device:
        raise HTTPException(status_code=404, detail="Device not found")
    
    # Create log entry
    log = Log(
        device_id=log_in.device_id,
        level=log_in.level,
        message=log_in.message,
        source=log_in.source,
    )
    db.add(log)
    db.commit()
    db.refresh(log)
    return log


@router.get("/", response_model=List[LogResponse])
def get_logs(
    db: Session = Depends(get_db),
    skip: int = 0,
    limit: int = 100,
    device_id: Optional[str] = None,
    level: Optional[LogLevel] = None,
    start_date: Optional[datetime] = None,
    end_date: Optional[datetime] = None,
) -> Any:
    """
    Retrieve logs with optional filtering.
    """
    query = db.query(Log)
    
    if device_id:
        query = query.filter(Log.device_id == device_id)
    
    if level:
        query = query.filter(Log.level == level)
    
    if start_date:
        query = query.filter(Log.timestamp >= start_date)
    
    if end_date:
        query = query.filter(Log.timestamp <= end_date)
    
    logs = query.order_by(desc(Log.timestamp)).offset(skip).limit(limit).all()
    return logs


@router.get("/{log_id}", response_model=LogResponse)
def get_log(
    *,
    db: Session = Depends(get_db),
    log_id: int,
) -> Any:
    """
    Get log by ID.
    """
    log = db.query(Log).filter(Log.id == log_id).first()
    if not log:
        raise HTTPException(status_code=404, detail="Log not found")
    return log


@router.delete("/{log_id}")
def delete_log(
    *,
    db: Session = Depends(get_db),
    log_id: int,
) -> Any:
    """
    Delete log.
    """
    log = db.query(Log).filter(Log.id == log_id).first()
    if not log:
        raise HTTPException(status_code=404, detail="Log not found")
    
    db.delete(log)
    db.commit()
    return {"success": True}