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

/**
 * 评查点分组接口
 */
export interface RuleGroup {
  id: string;
  pid: string;
  name: string;
  code?: string;   // 添加分组编码字段
  is_enabled: boolean;
  ruleCount?: number;  // 评查点数量
  children?: RuleGroup[];  // 子分组
  createdAt?: string;  // 添加创建时间字段
  description?: string; // 描述
}

// API请求模型
export interface ApiRuleGroup {
  id?: number;
  pid: number | null;  // 允许 null，表示一级分组
  name: string;
  code?: string;
  description?: string;
  is_enabled: boolean;
  created_at?: string;
  updated_at?: string;
}

// 创建或更新分组请求参数
export interface RuleGroupCreateUpdateDto {
  name: string;
  code: string;
  pid: string | null; // 父分组ID，如果是一级分组则为null或'0'
  description?: string;
  is_enabled: boolean;
}

// 用于替换代码中的 any 类型
interface ApiResponse<T> {
  code: number;
  msg: string;
  data: T;
}



/**
 * 从不同格式的 API 响应中提取数据
 * @param responseData API 响应数据
 * @returns 提取后的数据或 null
 */
function extractApiData<T>(responseData: unknown): T | null {
  if (!responseData) return null;
  
  // 格式1: { code: number, msg: string, data: T }
  if (typeof responseData === 'object' && responseData !== null && 
      'code' in responseData && 
      'data' in responseData && 
      (responseData as { data: unknown }).data) {
    return (responseData as { data: T }).data;
  }
  
  // 格式2: 直接是数据对象
  return responseData as T;
}

/**
 * 评查点分组查询参数
 */
export interface RuleGroupQueryParams {
  // 分页参数
  page?: number;
  pageSize?: number;

  // 筛选参数
  name?: string;         // 名称模糊搜索
  code?: string;         // 编码模糊搜索
  is_enabled?: boolean;  // 启用状态
  pid?: string | null;   // 父级ID (null表示一级分组, 具体ID表示查询该父级的子分组)

  // 排序参数
  orderBy?: 'created_at' | 'updated_at' | 'name' | 'code';
  order?: 'asc' | 'desc';

  token?: string;
}

/**
 * 获取评查点分组列表（支持分页、筛选、排序）
 * @param params 查询参数
 * @returns 评查点分组列表和总数
 */
export async function getRuleGroups(
  params?: RuleGroupQueryParams
): Promise<{data: RuleGroup[]; totalCount?: number; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    const {
      page = 1,
      pageSize = 50,
      name,
      code,
      is_enabled,
      pid = '0',  // 默认获取一级分组
      orderBy = 'created_at',
      order = 'desc',
      token
    } = params || {};

    // 构建筛选条件
    const filter: Record<string, string> = {};

    // 父级ID筛选 (pid=null或'0'表示一级分组)
    if (pid === null || pid === '0') {
      filter['pid'] = 'eq.0';
    } else if (pid) {
      filter['pid'] = `eq.${pid}`;
    }

    // 名称模糊搜索
    if (name) {
      filter['name'] = `ilike.*${name}*`;
    }

    // 编码模糊搜索
    if (code) {
      filter['code'] = `ilike.*${code}*`;
    }

    // 状态筛选
    if (is_enabled !== undefined) {
      filter['is_enabled'] = `eq.${is_enabled}`;
    }

    const postgrestParams: PostgrestParams = {
      select: `
        id,
        pid,
        name,
        code,
        description,
        is_enabled,
        created_at
      `,
      filter,
      order: `${orderBy}.${order}`,  // PostgREST order format: field.direction
      limit: pageSize,
      offset: (page - 1) * pageSize,
      token
    };

    const response = await postgrestGet<{code: number; msg: string; data: Array<{
      id: number;
      pid: number;
      name: string;
      code?: string;
      description?: string;
      is_enabled: boolean;
      created_at?: string;
    }>}>('evaluation_point_groups', postgrestParams);

    if (response.error) {
      return { error: response.error, status: response.status };
    }

    // 处理响应数据
    let groups: RuleGroup[] = [];
    if (response.data && 'code' in response.data && response.data.data) {
      groups = response.data.data.map(group => ({
        id: group.id.toString(),
        pid: group.pid.toString(),
        name: group.name,
        code: group.code,
        description: group.description,
        is_enabled: group.is_enabled,
        createdAt: group.created_at ? formatDate(group.created_at) : undefined
      }));
    } else if (Array.isArray(response.data)) {
      groups = response.data.map(group => ({
        id: group.id.toString(),
        pid: group.pid.toString(),
        name: group.name,
        code: group.code,
        description: group.description,
        is_enabled: group.is_enabled,
        createdAt: group.created_at ? formatDate(group.created_at) : undefined
      }));
    }

    // 注意：由于当前 PostgREST 客户端不支持 count 参数，totalCount 返回当前页的记录数
    // 后续可优化为单独查询获取准确的总数
    return {
      data: groups,
      totalCount: groups.length
    };
  } catch (error) {
    console.error('获取评查点分组列表失败:', error);
    return {
      error: error instanceof Error ? error.message : '获取评查点分组列表失败',
      status: 500
    };
  }
}

/**
 * 获取指定分组的子分组（包含评查点数量统计）
 * @param parentId 父分组ID
 * @param token JWT token (可选)
 * @returns 子分组列表
 */
export async function getChildGroups(parentId: string, token?: string): Promise<{data: RuleGroup[]; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 使用改进后的 getRuleGroups 函数获取子分组
    const response = await getRuleGroups({
      pid: parentId,
      pageSize: 1000, // 设置较大的页面大小以获取所有子分组
      token
    });

    if (response.error) {
      return { error: response.error, status: response.status };
    }

    const childGroups = response.data || [];

    // 为每个子分组添加评查点数量统计
    const groupsWithCount = await Promise.all(
      childGroups.map(async (group) => {
        // 获取该分组的评查点数量
        const ruleCountParams: PostgrestParams = {
          select: 'id',
          filter: {
            'evaluation_point_groups_id': `eq.${group.id}`
          },
          token
        };

        const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>(
          'evaluation_points',
          ruleCountParams
        );

        let ruleCount = 0;
        if (ruleCountResponse.error) {
          // 查询失败，使用默认值 0
          ruleCount = 0;
        } else if (ruleCountResponse.data) {
          // 处理包装格式的响应
          if ('code' in ruleCountResponse.data && 'data' in ruleCountResponse.data) {
            const wrappedData = ruleCountResponse.data as {code: number; data: Array<{id: number}>};
            ruleCount = Array.isArray(wrappedData.data) ? wrappedData.data.length : 0;
          }
          // 处理直接数组格式的响应
          else if (Array.isArray(ruleCountResponse.data)) {
            ruleCount = (ruleCountResponse.data as Array<{id: number}>).length;
          }
        }

        return {
          ...group,
          ruleCount
        };
      })
    );

    return { data: groupsWithCount };
  } catch (error) {
    console.error('获取子分组列表出错:', error);
    return {
      error: error instanceof Error ? error.message : '获取子分组列表失败',
      status: 500
    };
  }
}

/**
 * 获取所有评查点分组（包括一级和二级）
 * @param token JWT token (可选)
 * @returns 完整的评查点分组列表
 */
export async function getAllRuleGroups(token?: string): Promise<{data: RuleGroup[]; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 1. 获取所有分组
    const allGroupsParams: PostgrestParams = {
      select: `
        id,
        pid,
        name,
        is_enabled
      `,
      token
    };
    
    const allGroupsResponse = await postgrestGet<{code: number; msg: string; data: Array<{
      id: number;
      pid: number;
      name: string;
      is_enabled: boolean;
    }>}>('evaluation_point_groups', allGroupsParams);
    
    if (allGroupsResponse.error) {
      return { error: allGroupsResponse.error, status: allGroupsResponse.status };
    }
    
    // 2. 处理响应数据
    let allGroups: RuleGroup[] = [];
    if (allGroupsResponse.data && 'code' in allGroupsResponse.data && allGroupsResponse.data.data) {
      allGroups = allGroupsResponse.data.data.map(group => ({
        id: group.id.toString(),
        pid: group.pid.toString(),
        name: group.name,
        is_enabled: group.is_enabled,
        children: []
      }));
    } else if (Array.isArray(allGroupsResponse.data)) {
      allGroups = allGroupsResponse.data.map(group => ({
        id: group.id.toString(),
        pid: group.pid.toString(),
        name: group.name,
        is_enabled: group.is_enabled,
        children: []
      }));
    }
    
    // 3. 构建树形结构（pid为NULL表示顶级分组）
    const parentGroups = allGroups.filter(group => !group.pid || group.pid === '0' || group.pid === null);
    
    // 4. 为每个父分组添加子分组
    for (const parent of parentGroups) {
      parent.children = allGroups.filter(group => group.pid === parent.id);
      
      // 5. 获取每个子分组的评查点数量
      for (const child of parent.children) {
        const ruleCountParams: PostgrestParams = {
          select: 'id',
          filter: {
            'evaluation_point_groups_id': `eq.${child.id}`
          },
          token
        };
        
        const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>('evaluation_points', ruleCountParams);
        
        child.ruleCount = ruleCountResponse.data && 'code' in ruleCountResponse.data 
          ? (ruleCountResponse.data.data && Array.isArray(ruleCountResponse.data.data) ? ruleCountResponse.data.data.length : 0)
          : (Array.isArray(ruleCountResponse.data) ? (ruleCountResponse.data as unknown[]).length : 0)
      }
    }
    
    return { data: parentGroups };
  } catch (error) {
    console.error('获取所有评查点分组出错:', error);
    return { 
      error: error instanceof Error ? error.message : '获取所有评查点分组失败',
      status: 500
    };
  }
}

/**
 * 获取单个评查点分组详情（包含评查点数量统计）
 * @param id 分组ID
 * @param token JWT token (可选)
 * @returns 分组详情
 */
export async function getRuleGroup(id: string, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    if (!id) {
      return { error: '分组ID不能为空', status: 400 };
    }

    const params: PostgrestParams = {
      select: `
        id,
        pid,
        name,
        code,
        description,
        is_enabled,
        created_at
      `,
      filter: {
        'id': `eq.${id}`
      },
      token
    };

    const response = await postgrestGet<{code: number; msg: string; data: Array<{
      id: number;
      pid: number;
      name: string;
      code?: string;
      description?: string;
      is_enabled: boolean;
      created_at?: string;
    }>}>('evaluation_point_groups', params);

    if (response.error) {
      return { error: response.error, status: response.status };
    }

    let group: RuleGroup | null = null;

    if (response.data && 'code' in response.data && response.data.data && response.data.data.length > 0) {
      const apiGroup = response.data.data[0];
      group = {
        id: apiGroup.id.toString(),
        pid: apiGroup.pid.toString(),
        name: apiGroup.name,
        code: apiGroup.code,
        description: apiGroup.description,
        is_enabled: apiGroup.is_enabled,
        createdAt: apiGroup.created_at ? formatDate(apiGroup.created_at) : undefined
      };
    } else if (Array.isArray(response.data) && response.data.length > 0) {
      const apiGroup = response.data[0];
      group = {
        id: apiGroup.id.toString(),
        pid: apiGroup.pid.toString(),
        name: apiGroup.name,
        code: apiGroup.code,
        description: apiGroup.description,
        is_enabled: apiGroup.is_enabled,
        createdAt: apiGroup.created_at ? formatDate(apiGroup.created_at) : undefined
      };
    }

    if (!group) {
      return { error: '未找到指定分组', status: 404 };
    }

    // 获取该分组下的评查点数量（一级分组和二级分组都统计）
    const ruleCountParams: PostgrestParams = {
      select: 'id',
      filter: {
        'evaluation_point_groups_id': `eq.${group.id}`
      },
      token
    };

    const ruleCountResponse = await postgrestGet<ApiResponse<Array<{id: number}>>>(
      'evaluation_points',
      ruleCountParams
    );

    // 计算评查点数量
    let ruleCount = 0;
    if (ruleCountResponse.error) {
      // 查询失败，使用默认值 0
      ruleCount = 0;
    } else if (ruleCountResponse.data) {
      // 处理包装格式的响应
      if ('code' in ruleCountResponse.data && 'data' in ruleCountResponse.data) {
        const wrappedData = ruleCountResponse.data as {code: number; data: Array<{id: number}>};
        ruleCount = Array.isArray(wrappedData.data) ? wrappedData.data.length : 0;
      }
      // 处理直接数组格式的响应
      else if (Array.isArray(ruleCountResponse.data)) {
        ruleCount = (ruleCountResponse.data as Array<{id: number}>).length;
      }
    }

    group.ruleCount = ruleCount;

    return { data: group };
  } catch (error) {
    console.error('获取评查点分组详情失败:', error);
    return {
      error: error instanceof Error ? error.message : '获取评查点分组详情失败',
      status: 500
    };
  }
}

/**
 * 创建评查点分组
 * @param groupData 分组数据
 * @param token JWT token (可选)
 * @returns 创建的分组
 */
export async function createRuleGroup(groupData: RuleGroupCreateUpdateDto, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 验证必填字段
    if (!groupData.name || !groupData.code) {
      return { error: '分组名称和编码不能为空', status: 400 };
    }
    
    // 🆕 确保 pid 是合法值（NULL表示顶级分组）
    let pidValue: number | null;
    try {
      if (!groupData.pid || groupData.pid === '0') {
        pidValue = null; // 顶级分组
      } else {
        pidValue = Number(groupData.pid);
        if (isNaN(pidValue)) {
          return { error: '父分组ID必须是有效的数字', status: 400 };
        }
      }
    } catch (error) {
      console.error('父分组ID转换失败:', error);
      return { error: '父分组ID格式错误', status: 400 };
    }
    
    // 构建API请求数据 - 确保字段类型符合数据库要求
    const apiGroup: ApiRuleGroup = {
      pid: pidValue,
      name: groupData.name.trim(),
      code: groupData.code.trim(),
      description: groupData.description || '',
      is_enabled: groupData.is_enabled
    };
    
    // console.log('创建评查点分组请求数据:', JSON.stringify(apiGroup, null, 2));
    
    // 直接发送到 PostgreSQL 表
    const response = await postgrestPost<ApiResponse<ApiRuleGroup> | ApiRuleGroup, ApiRuleGroup>(
      'evaluation_point_groups', // 表名
      apiGroup,
      token
    );
    
    if (response.error) {
      console.error('创建评查点分组API返回错误:', response.error, '状态码:', response.status);
      return { error: response.error, status: response.status };
    }
    
    // console.log('创建评查点分组响应数据:', JSON.stringify(response.data, null, 2));
    
    // 处理响应数据 - 适配不同的API响应格式
    const apiResponse = extractApiData<ApiRuleGroup>(response.data);
    
    if (!apiResponse) {
      console.error('创建分组成功但返回数据格式异常:', response.data);
      return { error: '创建分组失败，返回数据格式错误', status: 500 };
    }
    
    // 构建返回对象
    const createdGroup: RuleGroup = {
      id: apiResponse.id?.toString() || '',
      pid: apiResponse.pid?.toString() || '', // 🆕 NULL 转换为空字符串（表示顶级分组）
      name: apiResponse.name || '',
      code: apiResponse.code?.toString() || '', // 处理可能的数字类型
      description: apiResponse.description,
      is_enabled: apiResponse.is_enabled !== undefined ? apiResponse.is_enabled : true,
      createdAt: apiResponse.created_at ? formatDate(apiResponse.created_at) : undefined
    };
    
    return { data: createdGroup };
  } catch (error) {
    console.error('创建评查点分组失败:', error);
    return { 
      error: error instanceof Error ? error.message : '创建评查点分组失败',
      status: 500
    };
  }
}

/**
 * 更新评查点分组
 * @param id 分组ID
 * @param data 更新的分组数据
 * @param token JWT token (可选)
 * @returns 更新后的分组
 */
export async function updateRuleGroup(id: string, data: RuleGroupCreateUpdateDto, token?: string): Promise<{data: RuleGroup; error?: never} | {data?: never; error: string; status?: number}> {
  try {
    // 验证必填字段
    if (!data.name || !data.code) {
      return { error: '分组名称和编码不能为空', status: 400 };
    }

    // 构建符合数据库结构的对象
    const apiGroup: Partial<ApiRuleGroup> = {
      name: data.name.trim(),
      code: data.code.trim(),
      description: data.description || '',
      is_enabled: data.is_enabled
    };

    // 🆕 如果需要更新父分组，添加 pid（NULL表示顶级分组）
    if (data.pid !== undefined) {
      let pidValue: number | null;
      if (!data.pid || data.pid === '0') {
        pidValue = null; // 顶级分组
      } else {
        pidValue = Number(data.pid);
        if (isNaN(pidValue)) {
          return { error: '父分组ID必须是有效的数字', status: 400 };
        }
      }
      apiGroup.pid = pidValue;
    }

    // 使用新的filters参数
    const response = await postgrestPut<ApiResponse<RuleGroup> | RuleGroup, Partial<ApiRuleGroup>>(
      'evaluation_point_groups',
      apiGroup,  // 使用转换后的对象
      { id },
      token
    );

    if (response.error) {
      return { error: response.error, status: response.status };
    }

    // 使用辅助函数提取数据
    const extractedData = extractApiData<RuleGroup>(response.data);

    if (!extractedData) {
      return { error: '更新成功但未返回数据' };
    }

    return { data: extractedData };
  } catch (error) {
    console.error('更新评查点分组失败:', error);
    return {
      error: error instanceof Error ? error.message : '更新评查点分组失败'
    };
  }
}

/**
 * 删除评查点分组
 * @param id 分组ID
 * @param token JWT token (可选)
 * @returns 删除结果
 */
export async function deleteRuleGroup(id: string, token?: string): Promise<{success: boolean; error?: string}> {
  try {
    // 1. 首先获取分组信息，判断是一级还是二级分组
    const groupResponse = await getRuleGroup(id, token);
    if (groupResponse.error) {
      return { success: false, error: groupResponse.error };
    }

    const group = groupResponse.data;
    if (!group) {
      return { success: false, error: '未找到指定分组' };
    }

    // 2. 如果是一级分组（顶级分组，pid为NULL或'0'），需要先删除所有子分组
    if (!group.pid || group.pid === '0' || group.pid === null) {
      // 获取所有子分组
      const childGroupsResponse = await getChildGroups(id, token);
      if (childGroupsResponse.error) {
        return { success: false, error: childGroupsResponse.error };
      }

      const childGroups = childGroupsResponse.data || [];
      
      // 遍历删除每个子分组
      for (const childGroup of childGroups) {
        const deleteChildResult = await deleteChildGroup(childGroup.id, token);
        if (!deleteChildResult.success) {
          return deleteChildResult;
        }
      }
    }

    // 3. 删除分组下的所有评查点
    const deletePointsResult = await deleteEvaluationPointsByGroupId(id, token);
    if (!deletePointsResult.success) {
      return deletePointsResult;
    }

    // 4. 最后删除分组本身
    const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_point_groups', {
      filter: {
        'id': `eq.${id}`
      },
      token
    });

    if (response.error) {
      return { success: false, error: response.error };
    }

    return { success: true };
  } catch (error) {
    console.error('删除评查点分组失败:', error);
    return { 
      success: false, 
      error: error instanceof Error ? error.message : '删除评查点分组失败'
    };
  }
}

/**
 * 删除子分组及其相关数据
 * @param id 子分组ID
 * @param token JWT token (可选)
 * @returns 删除结果
 */
async function deleteChildGroup(id: string, token?: string): Promise<{success: boolean; error?: string}> {
  try {
    // 1. 删除子分组下的所有评查点
    const deletePointsResult = await deleteEvaluationPointsByGroupId(id, token);
    if (!deletePointsResult.success) {
      return deletePointsResult;
    }

    // 2. 删除子分组本身
    const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_point_groups', {
      filter: {
        'id': `eq.${id}`
      },
      token
    });

    if (response.error) {
      return { success: false, error: response.error };
    }

    return { success: true };
  } catch (error) {
    console.error('删除子分组失败:', error);
    return { 
      success: false, 
      error: error instanceof Error ? error.message : '删除子分组失败'
    };
  }
}

/**
 * 删除指定分组下的所有评查点
 * @param groupId 分组ID
 * @param token JWT token (可选)
 * @returns 删除结果
 */
async function deleteEvaluationPointsByGroupId(groupId: string, token?: string): Promise<{success: boolean; error?: string}> {
  try {
    const response = await postgrestDelete<ApiResponse<{id: number}>>('evaluation_points', {
      filter: {
        'evaluation_point_groups_id': `eq.${groupId}`
      },
      token
    });

    if (response.error) {
      return { success: false, error: response.error };
    }

    return { success: true };
  } catch (error) {
    console.error('删除评查点失败:', error);
    return { 
      success: false, 
      error: error instanceof Error ? error.message : '删除评查点失败'
    };
  }
}