main.py

from datetime import datetime, timedelta

from fastapi import Depends, FastAPI, HTTPException, Request
from pydantic import BaseModel
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import HTMLResponse, RedirectResponse, Response
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from sqlalchemy import func
from sqlalchemy.orm import Session

from app.auth.jwt import verify_token
from app.database.database import get_db
from app.database.models import Client, ContactMessage as ContactMessageModel, Reservation, User, Vehicle
from app.routes import auth as auth_routes
from app.routes import client, payment, reservation, vehicle
from app.routes.export import router as export_router


app = FastAPI(
    title="Luxury Wheels API",
    description="API para sistema de gestao de frota de veiculos",
    version="1.0.0",
)

# Templates e arquivos estaticos
templates = Jinja2Templates(directory="templates")
app.mount("/static", StaticFiles(directory="static"), name="static")

# Configurar CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Incluir rotas
app.include_router(vehicle.router)
app.include_router(client.router)
app.include_router(reservation.router)
app.include_router(payment.router)
app.include_router(export_router, prefix="/api", tags=["export"])
app.include_router(auth_routes.router, prefix="/api/auth", tags=["auth"])


@app.get("/")
async def root(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})


@app.get("/favicon.ico", include_in_schema=False)
async def favicon():
    return Response(status_code=204)


@app.get("/car-list", response_class=HTMLResponse)
async def car_list(request: Request):
    return templates.TemplateResponse("car-list.html", {"request": request})


@app.get("/contact", response_class=HTMLResponse)
async def contact(request: Request):
    return templates.TemplateResponse("contact.html", {"request": request})


@app.get("/registration", response_class=HTMLResponse)
async def registration(request: Request):
    return templates.TemplateResponse("registration.html", {"request": request})


@app.get("/login", response_class=HTMLResponse)
async def login(request: Request):
    return templates.TemplateResponse("login.html", {"request": request})


@app.get("/reserva", response_class=HTMLResponse)
async def reserva(request: Request):
    return templates.TemplateResponse("reserva.html", {"request": request})


@app.get("/admin", response_class=HTMLResponse)
async def admin_redirect(request: Request):
    return templates.TemplateResponse("admin_login.html", {"request": request})


@app.get("/admin-login", response_class=HTMLResponse)
async def admin_login(request: Request):
    return templates.TemplateResponse("admin_login.html", {"request": request})


def _get_admin_token(request: Request) -> str | None:
    auth_header = request.headers.get("Authorization")
    if auth_header and auth_header.startswith("Bearer "):
        return auth_header.split(" ", 1)[1]
    return request.cookies.get("access_token")


@app.get("/admin-tools", response_class=HTMLResponse)
async def admin_tools(request: Request, db: Session = Depends(get_db)):
    token = _get_admin_token(request)
    if not token:
        return RedirectResponse(url="/admin-login", status_code=302)
    try:
        payload = verify_token(token)
    except Exception:
        return RedirectResponse(url="/admin-login", status_code=302)
    username = payload.get("sub")
    if not username:
        return RedirectResponse(url="/admin-login", status_code=302)
    user = db.query(User).filter(User.username == username).first()
    if not user or user.role != "admin":
        return RedirectResponse(url="/admin-login", status_code=302)
    return templates.TemplateResponse("admin_tools.html", {"request": request})


@app.get("/dashboard")
async def get_dashboard(db: Session = Depends(get_db)):
    try:
        # Veiculos alugados e dias restantes
        today = datetime.now().date()
        active_reservations = db.query(Reservation).join(Vehicle).filter(
            Reservation.end_date >= today
        ).all()
        rented_vehicles = []
        for res in active_reservations:
            days_remaining = (res.end_date - today).days if res.end_date else 0
            rented_vehicles.append(
                {
                    "reservation_id": res.id,
                    "vehicle": res.vehicle.to_dict() if res.vehicle else None,
                    "days_remaining": days_remaining,
                }
            )

        # Ultimos clientes
        latest_clients = [
            c.to_dict()
            for c in db.query(Client).order_by(Client.registration_date.desc()).limit(5).all()
        ]

        # Veiculos disponiveis
        available_vehicles = [
            {
                "vehicle_type": row[0],
                "category": row[1],
                "count": row[2],
            }
            for row in db.query(
                Vehicle.vehicle_type,
                Vehicle.category,
                func.count(Vehicle.id),
            )
            .filter(Vehicle.is_available.is_(True))
            .group_by(Vehicle.vehicle_type, Vehicle.category)
            .all()
        ]

        # Reservas do mes
        current_month = datetime.now().replace(day=1).date()
        month_reservations = [
            r.to_dict()
            for r in db.query(Reservation).filter(Reservation.start_date >= current_month).all()
        ]

        # Adicione estas novas consultas
        revision_cutoff = today + timedelta(days=15)
        inspection_cutoff = today + timedelta(days=15)
        revision_alert_cutoff = today + timedelta(days=5)

        # Veiculos que precisam de revisao nos proximos 15 dias
        vehicles_needing_revision = [
            v.to_dict()
            for v in db.query(Vehicle).filter(
                Vehicle.next_revision_date.between(today, revision_cutoff)
            ).all()
        ]

        # Veiculos que precisam de revisao nos proximos 5 dias (alerta)
        vehicles_revision_alert = [
            v.to_dict()
            for v in db.query(Vehicle).filter(
                Vehicle.next_revision_date.between(today, revision_alert_cutoff)
            ).all()
        ]

        # Veiculos que precisam de inspecao nos proximos 15 dias
        vehicles_needing_inspection = [
            v.to_dict()
            for v in db.query(Vehicle).filter(
                Vehicle.next_inspection_date.between(today, inspection_cutoff)
            ).all()
        ]

        # Total financeiro das reservas do mes
        monthly_revenue = db.query(
            func.sum(Reservation.total_amount)
        ).filter(
            func.extract("month", Reservation.start_date) == today.month,
            func.extract("year", Reservation.start_date) == today.year,
        ).scalar() or 0

        return {
            # Mantenha os dados existentes
            "rented_vehicles": rented_vehicles,
            "latest_clients": latest_clients,
            "available_vehicles": available_vehicles,
            "month_reservations": month_reservations,

            # Adicione os novos dados
            "vehicles_needing_revision": vehicles_needing_revision,
            "vehicles_revision_alert": vehicles_revision_alert,
            "vehicles_needing_inspection": vehicles_needing_inspection,
            "monthly_revenue": float(monthly_revenue) if monthly_revenue else 0,
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


class ContactMessagePayload(BaseModel):
    name: str
    email: str
    message: str


@app.post("/api/contact")
async def submit_contact(payload: ContactMessagePayload, db: Session = Depends(get_db)):
    message = ContactMessageModel(
        name=payload.name,
        email=payload.email,
        message=payload.message,
    )
    db.add(message)
    db.commit()
    return {"status": "ok"}


@app.get("/public/vehicles")
async def list_public_vehicles(db: Session = Depends(get_db)):
    vehicles = db.query(Vehicle).filter(
        Vehicle.is_available.is_(True),
        Vehicle.is_maintenance.is_(False),
    ).all()
    return [v.to_dict() for v in vehicles]


@app.get("/public/clients/lookup")
async def lookup_client(email: str | None = None, document: str | None = None, db: Session = Depends(get_db)):
    if not email and not document:
        raise HTTPException(status_code=400, detail="Email or document required")
    query = db.query(Client)
    if email:
        query = query.filter(Client.email == email)
    if document:
        query = query.filter(Client.document == document)
    client = query.first()
    if not client:
        raise HTTPException(status_code=404, detail="Client not found")
    return client.to_dict()