import { postgrestGet, postgrestPost, postgrestPut, postgrestDelete, type PostgrestParams } from '../postgrest-client';
import dayjs from 'dayjs';

/**
 * 评查点列表查询参数
 */
export interface RulesQueryParams {
  page?: number;
  pageSize?: number;
  ruleType?: string;  // 评查点类型ID
  groupId?: string;   // 规则组ID
  isActive?: boolean;
  keyword?: string;
  orderBy?: string;
  orderDirection?: 'asc' | 'desc';
}

/**
 * 评查点列表响应数据
 */
export interface RulesListResponse {
  rules: Rule[];
  totalCount: number;
}

/**
 * API返回的评查点详情
 */
export interface ApiRule {
  id: number;
  code: string;
  name: string;
  evaluation_point_groups_id: number | null;
  risk: string;
  description: string;
  is_enabled: boolean;
  evaluation_point_groups?: {
    first_name: string;
    second_name: string;
  };
  references_laws: Record<string, unknown>;
  extraction_config: {
    type: string;
    fields: string[];
    prompt_setting?: {
      type: string;
      template: string;
    };
  };
  evaluation_config: {
    rules: Array<{
      id: string;
      type: string;
      config: Record<string, unknown>;
    }>;
    logicType: string;
  };
  pass_message: string;
  fail_message: string;
  suggestion_message: string;
  suggestion_message_type: string;
  post_action: string;
  action_config: string;
  created_at: string;
  updated_at: string;
}

/**
 * 评查点详情（前端模型）
 */
export interface Rule {
  id: string;
  code: string;
  name: string;
  ruleType: string;
  groupId: string;
  groupName: string;
  priority: string;
  description: string;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
}

/**
 * 映射API返回的评查点数据到前端模型
 * @param apiRule API返回的评查点数据
 * @returns 前端评查点模型
 */
function mapApiRuleToFrontendModel(apiRule: ApiRule): Rule {
  // 风险等级映射到优先级
  const priorityMap: Record<string, string> = {
    '高': 'high',
    '中': 'medium',
    '低': 'low'
  };

  //评查点类型映射   

  // 规则类型映射（这里根据实际业务逻辑设置一个默认值）
//   const ruleType = 'essential'; // 实际应用中可能需要从其他字段推断
//   console.log("apiRule.evaluation_point_groups",apiRule);
  
  // 如果evaluation_point_groups_id为null或空，则不显示ruleType和groupName
  const isGroupIdEmpty = !apiRule.evaluation_point_groups_id;
  
  // 规则类型只在有分组ID时才显示
  const ruleType = isGroupIdEmpty ? '' : (apiRule.evaluation_point_groups?.first_name || '');

  // 规则组名称只在有分组ID时才显示
  const groupName = isGroupIdEmpty ? '' : (apiRule.evaluation_point_groups?.second_name || `${apiRule.evaluation_point_groups_id}`);
  
  return {
    id: apiRule.id ? apiRule.id.toString() : '', // 添加空值检查
    code: apiRule.code || '',
    name: apiRule.name || '',
    ruleType: ruleType,
    groupId: isGroupIdEmpty ? '' : apiRule.evaluation_point_groups_id?.toString() || '',
    groupName: groupName,
    priority: priorityMap[apiRule.risk] || 'medium',
    description: apiRule.description || '',
    isActive: apiRule.is_enabled === undefined ? false : apiRule.is_enabled,
    createdAt: apiRule.created_at ,
    updatedAt: apiRule.updated_at
  };
}

// 格式化日期的辅助函数
function formatDate(dateString: string): string {
  return dayjs(dateString).format('YYYY-MM-DD HH:mm:ss');
}

/**
 * 获取评查点列表
 * @param params 查询参数
 * @returns 评查点列表、总数和评查点组
 */
export async function getRulesList(params: RulesQueryParams): Promise<{data: RulesListResponse; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 解构并设置默认值
    const { 
      page = 1, 
      pageSize = 10, 
      ruleType, 
      groupId, 
      isActive, 
      keyword,
      orderBy = 'created_at',
      orderDirection = 'desc'
    } = params;
    
    // 构建PostgrestParams参数
    const postgrestParams: PostgrestParams = {
      // 修改select语句，不使用嵌入查询语法
      select: `
        id,
        code,
        name,
        evaluation_point_groups_id,
        risk,
        description,
        is_enabled,
        created_at,
        updated_at
      `,
      // 设置分页
      limit: pageSize,
      offset: (page - 1) * pageSize,
      
      // 设置排序
      order: `${orderBy}.${orderDirection}`,
      
      // 构建过滤条件
      filter: {},

      // 添加额外头部，用于获取总记录数
      headers: {
        'Prefer': 'count=exact'
      }
    };
    
    // 添加精确匹配过滤：规则组ID
    if (groupId) {
      postgrestParams.filter!['evaluation_point_groups_id'] = `eq.${groupId}`;
    }
    
    if (isActive !== undefined) {
      postgrestParams.filter!['is_enabled'] = `eq.${isActive}`;
    }
    
    // 如果指定了评查点类型ID，需要先查询该类型下的所有规则组ID
    if (ruleType) {
      try {
        // 先获取该类型下的所有规则组
        const groupsParams: PostgrestParams = {
          select: 'id',
          filter: {
            'pid': `eq.${ruleType}`
          }
        };
        
        const groupsResponse = await postgrestGet<{code: number; msg: string; data: Array<{id: number}>}>('evaluation_point_groups', groupsParams);
        
        if (groupsResponse.error) {
          console.error('获取规则组列表失败:', groupsResponse.error);
        } else {
          let groupIds: number[] = [];
          
          // 处理不同API响应格式
          if (groupsResponse.data && 'code' in groupsResponse.data && groupsResponse.data.data) {
            if (Array.isArray(groupsResponse.data.data) && groupsResponse.data.data.length > 0) {
              groupIds = groupsResponse.data.data.map(group => group.id);
            }
          } else if (Array.isArray(groupsResponse.data) && groupsResponse.data.length > 0) {
            groupIds = groupsResponse.data.map(group => group.id);
          }
          
          // 使用in过滤条件，如果找到规则组
          if (groupIds.length > 0) {
            postgrestParams.filter!['evaluation_point_groups_id'] = `in.(${groupIds.join(',')})`;
          }
          if (groupId) {
            postgrestParams.filter!['evaluation_point_groups_id'] = `eq.${groupId}`;
          }
        }
      } catch (error) {
        console.error('获取规则组ID出错:', error);
        // 错误不中断流程，继续使用其他筛选条件
      }
    }
    
    // 添加模糊搜索
    if (keyword) {
      // 使用PostgREST的or条件查询
      // 同时搜索name和code字段
      postgrestParams.or = [
        { name: `ilike.*${keyword}*` },
        { code: `ilike.*${keyword}*` }
      ];
    }
    
    // 使用postgrestGet发送请求
    const response = await postgrestGet<{code: number; msg: string; data: ApiRule[]}>('evaluation_points', postgrestParams);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    // 处理不同的API响应格式
    let apiRules: ApiRule[] = [];
    let totalCount = 0;
    
    // 9000端口格式 {code: number, msg: string, data: ApiRule[]}
    if (response.data && 'code' in response.data && response.data.data) {
      if (Array.isArray(response.data.data)) {
        apiRules = response.data.data;
      } else {
        return { error: '接口返回数据格式不正确', status: 500 };
      }
    } 
    // 3000端口格式 ApiRule[]
    else if (Array.isArray(response.data)) {
      apiRules = response.data;
    } 
    // 不支持的格式
    else {
      return { error: '接口返回数据格式不正确', status: 500 };
    }
    
    // 尝试从响应中获取总数
    let rangeHeader = '';
    
    // 安全地检查头信息是否存在
    if (response && 'headers' in response && response.headers && typeof response.headers === 'object') {
      rangeHeader = (response.headers as Record<string, string>)['content-range'] || '';
    }
    
    if (rangeHeader) {
      // 例如 Content-Range: 0-9/42 表示总共有 42 条记录
      const total = rangeHeader.split('/')[1];
      if (total !== '*') {  // '*' 表示未知总数
        totalCount = parseInt(total, 10);
      }
    } else {
      // 如果没有响应头，则使用当前返回的数据长度作为默认值
      totalCount = apiRules.length;
    }
    
    // 打印第一个数据项来查看结构（仅用于调试）
    // if (apiRules.length > 0) {
    //   console.log('评查点数据示例:', JSON.stringify(apiRules[0], null, 2));
    // }
    

    // 收集所有规则分组ID（实际上是二级分组） (多进行一步查找表的操作)
    const groupIds = [...new Set(apiRules.map(rule => rule.evaluation_point_groups_id))];
    // 如果有分组ID，查询分组信息 - 更新类型定义
    const groupsMap: Record<string, {first_name: string; second_name: string}> = {};
    if (groupIds.length > 0) {
      try {
        // 过滤null和空值
        const validGroupIds = groupIds.filter(id => id != null && id.toString().trim() !== '');
        
        if (validGroupIds.length > 0) {
          // 使用Promise.all并行查询所有分组信息 - 使用正确的函数名
          const groupPromises = validGroupIds.map(id => 
            postgrestGet<{code: number; msg: string; data: {id: number; pid: number; name: string; first_name: string; second_name: string}[]}>(
              `rpc/get_evaluation_point_group_with_pid?input_id=${id}`
            )
          );
          
          const groupResponses = await Promise.all(groupPromises);
        //   console.log("groupResponsesdddddddddddddddddd",groupResponses);
          // 处理响应，填充groupsMap
          groupResponses.forEach((response) => {
            if (!response.error && response.data) {
              // 处理不同API响应格式
              if (Array.isArray(response.data.data) && response.data.data.length > 0) {
                const groupid = response.data.data[1]?.id || "";
                groupsMap[groupid] = {
                  first_name: response.data.data[0]?.name || "",
                  second_name: response.data.data[1]?.name || ""
                };
              }else if(Array.isArray(response.data) && response.data.length > 0){
                const groupid = response.data[1]?.id || "";
                groupsMap[groupid] = {
                  first_name: response.data[0]?.name || "",
                  second_name: response.data[1]?.name || ""
                };
              }
            }
          });
        }
      } catch (error) {
        console.error('获取分组数据失败:', error);
        // 失败不阻止主流程，使用默认分组名
      }
    }
    

    // 应用本地过滤 - 只在API不支持的情况下使用
    const filteredRules = [...apiRules];
    // 不再需要本地过滤，因为已经在API层面添加了评查点类型过滤
    // 如果进行了本地过滤，则需要调整总记录数
    // if (ruleType) {
    //   totalCount = filteredRules.length;
    // }
    

    // 将API返回的数据映射到前端模型，并附加分组名称
    console.log("groupsMap",groupsMap);
    const mappedRules = filteredRules.map(apiRule => {
      // 创建修改版的apiRule，添加从分组映射获取的名称
      const enhancedApiRule = {
        ...apiRule,
        // 从映射中获取分组名称，如果不存在则使用默认值
        evaluation_point_groups: {
          first_name: groupsMap[apiRule.evaluation_point_groups_id?.toString() || '']?.first_name || `${apiRule.evaluation_point_groups_id}`,
          second_name: groupsMap[apiRule.evaluation_point_groups_id?.toString() || '']?.second_name || `${apiRule.evaluation_point_groups_id}`
        }
      };
      
      const rule = mapApiRuleToFrontendModel(enhancedApiRule);
      
      // 格式化日期字段
      rule.createdAt = formatDate(rule.createdAt);
      rule.updatedAt = formatDate(rule.updatedAt);
      
      return rule;
    });
    
    // 返回结果
    return {
      data: {
        rules: mappedRules,
        totalCount
      }
    };
  } catch (error) {
    console.error('获取评查点列表出错:', error);
    return { 
      error: error instanceof Error ? error.message : '获取评查点列表失败',
      status: 500
    };
  }
}

/**
 * 获取单个评查点详情
 * @param id 评查点ID
 * @returns 评查点详情
 */
export async function getRule(id: string): Promise<{data: Rule; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 使用postgrestGet获取单个评查点数据
    const postgrestParams: PostgrestParams = {
      // 使用PostgREST资源嵌入语法获取关联数据
      select: `
        id,
        code,
        name,
        evaluation_point_groups_id,
        risk,
        description,
        is_enabled,
        references_laws,
        extraction_config,
        evaluation_config,
        pass_message,
        fail_message,
        suggestion_message,
        suggestion_message_type,
        post_action,
        action_config,
        created_at,
        updated_at
      `
    };
    
    // 获取评查点详情
    const response = await postgrestGet<{code: number; msg: string; data: ApiRule}>(`evaluation_points/${id}`, postgrestParams);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    // 确保响应数据存在且符合预期格式
    if (!response.data || !response.data.data) {
      return { error: '接口返回数据格式不正确', status: 500 };
    }
    
    const apiRule = response.data.data;
    
    // 获取分组信息
    try {
      if (apiRule.evaluation_point_groups_id) {
        const groupParams: PostgrestParams = {
          select: 'id,name',
          filter: {
            'id': `eq.${apiRule.evaluation_point_groups_id}`
          }
        };
        
        // 查询评查点分组
        const groupResponse = await postgrestGet<{code: number; msg: string; data: {id: number; name: string}[]}>('evaluation_point_groups', groupParams);
        
        if (groupResponse.data?.data && groupResponse.data.data.length > 0) {
          // 将分组信息添加到评查点数据中
          const group = groupResponse.data.data[0];
          apiRule.evaluation_point_groups = { 
            first_name: group.name, 
            second_name: group.name 
          };
        }
      }
    } catch (error) {
      console.error('获取分组信息失败:', error);
      // 忽略错误，使用默认分组名
    }
    
    // 将API返回的数据映射到前端模型
    const rule = mapApiRuleToFrontendModel(apiRule);
    
    // 格式化日期字段 
    rule.createdAt = formatDate(rule.createdAt);
    rule.updatedAt = formatDate(rule.updatedAt);
    
    return { data: rule };
  } catch (error) {
    console.error('获取评查点详情出错:', error);
    return { 
      error: error instanceof Error ? error.message : '获取评查点详情失败',
      status: 500
    };
  }
}

/**
 * 创建新评查点
 * @param ruleData 评查点数据
 * @returns 创建的评查点
 */
export async function createRule(ruleData: Omit<Rule, 'id' | 'createdAt' | 'updatedAt'>): Promise<{data: Rule; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 将前端模型转换为API接受的格式
    const apiRuleData = {
      code: ruleData.code,
      name: ruleData.name,
      evaluation_point_groups_id: parseInt(ruleData.groupId),
      risk: ruleData.priority === 'high' ? '高' : ruleData.priority === 'medium' ? '中' : '低',
      description: ruleData.description,
      is_enabled: ruleData.isActive,
      // 以下是默认值，实际应用中需要根据业务逻辑设置
      references_laws: {},
      extraction_config: {
        type: "OCR+LLM",
        fields: []
      },
      evaluation_config: {
        rules: [],
        logicType: "and"
      },
      pass_message: "",
      fail_message: "",
      suggestion_message: "",
      suggestion_message_type: "warning",
      post_action: "none",
      action_config: ""
    };
    
    // 使用postgrestPost创建评查点
    const response = await postgrestPost<{code: number; msg: string; data: ApiRule}, typeof apiRuleData>('evaluation_points', apiRuleData);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    // 确保响应数据存在且符合预期格式
    if (!response.data || !response.data.data) {
      return { error: '接口返回数据格式不正确', status: 500 };
    }
    
    // 将API返回的数据映射到前端模型
    const rule = mapApiRuleToFrontendModel(response.data.data);
    
    return { data: rule };
  } catch (error) {
    console.error('创建评查点出错:', error);
    return { 
      error: error instanceof Error ? error.message : '创建评查点失败',
      status: 500
    };
  }
}

/**
 * 更新评查点
 * @param id 评查点ID
 * @param ruleData 评查点数据
 * @returns 更新后的评查点
 */
export async function updateRule(id: string, ruleData: Partial<Omit<Rule, 'id' | 'createdAt' | 'updatedAt'>>): Promise<{data: Rule; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 构建API接受的更新数据
    const apiRuleData: Record<string, unknown> = {};
    
    if (ruleData.code !== undefined) {
      apiRuleData.code = ruleData.code;
    }
    
    if (ruleData.name !== undefined) {
      apiRuleData.name = ruleData.name;
    }
    
    if (ruleData.groupId !== undefined) {
      apiRuleData.evaluation_point_groups_id = parseInt(ruleData.groupId);
    }
    
    if (ruleData.priority !== undefined) {
      apiRuleData.risk = ruleData.priority === 'high' ? '高' : ruleData.priority === 'medium' ? '中' : '低';
    }
    
    if (ruleData.description !== undefined) {
      apiRuleData.description = ruleData.description;
    }
    
    if (ruleData.isActive !== undefined) {
      apiRuleData.is_enabled = ruleData.isActive;
    }
    
    // 使用postgrestPut更新评查点
    const response = await postgrestPut<{code: number; msg: string; data: ApiRule}, typeof apiRuleData>(`evaluation_points/${id}`, apiRuleData);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    // 确保响应数据存在且符合预期格式
    if (!response.data || !response.data.data) {
      return { error: '接口返回数据格式不正确', status: 500 };
    }
    
    // 将API返回的数据映射到前端模型
    const rule = mapApiRuleToFrontendModel(response.data.data);
    
    return { data: rule };
  } catch (error) {
    console.error('更新评查点出错:', error);
    return { 
      error: error instanceof Error ? error.message : '更新评查点失败',
      status: 500
    };
  }
}

/**
 * 删除评查点
 * @param id 评查点ID
 * @returns 删除结果
 */
export async function deleteRule(id: string): Promise<{data: Rule; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    console.log(`开始删除评查点, ID: ${id}`);
    
    // 使用 PostgREST 语法，通过查询参数指定要删除的行
    const postgrestParams: PostgrestParams = {
      filter: {
        'id': `eq.${id}`
      },
      headers: {
        'Prefer': 'return=representation'  // 请求返回被删除的记录
      }
    };
    
    // 使用postgrestDelete删除评查点
    const response = await postgrestDelete('evaluation_points', postgrestParams);
    
    console.log('删除请求响应:', JSON.stringify(response, null, 2));
    
    // 检查是否有错误响应
    if (response.error) {
      console.error('删除评查点API返回错误:', response.error);
      return { error: response.error, status: response.status };
    }
    
    // 确保响应数据存在
    if (!response.data) {
      console.error('API响应缺少数据字段');
      return { error: 'API返回数据为空', status: 500 };
    }
    
    // 创建一个模拟的成功删除结果
    const createMockSuccessRule = (): Rule => {
      return {
        id: id,
        code: '',
        name: '',
        ruleType: '',
        groupId: '',
        groupName: '',
        priority: 'medium',
        description: '',
        isActive: false,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };
    };
    
    // 处理9000端口响应格式
    if (typeof response.data === 'object' && response.data !== null && 'code' in response.data) {
      const apiResponse = response.data as {code: number; msg: string; data?: ApiRule | ApiRule[]};
      
      // 检查响应的code - 如果code为0则表示操作成功
      if (apiResponse.code === 0) {
        // 如果data不存在或是空数组，返回模拟数据
        if (!apiResponse.data || (Array.isArray(apiResponse.data) && apiResponse.data.length === 0)) {
          return { data: createMockSuccessRule() };
        }
        
        // 处理存在的data
        let apiRule: ApiRule;
        if (Array.isArray(apiResponse.data)) {
          apiRule = apiResponse.data[0];
        } else {
          apiRule = apiResponse.data;
        }
        
        // 将API返回的数据映射到前端模型
        const rule = mapApiRuleToFrontendModel(apiRule);
        return { data: rule };
      }
      
      // 如果code不为0，则返回错误信息
      return { 
        error: apiResponse.msg || '删除失败，服务器返回错误', 
        status: 500 
      };
    } 
    // 处理3000端口响应格式 (直接返回数据)
    else {
      // 处理数组响应
      if (Array.isArray(response.data)) {
        if (response.data.length === 0) {
          // 空数组表示成功但没有返回数据
          return { data: createMockSuccessRule() };
        } else {
          // 返回数组中的第一个元素
          const apiRule = response.data[0] as ApiRule;
          const rule = mapApiRuleToFrontendModel(apiRule);
          return { data: rule };
        }
      } 
      // 处理单一对象响应
      else {
        const apiRule = response.data as ApiRule;
        const rule = mapApiRuleToFrontendModel(apiRule);
        return { data: rule };
      }
    }
  } catch (error) {
    console.error('删除评查点出错:', error);
    return { 
      error: error instanceof Error ? error.message : '删除评查点失败',
      status: 500
    };
  }
}

/**
 * 复制评查点
 * @param id 评查点ID
 * @returns 新创建的评查点
 */
export async function duplicateRule(id: string): Promise<{data: Rule; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 1. 获取原评查点详情
    const ruleResponse = await getRule(id);
    
    if (ruleResponse.error || !ruleResponse.data) {
      return { error: ruleResponse.error || '获取评查点详情失败', status: 500 };
    }
    
    // 2. 准备新评查点数据
    const rule = ruleResponse.data;
    
    // 创建新评查点对象
    const newRuleData = {
      code: `${rule.code}-COPY`,
      name: `${rule.name} (复制)`,
      ruleType: rule.ruleType,
      groupId: rule.groupId,
      groupName: rule.groupName,
      priority: rule.priority,
      description: rule.description,
      isActive: rule.isActive
    };
    
    // 3. 创建新评查点
    return createRule(newRuleData);
    
  } catch (error) {
    console.error('复制评查点出错:', error);
    return { 
      error: error instanceof Error ? error.message : '复制评查点失败',
      status: 500
    };
  }
}

/**
 * 评查点类型
 */
export interface RuleType {
  id: string;
  name: string;
  description?: string;
  isEnabled: boolean;
}

/**
 * 规则组
 */
export interface RuleGroup {
  id: string;
  name: string;
  description?: string;
  isEnabled: boolean;
  typeId?: string; // 关联的评查点类型ID
}

/**
 * 获取评查点类型列表
 * @returns 评查点类型列表
 */
export async function getRuleTypes(): Promise<{data: RuleType[]; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 构建PostgrestParams参数
    const postgrestParams: PostgrestParams = {
      select: `
        id,
        pid,
        code,
        name,
        description,
        is_enabled
      `,
      // 查询父ID为0的类型（顶级类型）
      filter: {
        'pid': 'eq.0'
      }
    };
    
    // 发送请求获取评查点类型列表
    const response = await postgrestGet<{code: number; msg: string; data: Array<{
      id: number;
      pid: number;
      code: string;
      name: string;
      description: string;
      is_enabled: boolean;
    }>;
    }>('evaluation_point_groups', postgrestParams);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    if(response.data && 'code' in response.data && response.data.data){
      if(Array.isArray(response.data.data) && response.data.data.length > 0){
        // 将API返回的数据映射到前端模型
    const ruleTypes = response.data.data.map(item => ({
      id: item.id.toString(),
      pid: item.pid.toString(),
      code: item.code,
      name: item.name,
      description: item.description,
      isEnabled: item.is_enabled
    }));
            return { data: ruleTypes };
      }else{
        return { error: '9000接口返回数据格式不正确', status: 500 };
      }
    }else if(Array.isArray(response.data) && response.data.length > 0){
      console.log("评查点类型列表",response.data);
      const ruleTypes = response.data.map(item => ({
        id: item.id.toString(),
        pid: item.pid.toString(),
        code: item.code,
        name: item.name,
        description: item.description,
        isEnabled: item.is_enabled
      }));
      return { data: ruleTypes };
    }else{
      return { error: '3000接口返回数据格式不正确', status: 500 };
    }
  } catch (error) {
    console.error('获取评查点类型出错:', error);
    return { 
      error: error instanceof Error ? error.message : '获取评查点类型失败',
      status: 500
    };
  }
}

/**
 * 根据评查点类型ID获取规则组列表
 * @param typeId 评查点类型ID
 * @returns 规则组列表
 */
export async function getRuleGroupsByType(typeId: string): Promise<{data: RuleGroup[]; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 如果typeId为空或为"全部"，则返回空数组
    if (!typeId || typeId === 'all') {
      return { data: [] };
    }
    
    // 构建PostgrestParams参数
    const postgrestParams: PostgrestParams = {
      select: `
        id,
        pid,
        code,
        name,
        description,
        is_enabled
      `,
      // 查询指定类型ID的规则组
      filter: {
        'pid': `eq.${typeId}`
      }
    };
    
    // 发送请求获取规则组列表
    const response = await postgrestGet<{code: number; msg: string; data: Array<{
      id: number;
      pid: number;
      code: string;
      name: string;
      description: string;
      is_enabled: boolean;
    }>;
    }>('evaluation_point_groups', postgrestParams);
    
    // 检查是否有错误响应
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    // 确保响应数据存在且符合预期格式
    if(response.data && 'code' in response.data && response.data.data){
      if(Array.isArray(response.data.data) && response.data.data.length > 0){
        // 将API返回的数据映射到前端模型
        const ruleGroups = response.data.data.map(item => ({
          id: item.id.toString(),
          name: item.name,
          description: item.description,
          isEnabled: item.is_enabled,
          code: item.code
        }));
        return { data: ruleGroups };
      }else{
        return { error: '9000接口返回数据格式不正确', status: 500 };
      }
    }else if(Array.isArray(response.data) && response.data.length > 0){
      console.log("评查点类型列表",response.data);
      const ruleGroups = response.data.map(item => ({
        id: item.id.toString(),
        name: item.name,
        description: item.description,
        isEnabled: item.is_enabled,
        code: item.code
      }));
      return { data: ruleGroups };
    }else{
      return { error: '3000接口返回数据格式不正确', status: 500 };
    }
  } catch (error) {
    console.error('获取规则组出错:', error);
    return { 
      error: error instanceof Error ? error.message : '获取规则组失败',
      status: 500
    };
  }
} 