desungongpai/app/services/device_service.py

"""
Device Service - 设备管理服务
Provides CRUD operations and statistics for badge devices.
"""

from datetime import datetime
from app.config import now_cst

from sqlalchemy import func, select, or_
from sqlalchemy.ext.asyncio import AsyncSession

from app.models import Device
from app.schemas import DeviceCreate, DeviceUpdate, BatchDeviceCreateItem


async def get_devices(
    db: AsyncSession,
    page: int = 1,
    page_size: int = 20,
    status_filter: str | None = None,
    search: str | None = None,
) -> tuple[list[Device], int]:
    """
    获取设备列表（分页）/ Get paginated device list.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    page : int
        Page number (1-indexed).
    page_size : int
        Number of items per page.
    status_filter : str, optional
        Filter by device status (online / offline).
    search : str, optional
        Search by IMEI or device name.

    Returns
    -------
    tuple[list[Device], int]
        (list of devices, total count)
    """
    query = select(Device)
    count_query = select(func.count(Device.id))

    if status_filter:
        query = query.where(Device.status == status_filter)
        count_query = count_query.where(Device.status == status_filter)

    if search:
        pattern = f"%{search}%"
        search_clause = or_(
            Device.imei.ilike(pattern),
            Device.name.ilike(pattern),
        )
        query = query.where(search_clause)
        count_query = count_query.where(search_clause)

    # Total count
    total_result = await db.execute(count_query)
    total = total_result.scalar() or 0

    # Paginated results
    offset = (page - 1) * page_size
    query = query.order_by(Device.updated_at.desc()).offset(offset).limit(page_size)
    result = await db.execute(query)
    devices = list(result.scalars().all())

    return devices, total


async def get_device(db: AsyncSession, device_id: int) -> Device | None:
    """
    按ID获取设备 / Get device by ID.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    device_id : int
        Device primary key.

    Returns
    -------
    Device | None
    """
    result = await db.execute(select(Device).where(Device.id == device_id))
    return result.scalar_one_or_none()


async def get_device_by_imei(db: AsyncSession, imei: str) -> Device | None:
    """
    按IMEI获取设备 / Get device by IMEI number.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    imei : str
        Device IMEI number.

    Returns
    -------
    Device | None
    """
    result = await db.execute(select(Device).where(Device.imei == imei))
    return result.scalar_one_or_none()


async def create_device(db: AsyncSession, device_data: DeviceCreate) -> Device:
    """
    创建设备 / Create a new device.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    device_data : DeviceCreate
        Device creation data.

    Returns
    -------
    Device
        The newly created device.
    """
    device = Device(**device_data.model_dump())
    db.add(device)
    await db.flush()
    await db.refresh(device)
    return device


async def update_device(
    db: AsyncSession, device_id: int, device_data: DeviceUpdate
) -> Device | None:
    """
    更新设备信息 / Update device information.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    device_id : int
        Device primary key.
    device_data : DeviceUpdate
        Fields to update (only non-None fields are applied).

    Returns
    -------
    Device | None
        The updated device, or None if not found.
    """
    device = await get_device(db, device_id)
    if device is None:
        return None

    update_fields = device_data.model_dump(exclude_unset=True)
    for field, value in update_fields.items():
        setattr(device, field, value)

    device.updated_at = now_cst()
    await db.flush()
    await db.refresh(device)
    return device


async def delete_device(db: AsyncSession, device_id: int) -> bool:
    """
    删除设备 / Delete a device.

    Parameters
    ----------
    db : AsyncSession
        Database session.
    device_id : int
        Device primary key.

    Returns
    -------
    bool
        True if the device was deleted, False if not found.
    """
    device = await get_device(db, device_id)
    if device is None:
        return False

    await db.delete(device)
    await db.flush()
    return True


async def get_devices_by_ids(db: AsyncSession, device_ids: list[int]) -> list[Device]:
    """Fetch multiple devices by IDs in a single query."""
    if not device_ids:
        return []
    result = await db.execute(select(Device).where(Device.id.in_(device_ids)))
    return list(result.scalars().all())


async def get_devices_by_imeis(db: AsyncSession, imeis: list[str]) -> list[Device]:
    """Fetch multiple devices by IMEIs in a single query."""
    if not imeis:
        return []
    result = await db.execute(select(Device).where(Device.imei.in_(imeis)))
    return list(result.scalars().all())


async def batch_create_devices(
    db: AsyncSession, items: list[BatchDeviceCreateItem]
) -> list[dict]:
    """Batch create devices, skipping duplicates. Uses single query to check existing."""
    # One query to find all existing IMEIs
    imeis = [item.imei for item in items]
    existing_devices = await get_devices_by_imeis(db, imeis)
    existing_imeis = {d.imei for d in existing_devices}

    results: list[dict] = [{} for _ in range(len(items))]  # preserve input order
    new_device_indices: list[tuple[int, Device]] = []
    seen_imeis: set[str] = set()
    for i, item in enumerate(items):
        if item.imei in existing_imeis:
            results[i] = {"imei": item.imei, "success": False, "device_id": None, "error": f"IMEI {item.imei} already exists"}
            continue
        if item.imei in seen_imeis:
            results[i] = {"imei": item.imei, "success": False, "device_id": None, "error": "Duplicate IMEI in request"}
            continue
        seen_imeis.add(item.imei)
        device = Device(imei=item.imei, device_type=item.device_type, name=item.name)
        db.add(device)
        new_device_indices.append((i, device))

    if new_device_indices:
        await db.flush()
        for idx, device in new_device_indices:
            await db.refresh(device)
            results[idx] = {"imei": device.imei, "success": True, "device_id": device.id, "error": None}

    return results


async def batch_update_devices(
    db: AsyncSession, device_ids: list[int], update_data: DeviceUpdate
) -> list[dict]:
    """Batch update devices with the same settings. Uses single query to fetch all."""
    devices = await get_devices_by_ids(db, device_ids)
    found_map = {d.id: d for d in devices}
    update_fields = update_data.model_dump(exclude_unset=True)
    now = now_cst()

    results = []
    for device_id in device_ids:
        device = found_map.get(device_id)
        if device is None:
            results.append({"device_id": device_id, "success": False, "error": f"Device {device_id} not found"})
            continue
        for field, value in update_fields.items():
            setattr(device, field, value)
        device.updated_at = now
        results.append({"device_id": device_id, "success": True, "error": None})

    if any(r["success"] for r in results):
        await db.flush()

    return results


async def batch_delete_devices(
    db: AsyncSession, device_ids: list[int]
) -> list[dict]:
    """Batch delete devices. Uses single query to fetch all."""
    devices = await get_devices_by_ids(db, device_ids)
    found_map = {d.id: d for d in devices}

    results = []
    for device_id in device_ids:
        device = found_map.get(device_id)
        if device is None:
            results.append({"device_id": device_id, "success": False, "error": f"Device {device_id} not found"})
            continue
        await db.delete(device)
        results.append({"device_id": device_id, "success": True, "error": None})

    if any(r["success"] for r in results):
        await db.flush()

    return results


async def get_device_stats(db: AsyncSession) -> dict:
    """
    获取设备统计信息（增强版）/ Get enhanced device statistics.

    Returns dict with total/online/offline counts, online_rate,
    by_type breakdown, battery/signal distribution.
    """
    total_result = await db.execute(select(func.count(Device.id)))
    total = total_result.scalar() or 0

    online_result = await db.execute(
        select(func.count(Device.id)).where(Device.status == "online")
    )
    online = online_result.scalar() or 0
    offline = total - online

    # By device_type
    type_result = await db.execute(
        select(Device.device_type, func.count(Device.id))
        .group_by(Device.device_type)
        .order_by(func.count(Device.id).desc())
    )
    by_type = {row[0] or "unknown": row[1] for row in type_result.all()}

    # Battery distribution: 0-20, 20-50, 50-100, unknown
    from sqlalchemy import case
    battery_result = await db.execute(
        select(
            func.sum(case((Device.battery_level < 20, 1), else_=0)).label("low"),
            func.sum(case(((Device.battery_level >= 20) & (Device.battery_level < 50), 1), else_=0)).label("medium"),
            func.sum(case((Device.battery_level >= 50, 1), else_=0)).label("high"),
            func.sum(case((Device.battery_level.is_(None), 1), else_=0)).label("unknown"),
        )
    )
    brow = battery_result.one()
    battery_distribution = {
        "low_0_20": int(brow.low or 0),
        "medium_20_50": int(brow.medium or 0),
        "high_50_100": int(brow.high or 0),
        "unknown": int(brow.unknown or 0),
    }

    # Signal distribution: 0=none, 1-10=weak, 11-20=medium, 21-31=strong
    signal_result = await db.execute(
        select(
            func.sum(case(((Device.gsm_signal.is_not(None)) & (Device.gsm_signal <= 10), 1), else_=0)).label("weak"),
            func.sum(case(((Device.gsm_signal > 10) & (Device.gsm_signal <= 20), 1), else_=0)).label("medium"),
            func.sum(case((Device.gsm_signal > 20, 1), else_=0)).label("strong"),
            func.sum(case((Device.gsm_signal.is_(None), 1), else_=0)).label("unknown"),
        )
    )
    srow = signal_result.one()
    signal_distribution = {
        "weak_0_10": int(srow.weak or 0),
        "medium_11_20": int(srow.medium or 0),
        "strong_21_31": int(srow.strong or 0),
        "unknown": int(srow.unknown or 0),
    }

    return {
        "total": total,
        "online": online,
        "offline": offline,
        "online_rate": round(online / total * 100, 1) if total else 0,
        "by_type": by_type,
        "battery_distribution": battery_distribution,
        "signal_distribution": signal_distribution,
    }