"""
设备类型业务服务层
"""
from typing import List, Optional, Tuple
from sqlalchemy.orm import Session
from app.crud.device_type import device_type, device_type_field
from app.schemas.device_type import (
    DeviceTypeCreate,
    DeviceTypeUpdate,
    DeviceTypeFieldCreate,
    DeviceTypeFieldUpdate
)
from app.core.exceptions import NotFoundException, AlreadyExistsException


class DeviceTypeService:
    """设备类型服务类"""

    def get_device_type(self, db: Session, device_type_id: int, include_fields: bool = False):
        """
        获取设备类型详情

        Args:
            db: 数据库会话
            device_type_id: 设备类型ID
            include_fields: 是否包含字段列表

        Returns:
            设备类型对象

        Raises:
            NotFoundException: 设备类型不存在
        """
        obj = device_type.get(db, device_type_id)
        if not obj:
            raise NotFoundException("设备类型")

        # 计算字段数量
        field_count = device_type_field.get_by_device_type(db, device_type_id)
        obj.field_count = len(field_count)

        return obj

    def get_device_types(
        self,
        db: Session,
        skip: int = 0,
        limit: int = 20,
        category: Optional[str] = None,
        status: Optional[str] = None,
        keyword: Optional[str] = None
    ) -> Tuple[List, int]:
        """
        获取设备类型列表

        Args:
            db: 数据库会话
            skip: 跳过条数
            limit: 返回条数
            category: 设备分类
            status: 状态
            keyword: 搜索关键词

        Returns:
            (设备类型列表, 总数)
        """
        items, total = device_type.get_multi(
            db=db,
            skip=skip,
            limit=limit,
            category=category,
            status=status,
            keyword=keyword
        )

        # 为每个项目添加字段数量
        for item in items:
            fields = device_type_field.get_by_device_type(db, item.id)
            item.field_count = len(fields)

        return items, total

    def create_device_type(
        self,
        db: Session,
        obj_in: DeviceTypeCreate,
        creator_id: Optional[int] = None
    ):
        """
        创建设备类型

        Args:
            db: 数据库会话
            obj_in: 创建数据
            creator_id: 创建人ID

        Returns:
            创建的设备类型对象

        Raises:
            AlreadyExistsException: 设备类型代码已存在
        """
        try:
            return device_type.create(db, obj_in, creator_id)
        except ValueError as e:
            raise AlreadyExistsException("设备类型") from e

    def update_device_type(
        self,
        db: Session,
        device_type_id: int,
        obj_in: DeviceTypeUpdate,
        updater_id: Optional[int] = None
    ):
        """
        更新设备类型

        Args:
            db: 数据库会话
            device_type_id: 设备类型ID
            obj_in: 更新数据
            updater_id: 更新人ID

        Returns:
            更新后的设备类型对象

        Raises:
            NotFoundException: 设备类型不存在
        """
        db_obj = device_type.get(db, device_type_id)
        if not db_obj:
            raise NotFoundException("设备类型")

        return device_type.update(db, db_obj, obj_in, updater_id)

    def delete_device_type(
        self,
        db: Session,
        device_type_id: int,
        deleter_id: Optional[int] = None
    ) -> bool:
        """
        删除设备类型

        Args:
            db: 数据库会话
            device_type_id: 设备类型ID
            deleter_id: 删除人ID

        Returns:
            是否删除成功

        Raises:
            NotFoundException: 设备类型不存在
        """
        if not device_type.get(db, device_type_id):
            raise NotFoundException("设备类型")

        return device_type.delete(db, device_type_id, deleter_id)

    def get_device_type_fields(
        self,
        db: Session,
        device_type_id: int,
        status: Optional[str] = None
    ) -> List:
        """
        获取设备类型的字段列表

        Args:
            db: 数据库会话
            device_type_id: 设备类型ID
            status: 状态筛选

        Returns:
            字段列表

        Raises:
            NotFoundException: 设备类型不存在
        """
        # 验证设备类型存在
        if not device_type.get(db, device_type_id):
            raise NotFoundException("设备类型")

        return device_type_field.get_by_device_type(db, device_type_id, status)

    def create_device_type_field(
        self,
        db: Session,
        device_type_id: int,
        obj_in: DeviceTypeFieldCreate,
        creator_id: Optional[int] = None
    ):
        """
        创建设备类型字段

        Args:
            db: 数据库会话
            device_type_id: 设备类型ID
            obj_in: 创建数据
            creator_id: 创建人ID

        Returns:
            创建的字段对象

        Raises:
            NotFoundException: 设备类型不存在
            AlreadyExistsException: 字段代码已存在
        """
        # 验证设备类型存在
        if not device_type.get(db, device_type_id):
            raise NotFoundException("设备类型")

        try:
            return device_type_field.create(db, obj_in, device_type_id, creator_id)
        except ValueError as e:
            raise AlreadyExistsException("字段") from e

    def update_device_type_field(
        self,
        db: Session,
        field_id: int,
        obj_in: DeviceTypeFieldUpdate,
        updater_id: Optional[int] = None
    ):
        """
        更新设备类型字段

        Args:
            db: 数据库会话
            field_id: 字段ID
            obj_in: 更新数据
            updater_id: 更新人ID

        Returns:
            更新后的字段对象

        Raises:
            NotFoundException: 字段不存在
        """
        db_obj = device_type_field.get(db, field_id)
        if not db_obj:
            raise NotFoundException("字段")

        return device_type_field.update(db, db_obj, obj_in, updater_id)

    def delete_device_type_field(
        self,
        db: Session,
        field_id: int,
        deleter_id: Optional[int] = None
    ) -> bool:
        """
        删除设备类型字段

        Args:
            db: 数据库会话
            field_id: 字段ID
            deleter_id: 删除人ID

        Returns:
            是否删除成功

        Raises:
            NotFoundException: 字段不存在
        """
        if not device_type_field.get(db, field_id):
            raise NotFoundException("字段")

        return device_type_field.delete(db, field_id, deleter_id)

    def get_all_categories(self, db: Session) -> List[str]:
        """
        获取所有设备分类

        Args:
            db: 数据库会话

        Returns:
            设备分类列表
        """
        return device_type.get_all_categories(db)


# 创建全局实例
device_type_service = DeviceTypeService()
