from typing import List, Optional
from datetime import datetime, timedelta
from app.core.utils import now_tw
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import func, case
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.models.server import Server, ServerStatusLog
from app.schemas.server import ServerCreate, ServerUpdate, ServerResponse, ServerAvailability

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


def _calc_availability(db: Session, server_id: int, days: int) -> Optional[float]:
    since = now_tw() - timedelta(days=days)
    row = (
        db.query(
            func.count().label("total"),
            func.sum(case((ServerStatusLog.result == True, 1), else_=0)).label("ok"),
        )
        .filter(ServerStatusLog.server_id == server_id, ServerStatusLog.recorded_at >= since)
        .first()
    )
    if not row or not row.total:
        return None
    return round(row.ok * 100.0 / row.total, 2)


def _get_last_status(db: Session, server_id: int):
    return (
        db.query(ServerStatusLog)
        .filter(ServerStatusLog.server_id == server_id)
        .order_by(ServerStatusLog.recorded_at.desc(), ServerStatusLog.id.desc())
        .first()
    )


@router.get("", response_model=List[ServerResponse])
def list_servers(db: Session = Depends(get_db)):
    servers = db.query(Server).order_by(Server.sort_order).all()
    result = []
    for s in servers:
        resp = ServerResponse.model_validate(s)
        last = _get_last_status(db, s.id)
        if last:
            resp.last_result = last.result
            resp.last_response_time = last.response_time
        resp.availability = ServerAvailability(
            availability_30d=_calc_availability(db, s.id, 30),
            availability_90d=_calc_availability(db, s.id, 90),
            availability_365d=_calc_availability(db, s.id, 365),
        )
        result.append(resp)
    return result


@router.post("", response_model=ServerResponse, status_code=201)
def create_server(payload: ServerCreate, db: Session = Depends(get_db)):
    if db.query(Server).filter(Server.ip_address == payload.ip_address).first():
        raise HTTPException(status_code=409, detail="IP address already exists")
    server = Server(**payload.model_dump())
    db.add(server)
    db.commit()
    db.refresh(server)
    return ServerResponse.model_validate(server)


@router.get("/{server_id}", response_model=ServerResponse)
def get_server(server_id: int, db: Session = Depends(get_db)):
    server = db.get(Server, server_id)
    if not server:
        raise HTTPException(status_code=404, detail="Server not found")
    resp = ServerResponse.model_validate(server)
    last = _get_last_status(db, server_id)
    if last:
        resp.last_result = last.result
        resp.last_response_time = last.response_time
    resp.availability = ServerAvailability(
        availability_30d=_calc_availability(db, server_id, 30),
        availability_90d=_calc_availability(db, server_id, 90),
        availability_365d=_calc_availability(db, server_id, 365),
    )
    return resp


@router.put("/{server_id}", response_model=ServerResponse)
def update_server(server_id: int, payload: ServerUpdate, db: Session = Depends(get_db)):
    server = db.get(Server, server_id)
    if not server:
        raise HTTPException(status_code=404, detail="Server not found")
    for field, value in payload.model_dump(exclude_none=True).items():
        setattr(server, field, value)
    db.commit()
    db.refresh(server)
    return ServerResponse.model_validate(server)


@router.delete("/{server_id}", status_code=204)
def delete_server(server_id: int, db: Session = Depends(get_db)):
    server = db.get(Server, server_id)
    if not server:
        raise HTTPException(status_code=404, detail="Server not found")
    db.delete(server)
    db.commit()