import HumannessView from './lib/components/HumannessView.svelte';

    <HumannessView {digraphs} metadata={sessionMetadata} />

<script>

  import { analyzeHumanness } from '../humanness';

  export let digraphs = [];

  export let metadata = {};

  $: result = analyzeHumanness(digraphs, metadata);

  const subScoreLabels = {

    timingVariance: {

      name: 'timing variance',

      desc: 'variation in key-to-key timing per digraph pair',

    },

    correctionRate: {

      name: 'correction rate',

      desc: 'backspace usage relative to total keystrokes',

    },

    pauseDistribution: {

      name: 'pause distribution',

      desc: 'presence and variety of natural thinking pauses',

    },

    distributionShape: {

      name: 'distribution shape',

      desc: 'right-skewed timing distribution (log-normal)',

    },

    flightTimeNegativity: {

      name: 'flight time negativity',

      desc: 'key overlap from pressing next key before releasing previous',

    },

    burstPatterns: {

      name: 'burst patterns',

      desc: 'variance in typing burst lengths between pauses',

    },

  };

  const subScoreKeys = Object.keys(subScoreLabels);

  function verdictColor(verdict) {

    if (verdict === 'likely human') return '#4ade80';

    if (verdict === 'uncertain') return '#facc15';

    return '#ff6b6b';

  }

  function barColor(score) {

    if (score >= 70) return '#4ade80';

    if (score >= 40) return '#facc15';

    return '#ff6b6b';

  }

</script>

{#if digraphs.length < 20}

  <div class="empty">

    <p>keep typing...</p>

    <span class="empty-sub">{20 - digraphs.length} more digraphs needed for analysis</span>

  </div>

{:else if result}

  <div class="humanness">

    <div class="score-card">

      <div class="main-score">

        <span class="score-value" style="color: {verdictColor(result.verdict)}">{result.score}</span>

        <span class="score-label">human-ness</span>

      </div>

      <div class="verdict-section">

        <span class="verdict" style="color: {verdictColor(result.verdict)}">{result.verdict}</span>

        {#if metadata.pastedCharCount > 0}

          <span class="paste-note">

            {metadata.pasteCount} paste{metadata.pasteCount !== 1 ? 's' : ''} detected ({metadata.pastedCharCount} chars)

          </span>

        {/if}

      </div>

    </div>

    <div class="bars">

      {#each subScoreKeys as key}

        <div class="bar-row">

          <div class="bar-header">

            <span class="bar-name">{subScoreLabels[key].name}</span>

            <span class="bar-value" style="color: {barColor(result.subScores[key])}">{result.subScores[key]}</span>

          </div>

          <div class="bar-track">

            <div

              class="bar-fill"

              style="width: {result.subScores[key]}%; background: {barColor(result.subScores[key])}"

            ></div>

          </div>

          <span class="bar-desc">{subScoreLabels[key].desc}</span>

        </div>

      {/each}

    </div>

  </div>

{/if}

<style>

  .empty {

    display: flex;

    flex-direction: column;

    align-items: center;

    justify-content: center;

    padding: 4rem 2rem;

    border: 1px dashed #333;

    gap: 0.5rem;

  }

  .empty p {

    font-size: 14px;

    color: #888;

  }

  .empty-sub {

    font-size: 11px;

    color: #555;

  }

  .humanness {

    display: flex;

    flex-direction: column;

    gap: 1.5rem;

  }

  .score-card {

    display: flex;

    border: 1px solid #333;

  }

  .main-score {

    display: flex;

    flex-direction: column;

    align-items: center;

    justify-content: center;

    padding: 1.5rem 2rem;

    border-right: 1px solid #333;

    min-width: 140px;

  }

  .score-value {

    font-size: 48px;

    font-weight: 700;

    line-height: 1;

  }

  .score-label {

    font-size: 10px;

    color: #888;

    margin-top: 0.35rem;

    text-transform: uppercase;

    letter-spacing: 0.05em;

  }

  .verdict-section {

    display: flex;

    flex-direction: column;

    justify-content: center;

    padding: 1rem 1.5rem;

    gap: 0.5rem;

  }

  .verdict {

    font-size: 18px;

    font-weight: 700;

    text-transform: uppercase;

    letter-spacing: 0.05em;

  }

  .paste-note {

    font-size: 10px;

    color: #555;

  }

  .bars {

    display: flex;

    flex-direction: column;

    gap: 1rem;

  }

  .bar-row {

    display: flex;

    flex-direction: column;

    gap: 0.25rem;

  }

  .bar-header {

    display: flex;

    justify-content: space-between;

    align-items: baseline;

  }

  .bar-name {

    font-size: 12px;

    font-weight: 700;

  }

  .bar-value {

    font-size: 13px;

    font-weight: 700;

  }

  .bar-track {

    width: 100%;

    height: 6px;

    background: #333;

  }

  .bar-fill {

    height: 100%;

    transition: width 0.3s ease;

  }

  .bar-desc {

    font-size: 10px;

    color: #555;

  }

  @media (max-width: 480px) {

    .score-card {

      flex-direction: column;

    }

    .main-score {

      border-right: none;

      border-bottom: 1px solid #333;

      padding: 1rem;

    }

  }

</style>

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,

  };

}