from fastapi import Request
from sqlalchemy.ext.asyncio import AsyncSession
from exceptions.exception import ServiceException
from module_admin.dao.datastd_dao import DataStdDao
from module_admin.entity.vo.common_vo import CrudResponseModel
from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DeleteDataStdModel,DataStdDictModel
from utils.common_util import CamelCaseUtil
import uuid
from config.constant import CommonConstant

class DataStdService:
    """
    数据源标准服务层
    """

    @classmethod
    async def get_std_code_list_services(
        cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
    ):
        """
        获取列配置列表信息service

        :param query_db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 列配置列表信息对象
        """
        col_list_result = await DataStdDao.get_std_code_list(query_db, query_object, is_page)
        return col_list_result

    @classmethod
    async def get_std_code_map_list_services(
        cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
    ):
        """
        获取列配置列表信息service

        :param query_db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 列配置列表信息对象
        """
        col_list_result = await DataStdDao.get_std_code_map_list(query_db, query_object, is_page)
        return col_list_result
    @classmethod
    async def get_std_code_by_id_services(cls, query_db: AsyncSession, id: str):
        """
        获取列配置详细信息service

        :param query_db: orm对象
        :param id: 列配置ID
        :return: 列配置详细信息对象
        """
        col = await DataStdDao.get_std_code_by_id(query_db, id)
        if col:
            result = DataStdCodeModel(**CamelCaseUtil.transform_result(col))
        else:
            result = DataStdCodeModel(**dict())
        return result

  
    @classmethod
    async def add_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdCodeModel):
        """
        新增列配置服务

        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 新增的列配置对象
        :return: 新增列配置校验结果
        """
        try:
            # 创建新的 page_object 实例，避免修改原始对象
            new_page_object = DataStdCodeModel(**page_object.model_dump(by_alias=True))
            new_page_object.code_status="0"
            # 调用 DAO 方法插入数据
            await DataStdDao.add_std_code(query_db, new_page_object)
            return CrudResponseModel(is_success=True, message='新增标准代码成功')
        except Exception as e:
            await query_db.rollback()
            raise e
 

    @classmethod
    async def code_detail_services(cls, query_db: AsyncSession, col: str):
        """
        获取参数配置详细信息service

        :param query_db: orm对象
        :param config_id: 参数配置id
        :return: 参数配置id对应的信息
        """
        config = await DataStdDao.get_std_code_by_id(query_db, col)
        if config:
            result = DataStdCodeModel(**CamelCaseUtil.transform_result(config))
        else:
            result = DataStdCodeModel(**dict())

        return result
    @classmethod
    async def edit_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdCodeModel):
        """
        编辑列配置服务

        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 编辑的列配置对象
        :return: 编辑列配置校验结果
        """
        edit_col = page_object.model_dump(exclude_unset=True)
        col_info = await cls.get_std_code_by_id_services(query_db, page_object.id)

        if col_info:
            try:
                await DataStdDao.update_std_code(query_db, edit_col)
                return CrudResponseModel(is_success=True, message='编辑标准代码成功')
            except Exception as e:
                await query_db.rollback()
                raise e
        else:
            raise ServiceException(message=f'标准代码{page_object.id}不存在')

 
    @classmethod
    async def delete_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDataStdModel):
        """
        删除列配置服务
        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 删除列配置对象
        :return: 删除列配置校验结果
        """
        if page_object.ids:
            col_id_list = page_object.ids.split(',')
            try:
                for col_id in col_id_list:
                    col_info = await cls.get_std_code_by_id_services(query_db, col_id)
                    if col_info:
                        # 校验不能删除的系统内置列
                        await DataStdDao.delete_std_code(query_db, col_id)
                await query_db.commit()


                return CrudResponseModel(is_success=True, message='删除列配置成功')
            except Exception as e:
                await query_db.rollback()
                raise e
        else:
            raise ServiceException(message='传入列配置ID为空')
        
    @classmethod
    async def add_std_code_with_items_services(cls, request, query_db: AsyncSession, code: DataStdCodeModel, code_item_list: list[DataStdCodeModel]):
     """
     新增标准代码和对应的代码项
     """
     try:
         # 先校验标准代码是否唯一
         if not await cls.check_code_unique_services(query_db, code):
             raise ServiceException(message=f'新增代码{code.code_name}失败，{code.code_num}代码已存在')
         else:
             # 保存标准代码
             code.id=str(uuid.uuid4())
             await cls.add_std_code_services(request, query_db, code)

         # 为每个代码项设置parent_id，并进行校验
         for code_item in code_item_list:
             # 校验同一个父级下，code是否已存在
             code_item.parent_id = code.id
             if not await cls.check_code_unique_services(query_db, code_item):
                 raise ServiceException(message=f"父级代码{code.code_num}下的代码项{code_item.code_num}已存在")

             # 将parent_id设为code的ID
             code_item.id=str(uuid.uuid4())
             code_item.create_by=code.create_by
             code_item.create_time=code.create_time
             code_item.update_by=code.update_by
             code_item.update_time=code.update_time
             await cls.add_std_code_services(request, query_db, code_item)

         # 提交事务
         await query_db.commit()
         return CrudResponseModel(is_success=True, message='标准代码和代码项新增成功')

     except Exception as e:
         await query_db.rollback()
         raise ServiceException(message=f"新增标准代码失败: {str(e)}")
    @classmethod
    async def edit_std_code_with_items_services(cls, request, query_db: AsyncSession, code: DataStdCodeModel, code_item_list: list[DataStdCodeModel]):
        """
        修改标准代码和对应的代码项。如果code_item.id为0，则执行新增操作，否则执行更新操作。
        """
        try:
              # 校验标准代码是否存在并且唯一
              if not await cls.check_code_unique_services(query_db, code):
                  raise ServiceException(message=f'修改代码{code.code_name}失败，{code.code_num}代码不存在或已存在')
  
              # 更新标准代码
              await cls.edit_std_code_services(request, query_db, code)
  
              # 为每个代码项设置parent_id，并进行校验
              for code_item in code_item_list:
                  code_item.parent_id = code.id
                  if code_item.id :  
                      # 校验同一个父级下，code_num是否已存在
                      if not await cls.check_code_unique_services(query_db, code_item):
                          raise ServiceException(message=f"父级代码{code.code_num}下的代码项{code_item.code_num}已存在")
  
                      # 更新代码项的相关信息
                      code_item.update_time = code.update_time
                      code_item.update_by = code.update_by
                      await cls.edit_std_code_services(request, query_db, code_item)  # 执行更新操作                
  
                  else:  # 如果code_item的id不为0，表示是修改操作
                  # 校验同一个父级下，code_num是否已存在
                      if not await cls.check_code_unique_services(query_db, code_item):
                          raise ServiceException(message=f"父级代码{code.code_num}下的代码项{code_item.code_num}已存在")
                      # 生成新的UUID，并新增代码项
                      code_item.id = str(uuid.uuid4()) # 新生成的UUID
                      code_item.create_time = code.update_time
                      code_item.create_by = code.create_by
                      code_item.update_time = code.update_time
                      code_item.update_by = code.update_by
                      await cls.add_std_code_services(request, query_db, code_item)  # 执行新增操作
              # 提交事务
              await query_db.commit()
              return CrudResponseModel(is_success=True, message='标准代码和代码项修改成功')
        except Exception as e:
              await query_db.rollback()
              raise ServiceException(message=f"修改标准代码失败: {str(e)}")        
    @classmethod
    async def check_code_unique_services(cls, query_db: AsyncSession, page_object: DataStdCodeModel):
        """
        校验字典类型称是否唯一service

        :param query_db: orm对象
        :param page_object: 字典类型对象
        :return: 校验结果
        """
        id = -1 if page_object.id is None else page_object.id
        codemodel=DataStdCodeModel()
        codemodel.code_num=page_object.code_num
        codemodel.class_id=page_object.class_id
        codemodel.parent_id=page_object.parent_id
        codemodel.code_type=page_object.code_type
        dict_type = await DataStdDao.get_data_code_by_info(query_db, codemodel
        )
        if dict_type and dict_type.id != id:
            return CommonConstant.NOT_UNIQUE
        return CommonConstant.UNIQUE        
    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------

    @classmethod
    async def get_std_dict_list_services(
        cls, query_db: AsyncSession, query_object: DataStdDictModel, is_page: bool = False
    ):
        """
        获取列配置列表信息service

        :param query_db: orm对象
        :param query_object: 查询参数对象
        :param is_page: 是否开启分页
        :return: 列配置列表信息对象
        """
        col_list_result = await DataStdDao.get_std_dict_list(query_db, query_object, is_page)
        return col_list_result

  
    @classmethod
    async def get_std_dict_by_id_services(cls, query_db: AsyncSession, id: str):
        """
        获取列配置详细信息service

        :param query_db: orm对象
        :param id: 列配置ID
        :return: 列配置详细信息对象
        """
        col = await DataStdDao.get_std_dict_by_id(query_db, id)
        if col:
            result = DataStdDictModel(**CamelCaseUtil.transform_result(col))
        else:
            result = DataStdDictModel(**dict())
        return result

  
    @classmethod
    async def add_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
        """
        新增列配置服务

        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 新增的列配置对象
        :return: 新增列配置校验结果
        """
        try:
            if not await cls.check_dict_unique_services(query_db, page_object):
                raise ServiceException(message=f"数据字典{page_object.dict_num}已存在")
            # 创建新的 page_object 实例，避免修改原始对象
            new_page_object = DataStdDictModel(**page_object.model_dump(by_alias=True))
            new_page_object.dict_status="0"
            new_page_object.id=str(uuid.uuid4())
            # 调用 DAO 方法插入数据
            await DataStdDao.add_std_dict(query_db, new_page_object)
            return CrudResponseModel(is_success=True, message='新增数据字典成功')
        except Exception as e:
            await query_db.rollback()
            raise e
 

    @classmethod
    async def dict_detail_services(cls, query_db: AsyncSession, col: str):
        """
        获取参数配置详细信息service

        :param query_db: orm对象
        :param config_id: 参数配置id
        :return: 参数配置id对应的信息
        """
        config = await DataStdDao.get_std_dict_by_id(query_db, col)
        if config:
            result = DataStdDictModel(**CamelCaseUtil.transform_result(config))
        else:
            result = DataStdDictModel(**dict())

        return result
    @classmethod
    async def edit_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
        """
        编辑列配置服务

        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 编辑的列配置对象
        :return: 编辑列配置校验结果
        """
        if not await cls.check_dict_unique_services(query_db, page_object):
                raise ServiceException(message=f"数据字典编号：{page_object.dict_num}已存在")
        edit_col = page_object.model_dump(exclude_unset=True)
        col_info = await cls.get_std_dict_by_id_services(query_db, page_object.id)
        if col_info:
            try:
                await DataStdDao.update_std_dict(query_db, edit_col)
                return CrudResponseModel(is_success=True, message='编辑数据字典成功')
            except Exception as e:
                await query_db.rollback()
                raise e
        else:
            raise ServiceException(message=f'数据字典{page_object.id}不存在')

 
    @classmethod
    async def delete_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDataStdModel):
        """
        删除列配置服务
        :param request: Request对象
        :param query_db: orm对象
        :param page_object: 删除列配置对象
        :return: 删除列配置校验结果
        """
        if page_object.ids:
            col_id_list = page_object.ids.split(',')
            try:
                for col_id in col_id_list:
                    col_info = await cls.get_std_dict_by_id_services(query_db, col_id)
                    if col_info:
                        # 校验不能删除的系统内置列
                        await DataStdDao.delete_std_dict(query_db, col_id)
                await query_db.commit()


                return CrudResponseModel(is_success=True, message='删除数据字典成功')
            except Exception as e:
                await query_db.rollback()
                raise e
        else:
            raise ServiceException(message='传入数据字典ID为空')
    @classmethod
    async def check_dict_unique_services(cls, query_db: AsyncSession, page_object: DataStdDictModel):
        """
        校验字典类型称是否唯一service

        :param query_db: orm对象
        :param page_object: 字典类型对象
        :return: 校验结果
        """
        id ='-1' if page_object.id is None else page_object.id
        codemodel=DataStdDictModel()
        codemodel.dict_num=page_object.dict_num

        dict_type = await DataStdDao.get_data_dict_by_info(query_db, codemodel
        )
        if dict_type and dict_type.id != id:
            return CommonConstant.NOT_UNIQUE
        return CommonConstant.UNIQUE