import type { DigraphAggregation, ComparisonResult, PerDigraphComparison } from './types';

const METRIC_KEYS = [
  'holdTime1',
  'holdTime2',
  'pressPress',
  'releaseRelease',
  'pressRelease',
  'releasePress',
] as const;

const MAX_METRIC_DISTANCE = 3.0;
const MIN_STD_FALLBACK = 15.0;

export function compareSession(
  sessionAggs: DigraphAggregation[],
  profileAggs: DigraphAggregation[],
): ComparisonResult {
  const profileMap = new Map<string, DigraphAggregation>();
  for (const a of profileAggs) {
    profileMap.set(a.normalizedKeys, a);
  }

  const perDigraph: PerDigraphComparison[] = [];
  let totalDistance = 0;
  let metricCount = 0;

  for (const sessionAgg of sessionAggs) {
    const profileAgg = profileMap.get(sessionAgg.normalizedKeys);
    if (!profileAgg) continue;

    let digraphDistance = 0;
    let digraphMetrics = 0;

    for (const key of METRIC_KEYS) {
      const sessionMean = sessionAgg[key].mean;
      const profileMean = profileAgg[key].mean;
      const profileStd = profileAgg[key].std;

      const divisor = Math.max(profileStd, MIN_STD_FALLBACK);
      const distance = Math.min(
        Math.abs(sessionMean - profileMean) / divisor,
        MAX_METRIC_DISTANCE,
      );

      digraphDistance += distance;
      digraphMetrics++;
    }

    const avgDistance = digraphMetrics > 0 ? digraphDistance / digraphMetrics : 0;
    const matchPercent = Math.max(0, Math.round(100 * (1 - avgDistance / 3.0)));

    perDigraph.push({
      normalizedKeys: sessionAgg.normalizedKeys,
      distance: Math.round(avgDistance * 100) / 100,
      matchPercent,
    });

    totalDistance += digraphDistance;
    metricCount += digraphMetrics;
  }

  const sharedCount = perDigraph.length;
  const overallDistance = metricCount > 0
    ? Math.round((totalDistance / metricCount) * 100) / 100
    : 0;
  const similarityPercent = Math.max(0, Math.round(100 * (1 - overallDistance / 3.0)));

  let confidence: ComparisonResult['confidence'];
  if (sharedCount >= 15) confidence = 'high';
  else if (sharedCount >= 10) confidence = 'medium';
  else if (sharedCount >= 5) confidence = 'low';
  else confidence = 'insufficient';

  // Sort by distance descending (worst matches first)
  perDigraph.sort((a, b) => b.distance - a.distance);

  return {
    overallDistance,
    similarityPercent,
    confidence,
    sharedCount,
    perDigraph,
  };
}