import type { Profile, DigraphAggregation, MetricStats } from './src/lib/types';

const METRIC_KEYS = [

  'holdTime1',

  'holdTime2',

  'pressPress',

  'releaseRelease',

  'pressRelease',

  'releasePress',

] as const;

const MAX_METRIC_DISTANCE = 3.0;

const MIN_STD_FALLBACK = 15.0;

function filterOutliers(values: number[], k = 1.5): number[] {

  if (values.length < 4) return values;

  const sorted = [...values].sort((a, b) => a - b);

  const q1 = sorted[Math.floor(sorted.length * 0.25)];

  const q3 = sorted[Math.floor(sorted.length * 0.75)];

  const iqr = q3 - q1;

  const lower = q1 - k * iqr;

  const upper = q3 + k * iqr;

  return values.filter((v) => v >= lower && v <= upper);

}

function computeMetricStats(values: number[]): MetricStats {

  if (values.length === 0) return { mean: 0, std: 0, min: 0, max: 0, count: 0 };

  const count = values.length;

  const mean = values.reduce((s, v) => s + v, 0) / count;

  const variance = count < 2 ? 0 : values.reduce((s, v) => s + (v - mean) ** 2, 0) / (count - 1);

  return {

    mean: Math.round(mean * 10) / 10,

    std: Math.round(Math.sqrt(variance) * 10) / 10,

    min: Math.round(Math.min(...values) * 10) / 10,

    max: Math.round(Math.max(...values) * 10) / 10,

    count,

  };

}

// Re-aggregate a profile's raw aggregations with outlier filtering

// Since we only have pre-aggregated data (no raw samples), we'll just use them as-is

// But demonstrate what the new comparison logic does

const profile1: Profile = await Bun.file('1.json').json();

const profile2: Profile = await Bun.file('2.json').json();

console.log('=== PROFILE OVERVIEW ===');

console.log(`Profile 1: "${profile1.name}" — ${profile1.aggregations.length} digraph types`);

console.log(`Profile 2: "${profile2.name}" — ${profile2.aggregations.length} digraph types`);

const map1 = new Map<string, DigraphAggregation>();

for (const a of profile1.aggregations) map1.set(a.normalizedKeys, a);

const map2 = new Map<string, DigraphAggregation>();

for (const a of profile2.aggregations) map2.set(a.normalizedKeys, a);

const sharedKeys = [...map1.keys()].filter(k => map2.has(k));

console.log(`Shared digraph types: ${sharedKeys.length}\n`);

// OLD algorithm

let oldTotal = 0, oldMetrics = 0;

for (const key of sharedKeys) {

  const a1 = map1.get(key)!, a2 = map2.get(key)!;

  for (const metric of METRIC_KEYS) {

    const s = a1[metric] as MetricStats, p = a2[metric] as MetricStats;

    let dist: number;

    if (p.std < 0.001) {

      dist = Math.abs(s.mean - p.mean) / Math.max(Math.abs(p.mean) * 0.1, 1.0);

    } else {

      dist = Math.abs(s.mean - p.mean) / p.std;

    }

    oldTotal += dist; oldMetrics++;

  }

}

const oldOverall = oldMetrics > 0 ? oldTotal / oldMetrics : 0;

const oldSim = Math.max(0, Math.round(100 * (1 - oldOverall / 3.0)));

// NEW algorithm (capped distance, better fallback)

let newTotal = 0, newMetrics = 0;

const perDigraph: { keys: string; avgDist: number; details: string[] }[] = [];

for (const key of sharedKeys) {

  const a1 = map1.get(key)!, a2 = map2.get(key)!;

  let digDist = 0, digMetrics = 0;

  const details: string[] = [];

  for (const metric of METRIC_KEYS) {

    const s = a1[metric] as MetricStats, p = a2[metric] as MetricStats;

    const divisor = Math.max(p.std, MIN_STD_FALLBACK);

    const dist = Math.min(Math.abs(s.mean - p.mean) / divisor, MAX_METRIC_DISTANCE);

    details.push(`  ${metric.padEnd(16)} s=${String(s.mean).padStart(8)} p=${String(p.mean).padStart(8)} div=${divisor.toFixed(1).padStart(6)} → ${dist.toFixed(2)}${dist >= MAX_METRIC_DISTANCE ? ' (capped)' : ''}`);

    digDist += dist; digMetrics++;

  }

  const avg = digMetrics > 0 ? digDist / digMetrics : 0;

  newTotal += digDist; newMetrics++;

  perDigraph.push({ keys: key, avgDist: avg, details });

}

const newOverall = newMetrics > 0 ? newTotal / (newMetrics * METRIC_KEYS.length) : 0;

const newSim = Math.max(0, Math.round(100 * (1 - newOverall / 3.0)));

console.log('=== COMPARISON ===');

console.log(`OLD: distance=${oldOverall.toFixed(2)}, similarity=${oldSim}%`);

console.log(`NEW: distance=${newOverall.toFixed(2)}, similarity=${newSim}%`);

perDigraph.sort((a, b) => b.avgDist - a.avgDist);

console.log('\nTop 10 worst (new algorithm):');

for (const d of perDigraph.slice(0, 10)) {

  const pct = Math.max(0, Math.round(100 * (1 - d.avgDist / 3.0)));

  console.log(`\n${d.keys}  — dist: ${d.avgDist.toFixed(2)}, match: ${pct}%`);

  for (const line of d.details) console.log(line);

}

console.log('\n\nTop 5 best (new algorithm):');

for (const d of perDigraph.slice(-5).reverse()) {

  const pct = Math.max(0, Math.round(100 * (1 - d.avgDist / 3.0)));

  console.log(`${d.keys}  — dist: ${d.avgDist.toFixed(2)}, match: ${pct}%`);

}

import { std, filterOutliers } from './utils';

      holdTime1: computeMetricStats(filterOutliers(group.map((d) => d.holdTime1))),

      holdTime2: computeMetricStats(filterOutliers(group.map((d) => d.holdTime2))),

      pressPress: computeMetricStats(filterOutliers(group.map((d) => d.pressPress))),

      releaseRelease: computeMetricStats(filterOutliers(group.map((d) => d.releaseRelease))),

      pressRelease: computeMetricStats(filterOutliers(group.map((d) => d.pressRelease))),

      releasePress: computeMetricStats(filterOutliers(group.map((d) => d.releasePress))),

const MAX_METRIC_DISTANCE = 3.0;

const MIN_STD_FALLBACK = 15.0;

      const divisor = Math.max(profileStd, MIN_STD_FALLBACK);

      const distance = Math.min(

        Math.abs(sessionMean - profileMean) / divisor,

        MAX_METRIC_DISTANCE,

      );

/** Remove outliers using the IQR method, returns filtered array */

export function filterOutliers(values: number[], k = 1.5): number[] {

  if (values.length < 4) return values;

  const sorted = [...values].sort((a, b) => a - b);

  const q1 = sorted[Math.floor(sorted.length * 0.25)];

  const q3 = sorted[Math.floor(sorted.length * 0.75)];

  const iqr = q3 - q1;

  const lower = q1 - k * iqr;

  const upper = q3 + k * iqr;

  return values.filter((v) => v >= lower && v <= upper);

}