// Ranking references include all measured methods in the selected runtime,
// scope and row mode. Search, family and coverage filters only hide rows.
export const WEIGHT_TENTHS = [];
for (let a=0;a<=10;a++) for (let b=0;b<=10-a;b++) WEIGHT_TENTHS.push([a,b,10-a-b]);

export function parseWeights(value) {
  const tokens=String(value).split(','),parts=tokens.map(Number);
  if(parts.length!==3||tokens.some(t=>t.trim()==='')||parts.some(n=>!Number.isInteger(n)||n<0)||parts.reduce((s,n)=>s+n,0)!==10) throw new Error('Weights must be non-negative tenths summing to 1.0.');
  return parts.map(n=>n/10);
}

const finite=v=>v!==null&&v!==undefined&&Number.isFinite(v);
const timingAdmitted=r=>Array.isArray(r.source)?r.source.every(timingAdmitted):/^timing_admitted_/i.test(String(r.timing_profile_status??''));
const valid=r=>finite(r.compression_rate)&&r.compression_rate>0&&finite(r.compression_time)&&r.compression_time>=0&&finite(r.decompression_time)&&r.decompression_time>=0&&timingAdmitted(r);
const average=values=>values.length?values.reduce((s,v)=>s+v,0)/values.length:null;

function bounds(rows,key) {
  const values=rows.map(r=>r[key]).filter(finite);
  return values.length?[Math.min(...values),Math.max(...values)]:null;
}

export function minMax(value,range) {
  if(!finite(value)||!range)return null;
  return range[0]===range[1]?0:(value-range[0])/(range[1]-range[0]);
}

function score(row,weights,encodeRange,decodeRange) {
  const encode=minMax(row.compression_time,encodeRange),decode=minMax(row.decompression_time,decodeRange);
  return {normalized_compression_time:encode,normalized_decompression_time:decode,composite_score:valid(row)&&encode!==null&&decode!==null?weights[0]*row.compression_rate+weights[1]*encode+weights[2]*decode:null};
}

function provisionalCompositeInputs(row) {
  return {
    compression_rate:row.compression_rate,
    compression_time:finite(row.compression_time)?row.compression_time:row.compression_time_timed_subset,
    decompression_time:finite(row.decompression_time)?row.decompression_time:row.decompression_time_timed_subset,
  };
}

function provisionalEligible(row,weights) {
  const input=provisionalCompositeInputs(row);
  return (weights[0]===0||(finite(input.compression_rate)&&input.compression_rate>0)) &&
    (weights[1]===0||(finite(input.compression_time)&&input.compression_time>=0)) &&
    (weights[2]===0||(finite(input.decompression_time)&&input.decompression_time>=0));
}

function provisionalScore(row,weights,encodeRange,decodeRange) {
  const input=provisionalCompositeInputs(row);
  const encode=weights[1]===0?null:minMax(input.compression_time,encodeRange);
  const decode=weights[2]===0?null:minMax(input.decompression_time,decodeRange);
  if(!provisionalEligible(row,weights)||(weights[1]>0&&encode===null)||(weights[2]>0&&decode===null))return {normalized_compression_time:encode,normalized_decompression_time:decode,composite_score:null};
  return {
    normalized_compression_time:encode,
    normalized_decompression_time:decode,
    composite_score:weights[0]*(finite(input.compression_rate)?input.compression_rate:0)+weights[1]*(encode??0)+weights[2]*(decode??0),
  };
}

export function addRankingMetrics(rows,weights,options={}) {
  if(weights.length!==3||weights.some(w=>!finite(w)||w<0)||Math.abs(weights.reduce((s,w)=>s+w,0)-1)>1e-12)throw new Error('Invalid scoring weights.');
  const provisionalCurrentTiming=options.provisionalCurrentTiming===true;
  const strictCandidates=rows.filter(r=>valid(r)&&r.source.every(valid));
  const workloadSignature=row=>row.source.map(r=>`${r.dataset}:${r.eligible_column_set_sha256??'legacy_snapshot_unbound'}`).sort().join('|');
  const workloadSignatures=new Set(strictCandidates.map(workloadSignature));
  const globallyComparable=workloadSignatures.size<=1;
  const provisionalCandidates=provisionalCurrentTiming?rows.filter(row=>provisionalEligible(row,weights)):[];
  const candidates=provisionalCurrentTiming?provisionalCandidates:strictCandidates;
  const provisionalInputs=provisionalCandidates.map(row=>provisionalCompositeInputs(row));
  const encodeRange=provisionalCurrentTiming?(weights[1]>0?bounds(provisionalInputs,'compression_time'):null):(globallyComparable?bounds(strictCandidates,'compression_time'):null);
  const decodeRange=provisionalCurrentTiming?(weights[2]>0?bounds(provisionalInputs,'decompression_time'):null):(globallyComparable?bounds(strictCandidates,'decompression_time'):null);
  const byDataset=new Map(),ranks=new Map(),details=new Map();
  for(const row of rows) {
    ranks.set(row.method,[]);
    for(const record of row.source.filter(valid)) {
      const cohort=`${record.dataset}\0${record.eligible_column_set_sha256??'legacy_snapshot_unbound'}`;
      if(!byDataset.has(cohort))byDataset.set(cohort,[]);
      byDataset.get(cohort).push({...record,method:row.method});
    }
  }
  for(const records of byDataset.values()) {
    const encode=bounds(records,'compression_time'),decode=bounds(records,'decompression_time');
    const ordered=records.map(r=>({...r,...score(r,weights,encode,decode)})).sort((a,b)=>a.composite_score-b.composite_score||a.method.localeCompare(b.method));
    for(let start=0;start<ordered.length;) {
      let end=start+1;
      while(end<ordered.length&&ordered[end].composite_score===ordered[start].composite_score)end++;
      const rank=(start+1+end)/2;
      for(let i=start;i<end;i++) {
        ranks.get(ordered[i].method).push(rank);
        details.set(`${ordered[i].method}\0${ordered[i].dataset}\0${ordered[i].eligible_column_set_sha256??'legacy_snapshot_unbound'}`,{dataset_score:ordered[i].composite_score,dataset_rank:rank,dataset_candidate_count:ordered.length});
      }
      start=end;
    }
  }
  // The explicitly selected methods use the published full method pool.
  // Their source support identities and every other method's ranks stay intact.
  const fullPoolMethods=new Set(options.fullPoolRankMethods??[]);
  const fullPoolRanks=new Map(),fullPoolDetails=new Map();
  for(const row of rows)if(fullPoolMethods.has(row.method))fullPoolRanks.set(row.method,[]);
  if(fullPoolRanks.size) {
    const allDatasets=new Map();
    for(const row of rows)for(const record of row.source.filter(valid)) {
      if(!allDatasets.has(record.dataset))allDatasets.set(record.dataset,[]);
      allDatasets.get(record.dataset).push({...record,method:row.method});
    }
    for(const records of allDatasets.values()) {
      const encode=bounds(records,'compression_time'),decode=bounds(records,'decompression_time');
      const ordered=records.map(r=>({...r,...score(r,weights,encode,decode)})).sort((a,b)=>a.composite_score-b.composite_score||a.method.localeCompare(b.method));
      for(let start=0;start<ordered.length;) {
        let end=start+1;
        while(end<ordered.length&&ordered[end].composite_score===ordered[start].composite_score)end++;
        const rank=(start+1+end)/2;
        for(let i=start;i<end;i++)if(fullPoolRanks.has(ordered[i].method)) {
          fullPoolRanks.get(ordered[i].method).push(rank);
          fullPoolDetails.set(`${ordered[i].method}\0${ordered[i].dataset}`,{dataset_score:ordered[i].composite_score,dataset_rank:rank,dataset_candidate_count:ordered.length});
        }
        start=end;
      }
    }
  }
  return rows.map(row=>{
    const fullPool=fullPoolRanks.has(row.method),rowRanks=fullPool?fullPoolRanks.get(row.method):ranks.get(row.method);
    const eligible=candidates.includes(row)&&(provisionalCurrentTiming||globallyComparable);
    const scored=eligible?(provisionalCurrentTiming?provisionalScore(row,weights,encodeRange,decodeRange):score(row,weights,encodeRange,decodeRange)):{normalized_compression_time:null,normalized_decompression_time:null,composite_score:null};
    return {...row,...scored,
      composite_score_status:provisionalCurrentTiming?(scored.composite_score===null?'provisional_unavailable':'provisional_current_admitted_timing'):(scored.composite_score===null?'strict_unavailable':'strict_exact_support'),
      composite_rate_coverage:row.coverage,
      composite_timing_coverage:row.timing_subset_coverage,
      composite_timing_denominator:row.timing_subset_denominator,
      composite_metric_basis:provisionalCurrentTiming?'all-current-rate-datasets plus current-admitted-timing-subset':'strict-complete-exact-support',
      average_rank:average(rowRanks),rank_coverage:rowRanks.length,
      ...(fullPool?{rank_reference:'all-published-methods-in-selected-scope',rank_reference_method_count:rows.length}:{}),
      normalization_reference_rows:provisionalCurrentTiming?candidates.length:(globallyComparable?strictCandidates.length:0),workload_signature_count:workloadSignatures.size,
      encode_min:encodeRange?.[0]??null,encode_max:encodeRange?.[1]??null,decode_min:decodeRange?.[0]??null,decode_max:decodeRange?.[1]??null,
      source:row.source.map(r=>({...r,...(fullPool?fullPoolDetails.get(`${row.method}\0${r.dataset}`):details.get(`${row.method}\0${r.dataset}\0${r.eligible_column_set_sha256??'legacy_snapshot_unbound'}`))}))};
  });
}