"""
设备管理服务
负责设备的CRUD操作、设备影子管理、设备发现等功能
"""

import json
import logging
from datetime import datetime
from typing import List, Optional, Dict, Any
from .models import Device, DeviceShadow, DeviceStatus, DeviceType


class DeviceManager:
    """设备管理器"""
    
    def __init__(self):
        self.devices: Dict[str, Device] = {}      # device_sn -> Device
        self.shadows: Dict[str, DeviceShadow] = {}  # device_sn -> DeviceShadow
        self.logger = logging.getLogger(__name__)
    
    def register_device(self, device_data: Dict[str, Any]) -> Device:
        """
        注册设备
        
        Args:
            device_data: 设备数据字典
            
        Returns:
            Device: 注册的设备对象
        """
        device = Device(
            device_sn=device_data['device_sn'],
            device_type=DeviceType(device_data.get('device_type', 'other')),
            name=device_data.get('name', ''),
            description=device_data.get('description', ''),
            area=device_data.get('area', ''),
            position=device_data.get('position', ''),
            geom=device_data.get('geom'),
            manufacturer=device_data.get('manufacturer', ''),
            model=device_data.get('model', ''),
            firmware_version=device_data.get('firmware_version', ''),
            hardware_version=device_data.get('hardware_version', ''),
            metadata=device_data.get('metadata', {})
        )
        
        self.devices[device.device_sn] = device
        
        # 创建设备影子
        shadow = DeviceShadow(device_sn=device.device_sn)
        self.shadows[device.device_sn] = shadow
        
        self.logger.info(f"Device registered: {device.device_sn}")
        return device
    
    def get_device(self, device_sn: str) -> Optional[Device]:
        """
        获取设备信息
        
        Args:
            device_sn: 设备序列号
            
        Returns:
            Device: 设备对象，如果不存在返回None
        """
        return self.devices.get(device_sn)
    
    def update_device(self, device_sn: str, updates: Dict[str, Any]) -> Optional[Device]:
        """
        更新设备信息
        
        Args:
            device_sn: 设备序列号
            updates: 更新的字段
            
        Returns:
            Device: 更新后的设备对象，如果不存在返回None
        """
        device = self.devices.get(device_sn)
        if not device:
            return None
        
        # 更新设备属性
        for key, value in updates.items():
            if hasattr(device, key):
                setattr(device, key, value)
        
        device.updated_at = datetime.now()
        self.logger.info(f"Device updated: {device_sn}")
        return device
    
    def delete_device(self, device_sn: str) -> bool:
        """
        删除设备
        
        Args:
            device_sn: 设备序列号
            
        Returns:
            bool: 是否删除成功
        """
        if device_sn in self.devices:
            del self.devices[device_sn]
            if device_sn in self.shadows:
                del self.shadows[device_sn]
            self.logger.info(f"Device deleted: {device_sn}")
            return True
        return False
    
    def list_devices(self, 
                    device_type: Optional[DeviceType] = None,
                    status: Optional[DeviceStatus] = None,
                    area: Optional[str] = None) -> List[Device]:
        """
        列出设备
        
        Args:
            device_type: 设备类型过滤
            status: 设备状态过滤
            area: 区域过滤
            
        Returns:
            List[Device]: 设备列表
        """
        devices = list(self.devices.values())
        
        if device_type:
            devices = [d for d in devices if d.device_type == device_type]
        
        if status:
            devices = [d for d in devices if d.status == status]
        
        if area:
            devices = [d for d in devices if d.area == area]
        
        return devices
    
    def update_device_shadow(self, device_sn: str, state: Dict[str, Any]) -> bool:
        """
        更新设备影子
        
        Args:
            device_sn: 设备序列号
            state: 设备状态
            
        Returns:
            bool: 是否更新成功
        """
        if device_sn not in self.shadows:
            return False
        
        shadow = self.shadows[device_sn]
        shadow.state.update(state)
        shadow.timestamp = datetime.now()
        self.logger.debug(f"Device shadow updated: {device_sn}")
        return True
    
    def get_device_shadow(self, device_sn: str) -> Optional[DeviceShadow]:
        """
        获取设备影子
        
        Args:
            device_sn: 设备序列号
            
        Returns:
            DeviceShadow: 设备影子对象
        """
        return self.shadows.get(device_sn)
    
    def discover_devices(self) -> List[Dict[str, Any]]:
        """
        设备发现 - 扫描网络中的设备
        
        Returns:
            List[Dict[str, Any]]: 发现的设备列表
        """
        discovered = []
        
        # 模拟设备发现过程
        # 在实际实现中，这里可以包含网络扫描、协议握手等逻辑
        for device_sn, device in self.devices.items():
            if device.status == DeviceStatus.OFFLINE:
                # 模拟设备上线
                device.status = DeviceStatus.ONLINE
                device.last_seen = datetime.now()
                device.ip_address = f"192.168.1.{hash(device_sn) % 255 + 1}"
                
                discovered.append({
                    "device_sn": device_sn,
                    "name": device.name,
                    "type": device.device_type.value,
                    "ip_address": device.ip_address,
                    "status": device.status.value
                })
        
        self.logger.info(f"Discovered {len(discovered)} devices")
        return discovered
    
    def get_device_statistics(self) -> Dict[str, Any]:
        """
        获取设备统计信息
        
        Returns:
            Dict[str, Any]: 统计信息
        """
        total = len(self.devices)
        online = sum(1 for d in self.devices.values() if d.status == DeviceStatus.ONLINE)
        offline = total - online
        
        by_type = {}
        for device in self.devices.values():
            device_type = device.device_type.value
            by_type[device_type] = by_type.get(device_type, 0) + 1
        
        return {
            "total_devices": total,
            "online_devices": online,
            "offline_devices": offline,
            "devices_by_type": by_type
        }