AI 评测结果双轮对比：稳定配对、语义差异与安全导出

type EvaluationResult = {
  id?: unknown;
  response?: unknown;
  trend?: unknown;
  currentData?: unknown;
  gateStatus?: unknown;
  gateReasons?: unknown;
  rating?: unknown;
  weightedScore?: unknown;
  explanation?: unknown;
  [key: string]: unknown;
};

type ResultGroup = Map<string, EvaluationResult[]>;

function groupByStableId(items: EvaluationResult[]) {
  const groups: ResultGroup = new Map();
  const missing: Array<{ index: number; item: EvaluationResult }> = [];

  items.forEach((item, index) => {
    const id = typeof item.id === 'string' ? item.id.trim() : '';
    if (!id) {
      missing.push({ index, item });
      return;
    }

    const group = groups.get(id) ?? [];
    group.push(item);
    groups.set(id, group);
  });

  return { groups, missing };
}

type FieldValue = { present: boolean; value: unknown };

function readField(record: EvaluationResult, key: keyof EvaluationResult): FieldValue {
  return {
    present: Object.hasOwn(record, key),
    value: record[key],
  };
}

function comparePresence(left: FieldValue, right: FieldValue) {
  if (left.present !== right.present) return 'changed';
  if (!left.present) return 'same';
  return 'compare-values';
}

type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };

function canonicalJson(value: JsonValue): string {
  if (value === null || typeof value !== 'object') {
    const encoded = JSON.stringify(value);
    if (encoded === undefined) throw new TypeError('值不是受支持的 JSON 数据');
    return encoded;
  }

  if (Array.isArray(value)) {
    return `[${value.map(canonicalJson).join(',')}]`;
  }

  const entries = Object.keys(value)
    .sort()
    .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`);
  return `{${entries.join(',')}}`;
}

function valuesEqual(left: unknown, right: unknown): boolean {
  if (Object.is(left, right)) return true;
  if (left === null || right === null) return false;
  if (typeof left !== 'object' || typeof right !== 'object') return false;

  try {
    return canonicalJson(left as JsonValue) === canonicalJson(right as JsonValue);
  } catch {
    return false;
  }
}

const comparisonFields = [
  'response',
  'trend',
  'currentData',
  'gateStatus',
  'gateReasons',
  'rating',
  'weightedScore',
  'explanation',
] as const;

type FieldDiff = {
  field: string;
  left: FieldValue;
  right: FieldValue;
  changed: boolean;
};

function compareMatched(left: EvaluationResult, right: EvaluationResult): FieldDiff[] {
  const extraFields = [...new Set([...Object.keys(left), ...Object.keys(right)])]
    .filter((field) => field !== 'id' && !comparisonFields.includes(field as (typeof comparisonFields)[number]))
    .sort();

  return [...comparisonFields, ...extraFields].map((field) => {
    const leftValue = readField(left, field);
    const rightValue = readField(right, field);
    const presence = comparePresence(leftValue, rightValue);
    const changed = presence === 'changed'
      || (presence === 'compare-values' && !valuesEqual(leftValue.value, rightValue.value));

    return { field, left: leftValue, right: rightValue, changed };
  });
}

type ComparisonRow = {
  status: 'matched' | 'left-only' | 'right-only' | 'ambiguous' | 'missing-id';
  id: string | null;
  left: EvaluationResult[];
  right: EvaluationResult[];
  diffs: FieldDiff[];
};

function toExportRows(rows: ComparisonRow[]) {
  return rows.map((row) => ({
    status: row.status,
    id: row.id,
    leftResults: row.left,
    rightResults: row.right,
    changedFields: row.diffs.filter((diff) => diff.changed).map((diff) => diff.field),
  }));
}

function safeExportFilename(label: string): string {
  const stem = label.trim()
    .replace(/\.xlsx$/i, '')
    .replace(/[\\/:*?"<>|\u0000-\u001f]/g, '-')
    .replace(/\s+/g, '-')
    .replace(/-+/g, '-')
    .replace(/^[.-]+|[.-]+$/g, '')
    .slice(0, 80);

  return `${stem || 'evaluation-comparison'}.xlsx`;
}