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.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: 作业信息对象
        """
        # 为同一个表创建多个别名，用于多次JOIN
        TesterUser = aliased(SysUser)
        ReviewerUser = aliased(SysUser)
        SecondTesterUser = aliased(SysUser)
        ThirdTesterUser = aliased(SysUser)
        
        query_result = await db.execute(
            select(
                TestJob,
                TesterUser.nick_name.label('tester_name'),
                ReviewerUser.nick_name.label('reviewer_name'),
                SecondTesterUser.nick_name.label('second_tester_name'),
                ThirdTesterUser.nick_name.label('third_tester_name')
            )
            .outerjoin(TesterUser, TestJob.tester_id == TesterUser.user_id)
            .outerjoin(ReviewerUser, TestJob.reviewer_id == ReviewerUser.user_id)
            .outerjoin(SecondTesterUser, TestJob.second_tester_id == SecondTesterUser.user_id)
            .outerjoin(ThirdTesterUser, TestJob.third_tester_id == ThirdTesterUser.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]
            job_dict['reviewerName'] = row[2]
            job_dict['secondTesterName'] = row[3]
            job_dict['thirdTesterName'] = row[4]
            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):
        """
        根据查询参数获取作业列表信息（包含关联用户名称）

        :param db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 作业列表信息对象
        """
        # 为同一个表创建多个别名，用于多次JOIN
        TesterUser = aliased(SysUser)
        ReviewerUser = aliased(SysUser)
        SecondTesterUser = aliased(SysUser)
        ThirdTesterUser = aliased(SysUser)
        
        query = (
            select(
                TestJob,
                TesterUser.nick_name.label('tester_name'),
                ReviewerUser.nick_name.label('reviewer_name'),
                SecondTesterUser.nick_name.label('second_tester_name'),
                ThirdTesterUser.nick_name.label('third_tester_name')
            )
            .outerjoin(TesterUser, TestJob.tester_id == TesterUser.user_id)
            .outerjoin(ReviewerUser, TestJob.reviewer_id == ReviewerUser.user_id)
            .outerjoin(SecondTesterUser, TestJob.second_tester_id == SecondTesterUser.user_id)
            .outerjoin(ThirdTesterUser, TestJob.third_tester_id == ThirdTesterUser.user_id)
            .where(
                TestJob.name.like(f'%{query_object.name}%') if query_object.name else True,
                TestJob.test_item_id == query_object.test_item_id if query_object.test_item_id else True,
                TestJob.tester_id == query_object.tester_id if query_object.tester_id else True,
                TestJob.reviewer_id == query_object.reviewer_id if query_object.reviewer_id else True,
                TestJob.second_tester_id == query_object.second_tester_id if query_object.second_tester_id else True,
                TestJob.third_tester_id == query_object.third_tester_id if query_object.third_tester_id else True,
                TestJob.memo == query_object.memo if query_object.memo else True,
            )
            .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]
                job_dict['reviewerName'] = row[2]
                job_dict['secondTesterName'] = row[3]
                job_dict['thirdTesterName'] = row[4]
                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]
                job_dict['reviewerName'] = row[2]
                job_dict['secondTesterName'] = row[3]
                job_dict['thirdTesterName'] = row[4]
                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', 'reviewer_name', 'second_tester_name', 'third_tester_name']}
            db_test_job = TestJob(**job_data)
        else:
            # 排除name字段（这些是JOIN查询返回的，不存在于数据库表中）
            db_test_job = TestJob(**test_job.model_dump(
                exclude={'tester_name', 'reviewer_name', 'second_tester_name', 'third_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])))