import type { RawDigraph, SessionMetadata, HumannessResult } from './types';
import { aggregateDigraphs } from './aggregation';

function clamp(value: number, min = 0, max = 100): number {
  return Math.max(min, Math.min(max, value));
}

/**
 * Timing Variance (weight 0.20)
 * Measures coefficient of variation (std/mean) of pressPress per digraph.
 * Humans typically have CV > 0.15, bots < 0.05.
 */
function scoreTimingVariance(digraphs: RawDigraph[]): number {
  const aggs = aggregateDigraphs(digraphs);
  if (aggs.length === 0) return 0;

  const cvs: number[] = [];
  for (const agg of aggs) {
    if (agg.pressPress.mean > 0 && agg.count >= 2) {
      cvs.push(agg.pressPress.std / agg.pressPress.mean);
    }
  }

  if (cvs.length === 0) return 0;

  const avgCv = cvs.reduce((s, v) => s + v, 0) / cvs.length;

  // CV < 0.03 → 0, CV >= 0.20 → 100
  if (avgCv >= 0.20) return 100;
  if (avgCv <= 0.03) return 0;
  return clamp(Math.round((avgCv - 0.03) / (0.20 - 0.03) * 100));
}

/**
 * Correction Rate (weight 0.15)
 * Ratio of backspaces to total keystrokes.
 * Humans typically 5-15%, zero is suspicious.
 */
function scoreCorrectionRate(metadata: SessionMetadata): number {
  if (metadata.totalKeystrokes === 0) return 0;

  const rate = metadata.backspaceCount / metadata.totalKeystrokes;

  // 0% → suspicious (score 10), 5-15% → ideal (100), >25% → decreasing
  if (rate === 0) return 10;
  if (rate < 0.02) return clamp(Math.round(10 + (rate / 0.02) * 40));
  if (rate <= 0.15) return 100;
  if (rate <= 0.30) return clamp(Math.round(100 - ((rate - 0.15) / 0.15) * 50));
  return 50;
}

/**
 * Pause Distribution (weight 0.20)
 * Presence and frequency of natural thinking pauses (> 500ms gaps).
 * Humans have pauses for thinking; bots type continuously.
 */
function scorePauseDistribution(metadata: SessionMetadata, digraphs: RawDigraph[]): number {
  if (digraphs.length === 0) return 0;

  const pauseRate = metadata.pauseCount / digraphs.length;

  // Collect pressPress values to check variance of pause-length gaps
  const longGaps = digraphs
    .map((d) => d.pressPress)
    .filter((pp) => pp > 500);

  const hasVariedPauses = longGaps.length >= 2
    ? computeStd(longGaps) / (longGaps.reduce((s, v) => s + v, 0) / longGaps.length) > 0.2
    : false;

  // No pauses at all → suspicious
  if (metadata.pauseCount === 0) return 5;

  let score = 0;

  // Pause rate: ideal is 0.03-0.15 pauses per digraph
  if (pauseRate >= 0.03 && pauseRate <= 0.15) {
    score = 80;
  } else if (pauseRate < 0.03) {
    score = clamp(Math.round(20 + (pauseRate / 0.03) * 60));
  } else {
    score = clamp(Math.round(80 - ((pauseRate - 0.15) / 0.30) * 30));
  }

  // Bonus for varied pause lengths (natural thinking)
  if (hasVariedPauses) score = clamp(score + 20);

  return score;
}

/**
 * Distribution Shape (weight 0.15)
 * Measures skewness of timing arrays.
 * Human typing is right-skewed (log-normal distribution).
 */
function scoreDistributionShape(digraphs: RawDigraph[]): number {
  const ppValues = digraphs.map((d) => d.pressPress);
  if (ppValues.length < 10) return 50; // not enough data

  const mean = ppValues.reduce((s, v) => s + v, 0) / ppValues.length;
  const std = computeStd(ppValues);
  if (std === 0) return 0;

  // Compute skewness: E[(X - mean)^3] / std^3
  const n = ppValues.length;
  const skewness =
    (n / ((n - 1) * (n - 2))) *
    ppValues.reduce((s, v) => s + Math.pow((v - mean) / std, 3), 0);

  // Human typing is right-skewed (positive skewness, typically 0.5-3.0)
  // Bot typing tends toward 0 skewness (symmetric) or negative
  if (skewness <= 0) return clamp(Math.round(20 + skewness * 10));
  if (skewness >= 0.5 && skewness <= 3.0) return 100;
  if (skewness < 0.5) return clamp(Math.round(20 + (skewness / 0.5) * 80));
  // Very high skewness (> 3.0) still human-like but slightly less certain
  return clamp(Math.round(100 - ((skewness - 3.0) / 5.0) * 20));
}

/**
 * Flight Time Negativity (weight 0.15)
 * Percentage of digraphs with releasePress < 0 (key overlap).
 * Humans overlap keys while typing; bots release before pressing next.
 */
function scoreFlightTimeNegativity(digraphs: RawDigraph[]): number {
  if (digraphs.length === 0) return 0;

  const negativeCount = digraphs.filter((d) => d.releasePress < 0).length;
  const negativeRate = negativeCount / digraphs.length;

  // Humans typically have 10-40% negative flight times
  // 0% → very suspicious, 10-40% → ideal
  if (negativeRate === 0) return 5;
  if (negativeRate < 0.05) return clamp(Math.round(5 + (negativeRate / 0.05) * 40));
  if (negativeRate >= 0.10 && negativeRate <= 0.50) return 100;
  if (negativeRate < 0.10) return clamp(Math.round(45 + ((negativeRate - 0.05) / 0.05) * 55));
  // Very high overlap might just be fast typing
  return clamp(Math.round(100 - ((negativeRate - 0.50) / 0.30) * 30));
}

/**
 * Burst Patterns (weight 0.15)
 * Variance of "burst" lengths (consecutive digraphs with < 300ms gap).
 * Humans type in bursts of 3-15 keys with pauses between.
 */
function scoreBurstPatterns(digraphs: RawDigraph[]): number {
  if (digraphs.length < 5) return 50;

  // Digraphs are stored newest-first, reverse for chronological order
  const chronological = [...digraphs].reverse();

  const bursts: number[] = [];
  let currentBurst = 1;

  for (let i = 1; i < chronological.length; i++) {
    if (chronological[i].pressPress < 300) {
      currentBurst++;
    } else {
      bursts.push(currentBurst);
      currentBurst = 1;
    }
  }
  bursts.push(currentBurst);

  if (bursts.length < 2) return 50;

  const avgBurst = bursts.reduce((s, v) => s + v, 0) / bursts.length;
  const burstStd = computeStd(bursts);
  const burstCv = avgBurst > 0 ? burstStd / avgBurst : 0;

  let score = 0;

  // Humans have varied burst lengths (CV > 0.3) and average burst 3-15
  if (avgBurst >= 3 && avgBurst <= 15) {
    score += 50;
  } else if (avgBurst < 3) {
    score += Math.round((avgBurst / 3) * 50);
  } else {
    score += Math.round(Math.max(20, 50 - ((avgBurst - 15) / 10) * 30));
  }

  // Variance in burst lengths
  if (burstCv > 0.5) {
    score += 50;
  } else if (burstCv > 0.1) {
    score += Math.round(((burstCv - 0.1) / 0.4) * 50);
  } else {
    score += 5; // nearly uniform bursts → suspicious
  }

  return clamp(score);
}

function computeStd(values: number[]): number {
  if (values.length < 2) return 0;
  const m = values.reduce((s, v) => s + v, 0) / values.length;
  const variance = values.reduce((s, v) => s + (v - m) ** 2, 0) / (values.length - 1);
  return Math.sqrt(variance);
}

const WEIGHTS = {
  timingVariance: 0.20,
  correctionRate: 0.15,
  pauseDistribution: 0.20,
  distributionShape: 0.15,
  flightTimeNegativity: 0.15,
  burstPatterns: 0.15,
} as const;

export function analyzeHumanness(
  digraphs: RawDigraph[],
  metadata: SessionMetadata,
): HumannessResult | null {
  if (digraphs.length < 20) return null;

  const subScores = {
    timingVariance: scoreTimingVariance(digraphs),
    correctionRate: scoreCorrectionRate(metadata),
    pauseDistribution: scorePauseDistribution(metadata, digraphs),
    distributionShape: scoreDistributionShape(digraphs),
    flightTimeNegativity: scoreFlightTimeNegativity(digraphs),
    burstPatterns: scoreBurstPatterns(digraphs),
  };

  const score = Math.round(
    subScores.timingVariance * WEIGHTS.timingVariance +
    subScores.correctionRate * WEIGHTS.correctionRate +
    subScores.pauseDistribution * WEIGHTS.pauseDistribution +
    subScores.distributionShape * WEIGHTS.distributionShape +
    subScores.flightTimeNegativity * WEIGHTS.flightTimeNegativity +
    subScores.burstPatterns * WEIGHTS.burstPatterns,
  );

  let verdict: HumannessResult['verdict'];
  if (score >= 60) verdict = 'likely human';
  else if (score >= 40) verdict = 'uncertain';
  else verdict = 'likely bot';

  // Factor in paste ratio as a penalty
  const pasteRatio = metadata.totalKeystrokes > 0
    ? metadata.pastedCharCount / metadata.totalKeystrokes
    : 0;

  let adjustedScore = score;
  if (pasteRatio > 0.5) {
    adjustedScore = Math.round(score * (1 - (pasteRatio - 0.5) * 0.4));
  }

  if (adjustedScore !== score) {
    if (adjustedScore >= 60) verdict = 'likely human';
    else if (adjustedScore >= 40) verdict = 'uncertain';
    else verdict = 'likely bot';
  }

  return {
    score: clamp(adjustedScore),
    verdict,
    subScores,
  };
}