from sqlalchemy import delete, select, update
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import aliased
from module_admin.system.entity.do.test_job_do import TestJob
from module_admin.system.entity.do.test_item_do import TestItem
from module_admin.entity.do.user_do import SysUser
from module_admin.system.entity.vo.test_job_vo import Test_jobModel, Test_jobPageQueryModel
from utils.page_util import PageUtil


class Test_jobDao:
    """
    作业模块数据库操作层
    """

    @classmethod
    async def get_test_job_detail_by_id(cls, db: AsyncSession, id: int):
        """
        根据作业ID获取作业详细信息（包含关联用户名称）

        :param db: orm对象
        :param id: 作业ID
        :return: 作业信息对象
        """
        query_result = await db.execute(
            select(
                TestJob,
                SysUser.nick_name.label('tester_name')
            )
            .outerjoin(SysUser, TestJob.tester_id == SysUser.user_id)
            .where(TestJob.id == id)
        )
        
        row = query_result.first()
        if row:
            # 转换为dict格式，包含ID和名称
            from utils.common_util import CamelCaseUtil
            job = row[0]  # TestJob对象
            job_dict = CamelCaseUtil.transform_result(job)
            job_dict['testerName'] = row[1]
            return job_dict
        
        return None

    @classmethod
    async def get_test_job_detail_by_info(cls, db: AsyncSession, test_job: Test_jobModel):
        """
        根据作业参数获取作业信息

        :param db: orm对象
        :param test_job: 作业参数对象
        :return: 作业信息对象
        """
        test_job_info = (
            (
                await db.execute(
                    select(TestJob).where(
                    )
                )
            )
            .scalars()
            .first()
        )

        return test_job_info

    @classmethod
    async def get_test_job_list(cls, db: AsyncSession, query_object: Test_jobPageQueryModel, is_page: bool = False):
        """
        根据查询参数获取作业列表信息（包含关联用户名称）
        支持按测试类别和产品类别筛选（通过JOIN test_item）

        :param db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 作业列表信息对象
        """
        # 构建筛选条件
        conditions = []
        if query_object.name:
            conditions.append(TestJob.name.like(f'%{query_object.name}%'))
        if query_object.test_item_id:
            conditions.append(TestJob.test_item_id == query_object.test_item_id)
        if query_object.tester_id:
            conditions.append(TestJob.tester_id == query_object.tester_id)
        if query_object.memo:
            conditions.append(TestJob.memo == query_object.memo)
        
        # 是否需要JOIN test_item（按测试类别或产品类别筛选时）
        need_join_item = bool(query_object.test_category_id or query_object.eut_type_id)
        
        query = (
            select(
                TestJob,
                SysUser.nick_name.label('tester_name')
            )
            .outerjoin(SysUser, TestJob.tester_id == SysUser.user_id)
        )
        
        if need_join_item:
            query = query.join(TestItem, TestJob.test_item_id == TestItem.id)
            if query_object.test_category_id:
                conditions.append(TestItem.test_category_id == query_object.test_category_id)
            if query_object.eut_type_id:
                conditions.append(TestItem.eut_type_id == query_object.eut_type_id)
        
        query = query.where(*conditions).order_by(TestJob.id).distinct()
        
        # 不使用PageUtil，自己处理JOIN后的数据
        from sqlalchemy import func
        from utils.common_util import CamelCaseUtil
        import math
        
        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:
                job = row[0]  # TestJob对象
                job_dict = CamelCaseUtil.transform_result(job)
                job_dict['testerName'] = row[1]
                processed_rows.append(job_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:
                job = row[0]
                job_dict = CamelCaseUtil.transform_result(job)
                job_dict['testerName'] = row[1]
                processed_rows.append(job_dict)
            return processed_rows

    @classmethod
    async def add_test_job_dao(cls, db: AsyncSession, test_job: Test_jobModel):
        """
        新增作业数据库操作

        :param db: orm对象
        :param test_job: 作业对象
        :return:
        """
        # 调试信息
        print(f"DEBUG add: test_job type = {type(test_job)}")
        
        # 如果test_job已经是dict，直接使用
        if isinstance(test_job, dict):
            job_data = {k: v for k, v in test_job.items() 
                       if k not in ['tester_name']}
            db_test_job = TestJob(**job_data)
        else:
            # 排除name字段（这些是JOIN查询返回的，不存在于数据库表中）
            db_test_job = TestJob(**test_job.model_dump(
                exclude={'tester_name'},
                exclude_unset=True
            ))
        db.add(db_test_job)
        await db.flush()
        print("db_test_job.id",db_test_job.id)
        return db_test_job

    @classmethod
    async def edit_test_job_dao(cls, db: AsyncSession, test_job: dict):
        """
        编辑作业数据库操作

        :param db: orm对象
        :param test_job: 需要更新的作业字典
        :return:
        """
        await db.execute(update(TestJob), [test_job])

    @classmethod
    async def delete_test_job_dao(cls, db: AsyncSession, test_job: Test_jobModel):
        """
        删除作业数据库操作

        :param db: orm对象
        :param test_job: 作业对象
        :return:
        """
        await db.execute(delete(TestJob).where(TestJob.id.in_([test_job.id])))