leaudit-platform-frontend/app/api/evaluation_points/reviews.ts

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

/**
 * 格式化日期
 * @param dateString 日期字符串
 * @returns 格式化后的日期字符串
 */
function formatDate(dateString: string): string {
    if (!dateString) return '';
    try {
      return dayjs(dateString).format('YYYY-MM-DD HH:mm:ss');
    } catch (error) {
      console.error('日期格式化失败:', error);
      return dateString;
    }
  }
  
/**
 * 从不同格式的 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;
}

// 定义评查结果类型
interface EvaluationResult {
  id: string | number;
  document_id: string | number;
  evaluation_point_id: string | number;
  evaluated_results?: {
    result?: boolean;
    message?: string;
    data?: string;
    [key: string]: unknown;
  };
  [key: string]: unknown;
}

// 定义评查点类型
interface EvaluationPoint {
  id: string | number;
  evaluation_point_groups_id: string | number;
  suggestion_message_type?: string;
  suggestion_message?: string;
  score?: number;
  [key: string]: unknown;
}

// 定义评查点组类型
interface EvaluationPointGroup {
  id: string | number;
  name?: string;
  [key: string]: unknown;
}

// 定义前端使用的评查点结果类型
interface ReviewPointResult {
  id: string | number;
  title: string;
  groupName: string;
  status: string;
  content: string;
  suggestion: string;
  result?: boolean;
  score: number;
}

// 定义统计数据类型
interface StatsData {
  total: number;
  success: number;
  warning: number;
  error: number;
  score: number;
}

/**
 * 获取当前评查文件的所有评查点结果
 * @param fileId 评查文件ID
 * @returns 评查点结果列表和统计数据
 */
export async function getReviewPoints(fileId: string) {
    // 步骤1：根据fileId查询evaluation_results表
    const evaluationResultsParams: PostgrestParams = {
        select: '*',
        filter: {
            'document_id': `eq.${fileId}`
        }
    };
    const evaluationResultsResponse = await postgrestGet('evaluation_results', evaluationResultsParams);

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

    const evaluationResultsData = extractApiData<EvaluationResult[]>(evaluationResultsResponse.data);
    
    if (!evaluationResultsData || !Array.isArray(evaluationResultsData)) {
        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
    }

    // 收集所有评查点ID，用于查询评查点详情
    const evaluationPointIds = evaluationResultsData.map(item => item.evaluation_point_id).filter(Boolean);
    
    if (evaluationPointIds.length === 0) {
        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
    }

    // 步骤2：根据evaluation_point_id查询evaluation_points表
    const evaluationPointsParams: PostgrestParams = {
        select: '*',
        filter: {
            'id': `in.(${evaluationPointIds.join(',')})`
        }
    };
    const evaluationPointsResponse = await postgrestGet('evaluation_points', evaluationPointsParams);

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

    const evaluationPointsData = extractApiData<EvaluationPoint[]>(evaluationPointsResponse.data);
    
    if (!evaluationPointsData || !Array.isArray(evaluationPointsData)) {
        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
    }

    // 收集所有评查点组ID，用于查询评查点组详情
    const groupIds = evaluationPointsData.map(item => item.evaluation_point_groups_id).filter(Boolean);

    if (groupIds.length === 0) {
        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
    }

    // 查询评查点组
    const groupsParams: PostgrestParams = {
        select: '*',
        filter: {
            'id': `in.(${groupIds.join(',')})`
        }
    };
    const groupsResponse = await postgrestGet('evaluation_point_groups', groupsParams);

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

    const groupsData = extractApiData<EvaluationPointGroup[]>(groupsResponse.data);
    
    if (!groupsData || !Array.isArray(groupsData)) {
        return { data: [], stats: { total: 0, success: 0, warning: 0, error: 0, score: 0 } };
    }

    // 创建映射关系以便快速查找
    const pointsMap = new Map<string | number, EvaluationPoint>();
    evaluationPointsData.forEach(point => {
        pointsMap.set(point.id, point);
    });

    // console.log('pointsMap-------', pointsMap);

    const groupsMap = new Map<string | number, EvaluationPointGroup>();
    groupsData.forEach(group => {
        groupsMap.set(group.id, group);
    });

    // console.log('groupsMap-------', groupsMap);

    // 构建前端所需的数据格式
    const resultData: ReviewPointResult[] = evaluationResultsData.map(result => {
        const point = pointsMap.get(result.evaluation_point_id) || {} as EvaluationPoint;
        const group = groupsMap.get(point.evaluation_point_groups_id || 0) || {} as EvaluationPointGroup;
        
        // 从 evaluated_results 中提取数据
        let message = '';
        let data = '';
        
        if (result.evaluated_results && typeof result.evaluated_results === 'object') {
            message = result.evaluated_results.message || '';
            data = result.evaluated_results.data || '';
        }

        return {
            id: result.id,
            title: message,
            groupName: group.name || '',
            status: point.suggestion_message_type || '',
            content: data,
            suggestion: point.suggestion_message || '',
            result: result.evaluated_results?.result, // 记录评查结果，用于统计
            score: point.score || 0
        };
    });

    // 统计数据
    const stats: StatsData = {
        total: evaluationResultsData.length,
        success: 0,
        warning: 0,
        error: 0,
        score: 0
    };

    // 计算统计数据
    resultData.forEach(item => {
        // 成功数量统计
        if (item.result === true) {
            stats.success += 1;
        } else if (item.result === false) {
            // 警告和错误数量统计
            if (item.status === 'warning') {
                stats.warning += 1;
            } else if (item.status === 'error') {
                stats.error += 1;
            }
        }
        
        // 分数统计
        stats.score += item.score || 0;
    });

    return { data: resultData, stats };
}