from sqlalchemy import delete, select, update
from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.system.entity.do.test_item_do import TestItem
from module_admin.system.entity.vo.test_item_vo import Test_itemModel, Test_itemPageQueryModel
from utils.page_util import PageUtil


class Test_itemDao:
    """
    测试单元模块数据库操作层
    """

    @classmethod
    async def get_test_item_detail_by_id(cls, db: AsyncSession, id: int):
        """
        根据ID获取测试单元详细信息

        :param db: orm对象
        :param id: ID
        :return: 测试单元信息对象
        """
        test_item_info = (
            (
                await db.execute(
                    select(TestItem)
                    .where(
                        TestItem.id == id
                    )
                )
            )
            .scalars()
            .first()
        )

        return test_item_info

    @classmethod
    async def get_test_item_detail_by_info(cls, db: AsyncSession, test_item: Test_itemModel):
        """
        根据测试单元参数获取测试单元信息

        :param db: orm对象
        :param test_item: 测试单元参数对象
        :return: 测试单元信息对象
        """
        test_item_info = (
            (
                await db.execute(
                    select(TestItem).where(
                    )
                )
            )
            .scalars()
            .first()
        )

        return test_item_info

    @classmethod
    async def get_test_item_list(cls, db: AsyncSession, query_object: Test_itemPageQueryModel, is_page: bool = False):
        """
        根据查询参数获取测试单元列表信息

        :param db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 测试单元列表信息对象
        """
        from module_admin.system.entity.do.test_category_do import TestCategory
        from module_admin.system.entity.do.eut_type_do import EutType
        from sqlalchemy import func
        from utils.common_util import CamelCaseUtil
        import math
        
        query = (
            select(
                TestItem,
                TestCategory.name.label('test_category_name'),
                EutType.name.label('eut_type_name')
            )
            .outerjoin(TestCategory, TestItem.test_category_id == TestCategory.id)
            .outerjoin(EutType, TestItem.eut_type_id == EutType.id)
            .where(
                TestItem.name.like(f'%{query_object.name}%') if query_object.name else True,
                TestItem.test_category_id == query_object.test_category_id if query_object.test_category_id else True,
                TestItem.eut_type_id == query_object.eut_type_id if query_object.eut_type_id else True,
                TestItem.config_json == query_object.config_json if query_object.config_json else True,
                TestItem.memo == query_object.memo if query_object.memo else True,
            )
            .order_by(TestItem.id)
            .distinct()
        )
        
        if is_page:
            # 计算总数
            total = (await db.execute(select(func.count('*')).select_from(query.subquery()))).scalar()
            # 执行分页查询
            query_result = await db.execute(query.offset((query_object.page_num - 1) * query_object.page_size).limit(query_object.page_size))
            
            # 处理JOIN结果
            processed_rows = []
            for row in query_result:
                item = row[0]  # TestItem对象
                item_dict = CamelCaseUtil.transform_result(item)
                item_dict['testCategoryName'] = row[1]
                item_dict['eutTypeName'] = row[2]
                processed_rows.append(item_dict)
            
            has_next = math.ceil(total / query_object.page_size) > query_object.page_num
            return {
                'rows': processed_rows,
                'total': total,
                'pageNum': query_object.page_num,
                'pageSize': query_object.page_size,
                'hasNext': has_next
            }
        else:
            # 非分页模式
            query_result = await db.execute(query)
            processed_rows = []
            for row in query_result:
                item = row[0]
                item_dict = CamelCaseUtil.transform_result(item)
                item_dict['testCategoryName'] = row[1]
                item_dict['eutTypeName'] = row[2]
                processed_rows.append(item_dict)
            
            return processed_rows

    @classmethod
    async def add_test_item_dao(cls, db: AsyncSession, test_item: Test_itemModel):
        """
        新增测试单元数据库操作

        :param db: orm对象
        :param test_item: 测试单元对象
        :return:
        """
        db_test_item = TestItem(**test_item.model_dump(
            exclude={'test_category_name', 'eut_type_name'},
            exclude_unset=True
        ))
        db.add(db_test_item)
        await db.flush()

        return db_test_item

    @classmethod
    async def edit_test_item_dao(cls, db: AsyncSession, test_item: dict):
        """
        编辑测试单元数据库操作

        :param db: orm对象
        :param test_item: 需要更新的测试单元字典
        :return:
        """
        await db.execute(update(TestItem), [test_item])

    @classmethod
    async def delete_test_item_dao(cls, db: AsyncSession, test_item: Test_itemModel):
        """
        删除测试单元数据库操作

        :param db: orm对象
        :param test_item: 测试单元对象
        :return:
        """
        await db.execute(delete(TestItem).where(TestItem.id.in_([test_item.id])))