export const DEFAULT_PROFILE = 'cpp';

const PROFILE_LABELS = {
  cpp: 'C++ · latest published result per dataset and method',
  java: 'Java · imported published results',
  python: 'Python · imported published results',
};

const FINITE = value => typeof value === 'number' && Number.isFinite(value);
const METRIC_AVAILABLE = (row,key) => key==='rank_coverage'?FINITE(row?.[key])&&row[key]>0:FINITE(row?.[key]);
const STRICT_COMPLETE_COLUMNS = new Set(['compression_time','decompression_time','normalized_compression_time','normalized_decompression_time','composite_score']);
const sourceRows = row => Array.isArray(row?.source) ? row.source : [];
const timingAdmitted = record => /^timing_admitted_/i.test(String(record?.timing_profile_status ?? ''));

export function profileLabel(profile, fallback = profile) {
  return PROFILE_LABELS[profile] || fallback;
}

export function isByteOnlyProfile(profile) {
  return false;
}

export function defaultColumnVisible(profile, column) {
  return Boolean(column.defaultVisible);
}

export function timingAvailability(row) {
  const source = sourceRows(row),evidence=source.length?source:[row];
  if (evidence.some(record => !timingAdmitted(record))) {
    return {
      code: 'timing_not_admitted',
      short: 'Timing not admitted',
      detail: 'Timing exists only as diagnostic or unqualified evidence for at least one selected dataset and is excluded from timing and composite rankings.',
    };
  }
  if (!FINITE(row?.compression_time) || !FINITE(row?.decompression_time)) {
    return {
      code: 'incomplete_timing',
      short: 'Incomplete timing',
      detail: 'At least one selected dataset lacks a complete admitted compression/decompression timing pair.',
    };
  }
  return {code: 'available', short: 'Available', detail: 'All selected timing inputs are admitted.'};
}

export function metricAvailability(row, key) {
  if (FINITE(row?.[key])) return {code: 'available', short: '', detail: ''};
  if (['compression_time_timed_subset', 'decompression_time_timed_subset'].includes(key)) {
    const status=row?.timing_subset_status;
    if(status==='no_admitted_timing')return {code:status,short:'No admitted timing',detail:'None of the current winning rate records has admitted timing.'};
    if(status==='mixed_timing_contracts')return {code:status,short:'Mixed timing contracts',detail:'Admitted timing comes from different source profiles, hosts, or timing contracts and is not averaged.'};
    if(status==='unbound_timing_source')return {code:status,short:'Timing source unbound',detail:'Source profile, host, and timing contract are not all bound, so subset timing is withheld.'};
    if(status==='mixed_timing_aggregation')return {code:status,short:'Mixed timing basis',detail:'Column-level and dataset-level timing aggregation cannot be mixed.'};
    return {code:'incomplete_timing',short:'Incomplete timing',detail:'A valid timed subset is unavailable.'};
  }
  if (['compression_time', 'decompression_time'].includes(key)) return timingAvailability(row);
  if (['normalized_compression_time', 'normalized_decompression_time', 'composite_score'].includes(key)) {
    const timing = timingAvailability(row);
    if (timing.code !== 'available') return timing;
    if (Number(row?.workload_signature_count) > 1) return {
      code: 'support_mismatch',
      short: 'Support mismatch',
      detail: `Composite metrics are withheld because this view contains ${Number(row.workload_signature_count).toLocaleString('en-US')} distinct dataset/support signatures.`,
    };
    return {code: 'not_eligible', short: 'Not eligible', detail: 'No eligible normalization cohort is available for this row.'};
  }
  if (key === 'average_rank') {
    const timing = timingAvailability(row);
    if (timing.code !== 'available') return timing;
    return {code: 'support_mismatch', short: 'Support mismatch', detail: 'No matched dataset/support cohort provides a rank for this row.'};
  }
  if (['overall_rate', 'compressed_bytes', 'original_bytes'].includes(key)) return {
    code: 'incomplete_bytes', short: 'Incomplete bytes', detail: 'Complete compressed/original byte totals are unavailable for the selected records.',
  };
  return {code: 'unavailable', short: 'Unavailable', detail: 'This metric is unavailable for the selected records.'};
}

export function summarizeAvailability(rows, requestedColumns) {
  const total = rows.length;
  const counts = Object.fromEntries(requestedColumns.map(column => [column.key, rows.filter(row => METRIC_AVAILABLE(row,column.key)).length]));
  const hidden = requestedColumns.filter(column => (counts[column.key] || 0) === 0);
  const timingNotAdmitted = rows.filter(row => timingAvailability(row).code === 'timing_not_admitted').length;
  const incompleteTiming = rows.filter(row => timingAvailability(row).code === 'incomplete_timing').length;
  const supportMismatch = rows.filter(row =>
    !FINITE(row?.composite_score) && timingAvailability(row).code === 'available' && Number(row?.workload_signature_count) > 1
  ).length;
  const noComparableCohort = rows.filter(row =>
    !FINITE(row?.composite_score) && timingAvailability(row).code === 'available' && Number(row?.workload_signature_count) <= 1 && Number(row?.normalization_reference_rows) < 2
  ).length;
  const parts = [
    `${counts.compression_rate || 0}/${total} rates`,
    `${counts.compression_time || 0}/${total} admitted timings`,
    `${counts.average_rank || 0}/${total} matched-support ranks`,
    `${counts.composite_score || 0}/${total} composite scores`,
  ];
  const reasons = [];
  if (timingNotAdmitted) reasons.push(`${timingNotAdmitted} timing not admitted`);
  if (incompleteTiming) reasons.push(`${incompleteTiming} incomplete timing`);
  if (supportMismatch) {
    const signatures = Math.max(0, ...rows.map(row => Number(row?.workload_signature_count) || 0));
    reasons.push(`${supportMismatch} composite scores withheld across ${signatures} dataset/support signatures`);
  }
  if(noComparableCohort)reasons.push(`${noComparableCohort} lack a comparable normalization cohort`);
  return {total, counts, hidden, timingNotAdmitted, incompleteTiming, supportMismatch, noComparableCohort, parts, reasons};
}

export function visibleColumns(columns, rows, profile, showUnavailable, touched = new Set()) {
  const requested = columns.filter(column => touched.has(column.key) ? column.visible : defaultColumnVisible(profile, column));
  if (showUnavailable) return columns.filter(column => touched.has(column.key) ? column.visible : Boolean(column.defaultVisible));
  return requested.filter(column => STRICT_COMPLETE_COLUMNS.has(column.key)?rows.length>0&&rows.every(row=>METRIC_AVAILABLE(row,column.key)):rows.some(row => METRIC_AVAILABLE(row,column.key)));
}

export function profileScopeText({profile, measuredDatasets, catalogDatasets}) {
  const prefix = `${profileLabel(profile)} · ${measuredDatasets} measured datasets in this profile / ${catalogDatasets} catalog datasets.`;
  if (profile === DEFAULT_PROFILE) return `${prefix} Duplicate C++ dataset/method pairs use the latest receipt-bound authority. Source profile and host remain visible in details and CSV. Strict timing and scores require complete same-contract coverage; partial admitted timing is labeled as a timed subset.`;
  return `${prefix} These imported published results retain their original evidence boundaries; unqualified timing is not promoted into rankings.`;
}

export function timingSourceIdentity(record) {
  const profile = record?.source_comparison_profile ?? record?.comparison_profile ?? record?.runtime ?? '';
  const host = record?.source_execution_host ?? record?.execution_host ?? '';
  const contract = record?.timing_contract ?? record?.timing_profile_status ?? '';
  return `${profile}\u0000${host}\u0000${contract}`;
}

export function aggregateTimedSubset(source) {
  const denominator = new Set(sourceRows({source}).map(record => record.dataset)).size;
  const admitted = sourceRows({source}).filter(record =>
    timingAdmitted(record) && FINITE(record?.compression_time) && FINITE(record?.decompression_time) &&
    Number(record.compression_time) >= 0 && Number(record.decompression_time) >= 0
  );
  const boundIdentity = record => {
    const profile=record?.source_comparison_profile ?? record?.comparison_profile ?? record?.runtime ?? '';
    const host=record?.source_execution_host ?? record?.execution_host ?? '';
    const contract=record?.timing_contract ?? record?.timing_profile_status ?? '';
    return profile && host && contract;
  };
  const identities = [...new Set(admitted.map(timingSourceIdentity))];
  const base = {
    timing_subset_coverage: new Set(admitted.map(record => record.dataset)).size,
    timing_subset_denominator: denominator,
    timing_subset_source_identity: identities.length === 1 ? identities[0] : '',
    timing_subset_source_profiles: [...new Set(admitted.map(record => record.source_comparison_profile ?? record.comparison_profile ?? record.runtime ?? ''))].filter(Boolean),
    timing_subset_hosts: [...new Set(admitted.map(record => record.source_execution_host ?? record.execution_host ?? ''))].filter(Boolean),
  };
  if (!admitted.length) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'no_admitted_timing'};
  if (!admitted.every(boundIdentity)) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'unbound_timing_source'};
  if (identities.length !== 1) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'mixed_timing_contracts'};
  const completeColumnTiming = admitted.every(record => record.timing_aggregation === 'column_mean' && Number.isInteger(record.timing_column_count) && record.timing_column_count > 0);
  const completeDatasetTiming = admitted.every(record => record.timing_aggregation === 'dataset_aggregate' && record.timing_column_count === 0);
  if (!completeColumnTiming && !completeDatasetTiming) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'mixed_timing_aggregation'};
  const aggregate = key => completeColumnTiming
    ? admitted.reduce((sum,record) => sum + Number(record[key]) * record.timing_column_count, 0) / admitted.reduce((sum,record) => sum + record.timing_column_count, 0)
    : admitted.reduce((sum,record) => sum + Number(record[key]), 0) / admitted.length;
  return {
    ...base,
    compression_time_timed_subset:aggregate('compression_time'),
    decompression_time_timed_subset:aggregate('decompression_time'),
    timing_subset_status:completeColumnTiming?'column_mean':'dataset_mean',
  };
}

export function strictTimingMode(source) {
  const rows=sourceRows({source});
  if(!rows.length||rows.some(record=>!timingAdmitted(record)||!FINITE(record?.compression_time)||!FINITE(record?.decompression_time)))return 'unavailable';
  const subset=aggregateTimedSubset(rows),datasetCount=new Set(rows.map(record=>record.dataset)).size;
  if(subset.timing_subset_coverage!==datasetCount)return 'unavailable';
  return ['column_mean','dataset_mean'].includes(subset.timing_subset_status)?subset.timing_subset_status:'unavailable';
}