desungongpai/app/routers/fences.py

"""Fences Router - geofence management API endpoints."""

import math
from datetime import datetime, timedelta

from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.dependencies import require_write
from app.database import get_db
from app.models import AttendanceRecord, DeviceFenceBinding, DeviceFenceState, FenceConfig
from app.schemas import (
    APIResponse,
    DeviceFenceBindRequest,
    FenceConfigCreate,
    FenceConfigResponse,
    FenceConfigUpdate,
    FenceDeviceDetail,
    PaginatedList,
)
from app.services import fence_service

router = APIRouter(prefix="/api/fences", tags=["Fences"])


@router.get("", response_model=APIResponse[PaginatedList[FenceConfigResponse]])
async def list_fences(
    is_active: bool | None = Query(default=None),
    search: str | None = Query(default=None),
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
):
    records, total = await fence_service.get_fences(db, page, page_size, is_active, search)
    return APIResponse(
        data=PaginatedList(
            items=[FenceConfigResponse.model_validate(r) for r in records],
            total=total, page=page, page_size=page_size,
            total_pages=math.ceil(total / page_size) if total else 0,
        )
    )


@router.get(
    "/stats",
    response_model=APIResponse[dict],
    summary="围栏统计 / Fence statistics",
)
async def fence_stats(db: AsyncSession = Depends(get_db)):
    """
    围栏统计：总数、活跃数、绑定设备总数、各围栏当前在内设备数、今日进出事件数。
    Fence stats: totals, bindings, devices currently inside, today's events.
    """
    from app.config import now_cst
    now = now_cst()

    total = (await db.execute(select(func.count(FenceConfig.id)))).scalar() or 0
    active = (await db.execute(
        select(func.count(FenceConfig.id)).where(FenceConfig.is_active == True)  # noqa: E712
    )).scalar() or 0
    total_bindings = (await db.execute(select(func.count(DeviceFenceBinding.id)))).scalar() or 0

    # Devices currently inside fences
    inside_result = await db.execute(
        select(
            DeviceFenceState.fence_id,
            func.count(DeviceFenceState.id),
        )
        .where(DeviceFenceState.is_inside == True)  # noqa: E712
        .group_by(DeviceFenceState.fence_id)
    )
    devices_inside = {row[0]: row[1] for row in inside_result.all()}
    total_inside = sum(devices_inside.values())

    # Today's fence attendance events
    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
    today_events = (await db.execute(
        select(func.count(AttendanceRecord.id))
        .where(
            AttendanceRecord.attendance_source == "fence",
            AttendanceRecord.recorded_at >= today_start,
        )
    )).scalar() or 0

    # Per-fence summary
    fence_result = await db.execute(
        select(FenceConfig.id, FenceConfig.name, FenceConfig.fence_type, FenceConfig.is_active)
    )
    fence_summary = []
    for row in fence_result.all():
        fid = row[0]
        fence_summary.append({
            "fence_id": fid,
            "name": row[1],
            "type": row[2],
            "is_active": bool(row[3]),
            "devices_inside": devices_inside.get(fid, 0),
        })

    return APIResponse(data={
        "total": total,
        "active": active,
        "inactive": total - active,
        "total_bindings": total_bindings,
        "total_devices_inside": total_inside,
        "today_events": today_events,
        "fences": fence_summary,
    })


@router.get("/all-active", response_model=APIResponse[list[FenceConfigResponse]])
async def get_all_active(db: AsyncSession = Depends(get_db)):
    fences = await fence_service.get_all_active_fences(db)
    return APIResponse(data=[FenceConfigResponse.model_validate(f) for f in fences])


@router.get("/{fence_id}", response_model=APIResponse[FenceConfigResponse])
async def get_fence(fence_id: int, db: AsyncSession = Depends(get_db)):
    fence = await fence_service.get_fence(db, fence_id)
    if fence is None:
        raise HTTPException(status_code=404, detail="Fence not found")
    return APIResponse(data=FenceConfigResponse.model_validate(fence))


@router.post("", response_model=APIResponse[FenceConfigResponse], status_code=201, dependencies=[Depends(require_write)])
async def create_fence(body: FenceConfigCreate, db: AsyncSession = Depends(get_db)):
    fence = await fence_service.create_fence(db, body)
    return APIResponse(message="Fence created", data=FenceConfigResponse.model_validate(fence))


@router.put("/{fence_id}", response_model=APIResponse[FenceConfigResponse], dependencies=[Depends(require_write)])
async def update_fence(fence_id: int, body: FenceConfigUpdate, db: AsyncSession = Depends(get_db)):
    fence = await fence_service.update_fence(db, fence_id, body)
    if fence is None:
        raise HTTPException(status_code=404, detail="Fence not found")
    return APIResponse(message="Fence updated", data=FenceConfigResponse.model_validate(fence))


@router.delete("/{fence_id}", response_model=APIResponse, dependencies=[Depends(require_write)])
async def delete_fence(fence_id: int, db: AsyncSession = Depends(get_db)):
    if not await fence_service.delete_fence(db, fence_id):
        raise HTTPException(status_code=404, detail="Fence not found")
    return APIResponse(message="Fence deleted")


@router.get(
    "/{fence_id}/events",
    response_model=APIResponse[PaginatedList[dict]],
    summary="围栏进出事件历史 / Fence events history",
)
async def fence_events(
    fence_id: int,
    start_time: datetime | None = Query(default=None, description="开始时间"),
    end_time: datetime | None = Query(default=None, description="结束时间"),
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
):
    """
    获取围栏的进出事件历史（来源为 fence 的考勤记录）。
    Get fence entry/exit events (attendance records with source=fence).
    """
    fence = await fence_service.get_fence(db, fence_id)
    if fence is None:
        raise HTTPException(status_code=404, detail="Fence not found")

    from sqlalchemy.dialects.sqlite import JSON as _JSON

    filters = [
        AttendanceRecord.attendance_source == "fence",
    ]
    if start_time:
        filters.append(AttendanceRecord.recorded_at >= start_time)
    if end_time:
        filters.append(AttendanceRecord.recorded_at <= end_time)

    # Filter by fence_id in lbs_data JSON (fence_auto records store fence_id there)
    # Since SQLite JSON support is limited, we use LIKE for the fence_id match
    filters.append(AttendanceRecord.lbs_data.like(f'%"fence_id": {fence_id}%'))

    count_q = select(func.count(AttendanceRecord.id)).where(*filters)
    total = (await db.execute(count_q)).scalar() or 0

    offset = (page - 1) * page_size
    result = await db.execute(
        select(AttendanceRecord)
        .where(*filters)
        .order_by(AttendanceRecord.recorded_at.desc())
        .offset(offset).limit(page_size)
    )
    records = result.scalars().all()

    items = []
    for r in records:
        items.append({
            "id": r.id,
            "device_id": r.device_id,
            "imei": r.imei,
            "event_type": r.attendance_type,
            "latitude": r.latitude,
            "longitude": r.longitude,
            "address": r.address,
            "recorded_at": str(r.recorded_at),
        })

    return APIResponse(data=PaginatedList(
        items=items,
        total=total, page=page, page_size=page_size,
        total_pages=math.ceil(total / page_size) if total else 0,
    ))


# ---------------------------------------------------------------------------
# Device-Fence Binding endpoints
# ---------------------------------------------------------------------------


@router.get(
    "/{fence_id}/devices",
    response_model=APIResponse[list[FenceDeviceDetail]],
    summary="获取围栏绑定的设备列表",
)
async def get_fence_devices(fence_id: int, db: AsyncSession = Depends(get_db)):
    fence = await fence_service.get_fence(db, fence_id)
    if fence is None:
        raise HTTPException(status_code=404, detail="Fence not found")
    items = await fence_service.get_fence_devices(db, fence_id)
    return APIResponse(data=[FenceDeviceDetail(**item) for item in items])


@router.post(
    "/{fence_id}/devices",
    response_model=APIResponse,
    dependencies=[Depends(require_write)],
    summary="绑定设备到围栏",
)
async def bind_devices(fence_id: int, body: DeviceFenceBindRequest, db: AsyncSession = Depends(get_db)):
    result = await fence_service.bind_devices_to_fence(db, fence_id, body.device_ids)
    if result.get("error"):
        raise HTTPException(status_code=404, detail=result["error"])
    return APIResponse(
        message=f"绑定完成: 新增{result['created']}, 已绑定{result['already_bound']}, 未找到{result['not_found']}",
        data=result,
    )


@router.delete(
    "/{fence_id}/devices",
    response_model=APIResponse,
    dependencies=[Depends(require_write)],
    summary="解绑设备与围栏",
)
async def unbind_devices(fence_id: int, body: DeviceFenceBindRequest, db: AsyncSession = Depends(get_db)):
    count = await fence_service.unbind_devices_from_fence(db, fence_id, body.device_ids)
    return APIResponse(message=f"已解绑 {count} 个设备")