#!/usr/bin/env python3
"""
Создаёт/обновляет 6 benchmark-функций с ~10KB кода и тяжёлой вычислительной нагрузкой.
Случайные задержки, матрицы, сортировки, хэши — настоящая нагрузка.
"""
import json, subprocess, sys

BASE = "https://fission.kube5s.ru/console/api"
SUB = "livetest@test.local"

# ── Node.js ──────────────────────────────────────────────────────────────────
NODE_CODE = r"""module.exports = async (ctx) => {
  // ~10KB of real CPU work + async delays with random timing

  function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }

  function millerRabin(n) {
    if (n < 2) return false; if (n===2||n===3||n===5||n===7) return true;
    if (n%2===0) return false;
    let d=n-1, r=0; while(d%2===0){d/=2;r++;}
    const witnesses=[2,3,5,7,11,13,17,19,23,29,31,37];
    for(const a of witnesses){
      if(a>=n)continue; let x=modPow(a,d,n);
      if(x===1||x===n-1)continue; let cont=false;
      for(let i=0;i<r-1;i++){x=modPow(x,2,n);if(x===n-1){cont=true;break;}}
      if(!cont)return false;
    }
    return true;
  }
  function modPow(base,exp,mod){
    let result=1n,b=BigInt(base),e=BigInt(exp),m=BigInt(mod);
    b%=m; while(e>0n){if(e%2n===1n)result=result*b%m;e>>=1n;b=b*b%m;}
    return Number(result);
  }

  function gcd(a,b){while(b){[a,b]=[b,a%b];}return a;}
  function lcm(a,b){return a/gcd(a,b)*b;}

  function lucas(n){
    if(n===0)return 2; if(n===1)return 1;
    let a=2,b=1; for(let i=2;i<=n;i++){let t=a+b;a=b;b=t;} return b;
  }

  function fnv1a(str){
    let h=2166136261>>>0;
    for(let i=0;i<str.length;i++){h^=str.charCodeAt(i);h=Math.imul(h,16777619)>>>0;}
    return h;
  }

  function collatz(n){let s=0;while(n!==1){n=n%2===0?n/2:3*n+1;s++;}return s;}

  function hornerEval(coeffs,x){
    let r=0; for(let i=coeffs.length-1;i>=0;i--)r=r*x+coeffs[i]; return r;
  }

  function digitSum(n){let s=0;while(n>0){s+=n%10;n=Math.floor(n/10);}return s;}

  function sundaramSieve(n){
    const lim=Math.floor((n-2)/2);
    const s=new Array(lim+1).fill(false);
    for(let i=1;i<=lim;i++) for(let j=i;i+j+2*i*j<=lim;j++) s[i+j+2*i*j]=true;
    const primes=[2];
    for(let i=1;i<=lim;i++) if(!s[i]) primes.push(2*i+1);
    return primes;
  }

  function rleEncode(arr){
    if(!arr.length)return[];
    const out=[];let cur=arr[0],cnt=1;
    for(let i=1;i<arr.length;i++){if(arr[i]===cur)cnt++;else{out.push([cur,cnt]);cur=arr[i];cnt=1;}}
    out.push([cur,cnt]);return out;
  }

  function heapSort(arr){
    const a=[...arr],n=a.length;
    function heapify(i,size){let l=2*i+1,r=2*i+2,m=i;if(l<size&&a[l]>a[m])m=l;if(r<size&&a[r]>a[m])m=r;if(m!==i){[a[i],a[m]]=[a[m],a[i]];heapify(m,size);}}
    for(let i=Math.floor(n/2)-1;i>=0;i--)heapify(i,n);
    for(let i=n-1;i>0;i--){[a[0],a[i]]=[a[i],a[0]];heapify(0,i);}
    return a;
  }

  function fib(n) {
    if (n <= 1) return n;
    let a = 0, b = 1;
    for (let i = 2; i <= n; i++) { let t = a + b; a = b; b = t; }
    return b;
  }

  function isPrime(n) {
    if (n < 2) return false;
    if (n === 2) return true;
    if (n % 2 === 0) return false;
    for (let i = 3; i * i <= n; i += 2) if (n % i === 0) return false;
    return true;
  }

  function sieveOfEratosthenes(limit) {
    const sieve = new Array(limit + 1).fill(true);
    sieve[0] = sieve[1] = false;
    for (let i = 2; i * i <= limit; i++) {
      if (sieve[i]) for (let j = i * i; j <= limit; j += i) sieve[j] = false;
    }
    return sieve.map((v, i) => v ? i : -1).filter(v => v > 0);
  }

  function matMul(A, B, n) {
    const C = Array.from({length: n}, () => new Array(n).fill(0));
    for (let i = 0; i < n; i++)
      for (let k = 0; k < n; k++)
        for (let j = 0; j < n; j++)
          C[i][j] += A[i][k] * B[k][j];
    return C;
  }

  function makeMatrix(n, seed) {
    const M = [];
    for (let i = 0; i < n; i++) {
      const row = [];
      for (let j = 0; j < n; j++) row.push(((i * n + j + seed) % 17) * 0.1 + 1);
      M.push(row);
    }
    return M;
  }

  function bubbleSort(arr) {
    const a = [...arr];
    for (let i = 0; i < a.length; i++)
      for (let j = 0; j < a.length - i - 1; j++)
        if (a[j] > a[j+1]) { let t = a[j]; a[j] = a[j+1]; a[j+1] = t; }
    return a;
  }

  function mergeSort(arr) {
    if (arr.length <= 1) return arr;
    const mid = Math.floor(arr.length / 2);
    const L = mergeSort(arr.slice(0, mid));
    const R = mergeSort(arr.slice(mid));
    const res = [];
    let i = 0, j = 0;
    while (i < L.length && j < R.length)
      res.push(L[i] <= R[j] ? L[i++] : R[j++]);
    return res.concat(L.slice(i)).concat(R.slice(j));
  }

  function lcg(seed) {
    // Linear Congruential Generator for pseudo-random
    return ((seed * 1664525 + 1013904223) & 0xffffffff) >>> 0;
  }

  function generateArray(size, seed) {
    const arr = [];
    let s = seed;
    for (let i = 0; i < size; i++) { s = lcg(s); arr.push(s % 10000); }
    return arr;
  }

  function polyEval(coeffs, x) {
    let result = 0, power = 1;
    for (const c of coeffs) { result += c * power; power *= x; }
    return result;
  }

  function computeHash(str) {
    let hash = 5381;
    for (let i = 0; i < str.length; i++) hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
    return hash >>> 0;
  }

  function runRLE(data) {
    // Run-length encoding
    if (!data.length) return [];
    const out = [];
    let cur = data[0], cnt = 1;
    for (let i = 1; i < data.length; i++) {
      if (data[i] === cur) cnt++;
      else { out.push([cur, cnt]); cur = data[i]; cnt = 1; }
    }
    out.push([cur, cnt]);
    return out;
  }

  // Random delay 200ms–1500ms
  const delay = 200 + (lcg(Date.now() & 0xffff) % 1300);
  await sleep(delay);

  // Phase 1: Sieve primes up to 2000
  const primes = sieveOfEratosthenes(2000);
  await sleep(50 + (lcg(primes.length) % 200));

  // Phase 2: Fibonacci batch
  const fibs = [];
  for (let i = 20; i <= 50; i += 5) fibs.push({ n: i, val: fib(i) });
  await sleep(30 + (lcg(fibs.length * 7) % 150));

  // Phase 3: Matrix multiply 20×20
  const A = makeMatrix(20, 3);
  const B = makeMatrix(20, 7);
  const C = matMul(A, B, 20);
  const matSum = C.reduce((s, row) => s + row.reduce((a, b) => a + b, 0), 0);
  await sleep(20 + (lcg(Math.floor(matSum) & 0xffff) % 100));

  // Phase 4: Sort 800 elements two ways
  const arr800 = generateArray(800, 42);
  const bSorted = bubbleSort(arr800.slice(0, 200));
  const mSorted = mergeSort(arr800);
  await sleep(10 + (lcg(bSorted[0]) % 80));

  // Phase 5: Polynomial evaluation
  const coeffs = [1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1];
  const polyResults = [];
  for (let x = -5; x <= 5; x += 0.5) polyResults.push(polyEval(coeffs, x));
  await sleep(10 + (lcg(polyResults.length * 3) % 60));

  // Phase 6: Hash chain
  let h = computeHash("bench-node-start");
  const hashChain = [h];
  for (let i = 0; i < 500; i++) { h = computeHash(String(h)); hashChain.push(h); }

  // Phase 7: RLE on prime indicators
  const indicators = Array.from({length: 500}, (_, i) => isPrime(i) ? 1 : 0);
  const rle = runRLE(indicators);

  await sleep(10 + (lcg(hashChain[hashChain.length - 1] & 0xffff) % 50));

  return {
    body: JSON.stringify({
      language: "nodejs",
      delay_ms: delay,
      prime_count: primes.length,
      prime_sum: primes.reduce((a, b) => a + b, 0),
      fibs: fibs,
      mat_sum: matSum.toFixed(4),
      sort_check: mSorted[0] <= mSorted[mSorted.length - 1],
      poly_max: Math.max(...polyResults).toFixed(4),
      hash_final: hashChain[hashChain.length - 1],
      rle_segments: rle.length,
    })
  };
};
"""

# ── PHP ───────────────────────────────────────────────────────────────────────
PHP_CODE = r"""<?php
function handler($context) {
    // ~10KB CPU work + random delays

    $startTime = microtime(true);

    // LCG pseudo-random
    function lcg_rand($seed) {
        return (($seed * 1664525 + 1013904223) & 0x7fffffff);
    }

    function is_prime($n) {
        if ($n < 2) return false;
        if ($n === 2) return true;
        if ($n % 2 === 0) return false;
        for ($i = 3; $i * $i <= $n; $i += 2) if ($n % $i === 0) return false;
        return true;
    }

    function sieve($limit) {
        $s = array_fill(0, $limit + 1, true);
        $s[0] = $s[1] = false;
        for ($i = 2; $i * $i <= $limit; $i++)
            if ($s[$i]) for ($j = $i * $i; $j <= $limit; $j += $i) $s[$j] = false;
        $primes = [];
        for ($i = 2; $i <= $limit; $i++) if ($s[$i]) $primes[] = $i;
        return $primes;
    }

    function mat_mul($A, $B, $n) {
        $C = array_fill(0, $n, array_fill(0, $n, 0.0));
        for ($i = 0; $i < $n; $i++)
            for ($k = 0; $k < $n; $k++)
                for ($j = 0; $j < $n; $j++)
                    $C[$i][$j] += $A[$i][$k] * $B[$k][$j];
        return $C;
    }

    function make_matrix($n, $seed) {
        $M = [];
        for ($i = 0; $i < $n; $i++) {
            $row = [];
            for ($j = 0; $j < $n; $j++) $row[] = (($i * $n + $j + $seed) % 17) * 0.1 + 1.0;
            $M[] = $row;
        }
        return $M;
    }

    function fib($n) {
        if ($n <= 1) return $n;
        $a = 0; $b = 1;
        for ($i = 2; $i <= $n; $i++) { $t = $a + $b; $a = $b; $b = $t; }
        return $b;
    }

    function insertion_sort($arr) {
        $n = count($arr);
        for ($i = 1; $i < $n; $i++) {
            $key = $arr[$i]; $j = $i - 1;
            while ($j >= 0 && $arr[$j] > $key) { $arr[$j + 1] = $arr[$j]; $j--; }
            $arr[$j + 1] = $key;
        }
        return $arr;
    }

    function poly_eval($coeffs, $x) {
        $result = 0.0; $power = 1.0;
        foreach ($coeffs as $c) { $result += $c * $power; $power *= $x; }
        return $result;
    }

    function djb2($str) {
        $hash = 5381;
        for ($i = 0; $i < strlen($str); $i++) $hash = (($hash << 5) + $hash + ord($str[$i])) & 0x7fffffff;
        return $hash;
    }

    // Random delay 300ms-1200ms via usleep
    $seed = (int)(microtime(true) * 1000) & 0xffff;
    $delay_us = (300 + lcg_rand($seed) % 900) * 1000;
    usleep($delay_us);

    // Phase 1: Sieve primes up to 2000
    $primes = sieve(2000);
    $prime_sum = array_sum($primes);

    // Phase 2: Fibonacci batch
    $fibs = [];
    for ($i = 20; $i <= 50; $i += 5) $fibs[$i] = fib($i);
    usleep(30000 + lcg_rand(count($fibs)*7) % 100000);

    // Phase 3: Matrix 20x20
    $A = make_matrix(20, 5);
    $B = make_matrix(20, 9);
    $C = mat_mul($A, $B, 20);
    $mat_sum = 0.0;
    foreach ($C as $row) foreach ($row as $v) $mat_sum += $v;
    usleep(20000 + lcg_rand((int)$mat_sum & 0xffff) % 80000);

    // Phase 4: Insertion sort 300 elements
    $arr = [];
    $s2 = 99;
    for ($i = 0; $i < 300; $i++) { $s2 = lcg_rand($s2); $arr[] = $s2 % 10000; }
    $sorted = insertion_sort($arr);
    usleep(10000 + lcg_rand($sorted[0]) % 60000);

    // Phase 5: Polynomial evaluation
    $coeffs = [1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1];
    $poly_max = -1e18;
    for ($x = -5.0; $x <= 5.0; $x += 0.5) {
        $v = poly_eval($coeffs, $x);
        if ($v > $poly_max) $poly_max = $v;
    }
    usleep(10000 + lcg_rand(count($primes)) % 50000);

    // Phase 6: Hash chain 500 iterations
    $h = djb2("bench-php-start");
    $chain = [$h];
    for ($i = 0; $i < 500; $i++) { $h = djb2((string)$h); $chain[] = $h; }

    // Phase 7: Count twin primes
    $twins = 0;
    for ($i = 0; $i < count($primes) - 1; $i++)
        if ($primes[$i + 1] - $primes[$i] === 2) $twins++;

    usleep(10000 + lcg_rand(end($chain)) % 40000);

    $elapsed = round((microtime(true) - $startTime) * 1000);

    $context["response"]->getBody()->write(json_encode([
        "language"     => "php",
        "delay_ms"     => (int)($delay_us / 1000),
        "elapsed_ms"   => $elapsed,
        "prime_count"  => count($primes),
        "prime_sum"    => $prime_sum,
        "fib45"        => $fibs[45],
        "mat_sum"      => round($mat_sum, 4),
        "sort_ok"      => $sorted[0] <= $sorted[count($sorted)-1],
        "poly_max"     => round($poly_max, 4),
        "hash_final"   => end($chain),
        "twin_primes"  => $twins,
    ]));
}
"""

# ── Ruby ──────────────────────────────────────────────────────────────────────
RUBY_CODE = r"""def handler
  require 'json'

  start_time = Time.now

  # LCG pseudo-random
  lcg = ->(s) { ((s * 1664525 + 1013904223) & 0x7fffffff) }

  is_prime = ->(n) {
    return false if n < 2
    return true  if n == 2
    return false if n.even?
    d = 3; while d * d <= n; return false if n % d == 0; d += 2; end
    true
  }

  sieve = ->(limit) {
    s = Array.new(limit + 1, true); s[0] = s[1] = false
    i = 2; while i * i <= limit
      if s[i]; j = i * i; while j <= limit; s[j] = false; j += i; end; end
      i += 1
    end
    (2..limit).select { |k| s[k] }
  }

  mat_mul = ->(a, b, n) {
    c = Array.new(n) { Array.new(n, 0.0) }
    n.times { |i| n.times { |k| n.times { |j| c[i][j] += a[i][k] * b[k][j] } } }
    c
  }

  make_matrix = ->(n, seed) {
    Array.new(n) { |i| Array.new(n) { |j| ((i * n + j + seed) % 17) * 0.1 + 1.0 } }
  }

  fib = ->(n) {
    return n if n <= 1
    a, b = 0, 1; (n - 1).times { a, b = b, a + b }; b
  }

  shell_sort = ->(arr) {
    a = arr.dup; gap = a.length / 2
    while gap > 0
      (gap...a.length).each { |i| tmp = a[i]; j = i; while j >= gap && a[j-gap] > tmp; a[j] = a[j-gap]; j -= gap; end; a[j] = tmp }
      gap /= 2
    end
    a
  }

  poly_eval = ->(coeffs, x) {
    result = 0.0; power = 1.0
    coeffs.each { |c| result += c * power; power *= x }
    result
  }

  djb2 = ->(str) {
    h = 5381; str.each_byte { |b| h = ((h << 5) + h + b) & 0x7fffffff }; h
  }

  collatz = ->(n) { steps = 0; while n != 1; n = n.even? ? n / 2 : 3 * n + 1; steps += 1; end; steps }

  # Random delay 250ms-1600ms
  seed = (Time.now.to_f * 1000).to_i & 0xffff
  delay_ms = 250 + lcg.(seed) % 1350
  sleep(delay_ms / 1000.0)

  # Phase 1: Sieve
  primes = sieve.(2000)
  prime_sum = primes.sum
  sleep(0.05 + (lcg.(primes.length) % 200) / 1000.0)

  # Phase 2: Fibonacci batch
  fibs = (20..50).step(5).map { |n| [n, fib.(n)] }.to_h
  sleep(0.03 + (lcg.(fibs.length * 7) % 150) / 1000.0)

  # Phase 3: Matrix 20x20
  a_mat = make_matrix.(20, 4)
  b_mat = make_matrix.(20, 8)
  c_mat = mat_mul.(a_mat, b_mat, 20)
  mat_sum = c_mat.flatten.sum
  sleep(0.02 + (lcg.(mat_sum.to_i & 0xffff) % 100) / 1000.0)

  # Phase 4: Shell sort 500 elements
  s2 = 77
  arr = Array.new(500) { s2 = lcg.(s2); s2 % 10000 }
  sorted = shell_sort.(arr)
  sleep(0.01 + (lcg.(sorted.first) % 80) / 1000.0)

  # Phase 5: Polynomial
  coeffs = [1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1]
  poly_max = (-5.0..5.0).step(0.5).map { |x| poly_eval.(coeffs, x) }.max
  sleep(0.01 + (lcg.(primes.length) % 60) / 1000.0)

  # Phase 6: Hash chain
  h = djb2.("bench-ruby-start")
  chain = [h]
  500.times { h = djb2.(h.to_s); chain << h }

  # Phase 7: Collatz max steps for 1..200
  collatz_max = (1..200).map { |n| collatz.(n) }.max
  sleep(0.01 + (lcg.(chain.last & 0xffff) % 50) / 1000.0)

  elapsed_ms = ((Time.now - start_time) * 1000).round

  {
    language:    "ruby",
    delay_ms:    delay_ms,
    elapsed_ms:  elapsed_ms,
    prime_count: primes.size,
    prime_sum:   prime_sum,
    fib45:       fibs[45],
    mat_sum:     mat_sum.round(4),
    sort_ok:     sorted.first <= sorted.last,
    poly_max:    poly_max.round(4),
    hash_final:  chain.last,
    collatz_max: collatz_max,
  }.to_json
end
"""

# ── Perl ──────────────────────────────────────────────────────────────────────
PERL_CODE = r"""sub {
    use Time::HiRes qw(time usleep);
    use POSIX qw(floor);

    my $start = time();

    sub lcg_r { return (($_[0] * 1664525 + 1013904223) & 0x7fffffff); }

    sub is_prime_p {
        my $n = shift; return 0 if $n < 2; return 1 if $n == 2;
        return 0 if $n % 2 == 0;
        my $i = 3; while ($i * $i <= $n) { return 0 if $n % $i == 0; $i += 2; } return 1;
    }

    sub sieve_p {
        my $lim = shift;
        my @s = (1) x ($lim + 1); $s[0] = $s[1] = 0;
        for (my $i = 2; $i * $i <= $lim; $i++) {
            if ($s[$i]) { for (my $j = $i*$i; $j <= $lim; $j += $i) { $s[$j] = 0; } }
        }
        return grep { $s[$_] } 2..$lim;
    }

    sub fib_p {
        my $n = shift; return $n if $n <= 1;
        my ($a, $b) = (0, 1);
        for (my $i = 2; $i <= $n; $i++) { ($a, $b) = ($b, $a + $b); }
        return $b;
    }

    sub mat_mul_p {
        my ($A, $B, $n) = @_;
        my @C = map { [(0) x $n] } 0..$n-1;
        for my $i (0..$n-1) { for my $k (0..$n-1) { for my $j (0..$n-1) {
            $C[$i][$j] += $A->[$i][$k] * $B->[$k][$j];
        }}}
        return @C;
    }

    sub make_mat_p {
        my ($n, $seed) = @_;
        return map { my $i = $_; [ map { (($i*$n+$_+$seed)%17)*0.1+1.0 } 0..$n-1 ] } 0..$n-1;
    }

    sub djb2_p {
        my $str = shift; my $h = 5381;
        for my $c (split //, $str) { $h = (($h<<5)+$h+ord($c)) & 0x7fffffff; }
        return $h;
    }

    sub selection_sort_p {
        my @a = @_; my $n = scalar @a;
        for my $i (0..$n-2) {
            my $min = $i;
            for my $j ($i+1..$n-1) { $min = $j if $a[$j] < $a[$min]; }
            @a[$i, $min] = @a[$min, $i] if $min != $i;
        }
        return @a;
    }

    sub poly_eval_p {
        my ($coeffs, $x) = @_; my ($r, $p) = (0.0, 1.0);
        for my $c (@$coeffs) { $r += $c * $p; $p *= $x; }
        return $r;
    }

    sub collatz_p {
        my $n = shift; my $steps = 0;
        while ($n != 1) { $n = ($n % 2 == 0) ? $n/2 : 3*$n+1; $steps++; }
        return $steps;
    }

    # Random delay 300ms-1500ms
    my $seed = int(time() * 1000) & 0xffff;
    my $delay_us = (300 + lcg_r($seed) % 1200) * 1000;
    usleep($delay_us);

    # Phase 1: Sieve
    my @primes = sieve_p(2000);
    my $prime_sum = 0; $prime_sum += $_ for @primes;
    usleep(50000 + lcg_r(scalar @primes) % 200000);

    # Phase 2: Fibonacci
    my %fibs = map { $_ => fib_p($_) } grep { $_ % 5 == 0 } 20..50;
    usleep(30000 + lcg_r(scalar keys %fibs) % 150000);

    # Phase 3: Matrix 15x15
    my @A = make_mat_p(15, 6);
    my @B = make_mat_p(15, 11);
    my @C = mat_mul_p(\@A, \@B, 15);
    my $mat_sum = 0.0;
    for my $row (@C) { $mat_sum += $_ for @$row; }
    usleep(20000 + lcg_r(int($mat_sum) & 0xffff) % 100000);

    # Phase 4: Selection sort 250 elements
    my $s2 = 55; my @arr;
    for (1..250) { $s2 = lcg_r($s2); push @arr, $s2 % 10000; }
    my @sorted = selection_sort_p(@arr);
    usleep(10000 + lcg_r($sorted[0]) % 80000);

    # Phase 5: Polynomial
    my @coeffs = (1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1);
    my $poly_max = -1e18;
    for (my $x = -5.0; $x <= 5.0; $x += 0.5) {
        my $v = poly_eval_p(\@coeffs, $x); $poly_max = $v if $v > $poly_max;
    }
    usleep(10000 + lcg_r(scalar @primes) % 60000);

    # Phase 6: Hash chain
    my $h = djb2_p("bench-perl-start");
    my @chain = ($h);
    for (1..500) { $h = djb2_p("$h"); push @chain, $h; }

    # Phase 7: Collatz
    my $cmax = 0;
    for my $n (1..200) { my $s = collatz_p($n); $cmax = $s if $s > $cmax; }
    usleep(10000 + lcg_r($chain[-1] & 0xffff) % 50000);

    my $elapsed_ms = int((time() - $start) * 1000);

    return sprintf('{"language":"perl","delay_ms":%d,"elapsed_ms":%d,"prime_count":%d,"prime_sum":%d,"fib45":%d,"mat_sum":%.4f,"sort_ok":%s,"poly_max":%.4f,"hash_final":%d,"collatz_max":%d}',
        int($delay_us/1000), $elapsed_ms, scalar @primes, $prime_sum, $fibs{45},
        $mat_sum, ($sorted[0] <= $sorted[-1] ? "true" : "false"),
        $poly_max, $chain[-1], $cmax);
}
"""

# ── Go ────────────────────────────────────────────────────────────────────────
GO_CODE = r"""package main

import (
	"encoding/json"
	"fmt"
	"math"
	"math/rand"
	"net/http"
	"sort"
	"strings"
	"time"
)

func sieveGo(limit int) []int {
	s := make([]bool, limit+1)
	for i := range s { s[i] = true }
	s[0], s[1] = false, false
	for i := 2; i*i <= limit; i++ {
		if s[i] { for j := i * i; j <= limit; j += i { s[j] = false } }
	}
	primes := []int{}
	for i := 2; i <= limit; i++ { if s[i] { primes = append(primes, i) } }
	return primes
}

func fibGo(n int) int64 {
	if n <= 1 { return int64(n) }
	a, b := int64(0), int64(1)
	for i := 2; i <= n; i++ { a, b = b, a+b }
	return b
}

func matMulGo(a, b [20][20]float64) [20][20]float64 {
	var c [20][20]float64
	for i := 0; i < 20; i++ {
		for k := 0; k < 20; k++ {
			for j := 0; j < 20; j++ { c[i][j] += a[i][k] * b[k][j] }
		}
	}
	return c
}

func makeMatGo(seed float64) [20][20]float64 {
	var m [20][20]float64
	for i := 0; i < 20; i++ {
		for j := 0; j < 20; j++ {
			m[i][j] = math.Mod(float64(i*20+j)+seed, 17)*0.1 + 1.0
		}
	}
	return m
}

func shellSortGo(arr []int) []int {
	a := make([]int, len(arr)); copy(a, arr)
	for gap := len(a) / 2; gap > 0; gap /= 2 {
		for i := gap; i < len(a); i++ {
			tmp := a[i]; j := i
			for j >= gap && a[j-gap] > tmp { a[j] = a[j-gap]; j -= gap }
			a[j] = tmp
		}
	}
	return a
}

func quickSortGo(arr []int) []int {
	a := make([]int, len(arr)); copy(a, arr)
	sort.Ints(a)
	return a
}

func polyEvalGo(coeffs []float64, x float64) float64 {
	result, power := 0.0, 1.0
	for _, c := range coeffs { result += c * power; power *= x }
	return result
}

func djb2Go(s string) uint32 {
	h := uint32(5381)
	for _, c := range s { h = ((h << 5) + h + uint32(c)) & 0x7fffffff }
	return h
}

func fnv1aGo(s string) uint32 {
	h := uint32(2166136261)
	for _, c := range []byte(s) { h ^= uint32(c); h *= 16777619 }
	return h
}

func collatzGo(n int) int {
	steps := 0
	for n != 1 {
		if n%2 == 0 { n /= 2 } else { n = 3*n + 1 }
		steps++
	}
	return steps
}

func isPrimeGo(n int) bool {
	if n < 2 { return false }
	if n == 2 { return true }
	if n%2 == 0 { return false }
	for d := 3; d*d <= n; d += 2 { if n%d == 0 { return false } }
	return true
}

func gcdGo(a, b int) int {
	for b != 0 { a, b = b, a%b }
	return a
}

func lcmGo(a, b int) int { return a / gcdGo(a, b) * b }

// Горнер для вычисления полинома
func hornerEval(coeffs []float64, x float64) float64 {
	result := 0.0
	for i := len(coeffs) - 1; i >= 0; i-- { result = result*x + coeffs[i] }
	return result
}

// Решето Сундарама
func sundaramSieve(n int) []int {
	limit := (n - 2) / 2
	s := make([]bool, limit+1)
	for i := 1; i <= limit; i++ {
		for j := i; i+j+2*i*j <= limit; j++ { s[i+j+2*i*j] = true }
	}
	primes := []int{2}
	for i := 1; i <= limit; i++ { if !s[i] { primes = append(primes, 2*i+1) } }
	return primes
}

// Простые числа через Miller-Rabin (детерминированный для малых n)
func millerRabinGo(n int) bool {
	if n < 2 { return false }
	if n == 2 || n == 3 || n == 5 || n == 7 { return true }
	if n%2 == 0 { return false }
	d, r := n-1, 0
	for d%2 == 0 { d /= 2; r++ }
	witnesses := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}
	for _, a := range witnesses {
		if a >= n { continue }
		x := modPowGo(a, d, n)
		if x == 1 || x == n-1 { continue }
		cont := false
		for _ = range make([]struct{}, r-1) {
			x = modPowGo(x, 2, n)
			if x == n-1 { cont = true; break }
		}
		if !cont { return false }
	}
	return true
}

func modPowGo(base, exp, mod int) int {
	result := 1; base %= mod
	for exp > 0 {
		if exp%2 == 1 { result = result * base % mod }
		exp /= 2; base = base * base % mod
	}
	return result
}

// Числа Люка
func lucasGo(n int) int64 {
	if n == 0 { return 2 }
	if n == 1 { return 1 }
	a, b := int64(2), int64(1)
	for i := 2; i <= n; i++ { a, b = b, a+b }
	return b
}

// Цифровая сумма
func digitSumGo(n int) int {
	s := 0
	for n > 0 { s += n % 10; n /= 10 }
	return s
}

func Handler(w http.ResponseWriter, r *http.Request) {
	rng := rand.New(rand.NewSource(time.Now().UnixNano()))

	// Random delay 300ms-1800ms
	delayMs := 300 + rng.Intn(1500)
	time.Sleep(time.Duration(delayMs) * time.Millisecond)

	// Phase 1: Sieve of Eratosthenes up to 3000
	primes := sieveGo(3000)
	primeSum := 0
	for _, p := range primes { primeSum += p }
	time.Sleep(time.Duration(50+rng.Intn(200)) * time.Millisecond)

	// Phase 2: Sundaram sieve cross-check
	primes2 := sundaramSieve(3000)
	_ = primes2
	time.Sleep(time.Duration(30+rng.Intn(150)) * time.Millisecond)

	// Phase 3: Miller-Rabin for 1000..1200
	mrCount := 0
	for n := 1000; n <= 1200; n++ { if millerRabinGo(n) { mrCount++ } }
	time.Sleep(time.Duration(20+rng.Intn(100)) * time.Millisecond)

	// Phase 4: Fibonacci + Lucas + digit sums
	type entry struct{ N int; Fib, Lucas int64; DigSum int }
	entries := []entry{}
	for n := 20; n <= 60; n += 5 {
		f := fibGo(n); l := lucasGo(n)
		entries = append(entries, entry{n, f, l, digitSumGo(int(f % 1000000))})
	}
	time.Sleep(time.Duration(30+rng.Intn(150)) * time.Millisecond)

	// Phase 5: Matrix multiply 20x20
	A := makeMatGo(3.0); B := makeMatGo(7.0)
	C := matMulGo(A, B)
	matSum := 0.0
	for _, row := range C { for _, v := range row { matSum += v } }
	time.Sleep(time.Duration(20+rng.Intn(100)) * time.Millisecond)

	// Phase 6: Shell sort + stdlib sort 800 elements, compare
	arr := make([]int, 800)
	for i := range arr { arr[i] = rng.Intn(10000) }
	shellSorted := shellSortGo(arr)
	quickSorted := quickSortGo(arr)
	sortMatch := true
	for i := range shellSorted { if shellSorted[i] != quickSorted[i] { sortMatch = false; break } }
	time.Sleep(time.Duration(10+rng.Intn(80)) * time.Millisecond)

	// Phase 7: Polynomial evaluation (Horner vs direct)
	coeffs := []float64{1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1, 3, -2, 1, 4}
	polyMax, hornerMax := math.Inf(-1), math.Inf(-1)
	for i := -80; i <= 80; i++ {
		x := float64(i) * 0.1
		if v := polyEvalGo(coeffs, x); v > polyMax { polyMax = v }
		if v := hornerEval(coeffs, x); v > hornerMax { hornerMax = v }
	}
	time.Sleep(time.Duration(10+rng.Intn(60)) * time.Millisecond)

	// Phase 8: DJB2 + FNV1a hash chains 500 iterations
	hDJB := djb2Go("bench-go-start")
	hFNV := fnv1aGo("bench-go-start")
	for i := 0; i < 500; i++ {
		hDJB = djb2Go(fmt.Sprintf("%d", hDJB))
		hFNV = fnv1aGo(fmt.Sprintf("%d", hFNV))
	}
	time.Sleep(time.Duration(10+rng.Intn(50)) * time.Millisecond)

	// Phase 9: Collatz max steps for 1..500
	collatzMax, collatzN := 0, 0
	for n := 1; n <= 500; n++ {
		if s := collatzGo(n); s > collatzMax { collatzMax = s; collatzN = n }
	}

	// Phase 10: GCD/LCM table for first 20 primes
	gcdSum, lcmMod := 0, 1
	for i := 0; i < 20 && i < len(primes)-1; i++ {
		gcdSum += gcdGo(primes[i], primes[i+1])
		lcmMod = lcmGo(lcmMod, primes[i]) % 1000000007
	}
	time.Sleep(time.Duration(10+rng.Intn(40)) * time.Millisecond)

	// Phase 11: Twin primes and cousin primes
	twins, cousins := 0, 0
	for i := 0; i < len(primes)-1; i++ {
		diff := primes[i+1] - primes[i]
		if diff == 2 { twins++ }
		if diff == 4 { cousins++ }
	}

	// Phase 12: String operations — build prime list string and count digits
	var sb strings.Builder
	for i, p := range primes { if i >= 100 { break }; fmt.Fprintf(&sb, "%d,", p) }
	primeStr := sb.String()
	digitCount := 0
	for _, c := range primeStr { if c >= '0' && c <= '9' { digitCount++ } }

	result := map[string]interface{}{
		"language":      "go",
		"delay_ms":      delayMs,
		"prime_count":   len(primes),
		"prime_sum":     primeSum,
		"mr_count":      mrCount,
		"fib55":         entries[7].Fib,
		"lucas55":       entries[7].Lucas,
		"mat_sum":       math.Round(matSum*10000) / 10000,
		"sort_match":    sortMatch,
		"poly_max":      math.Round(polyMax*10000) / 10000,
		"horner_max":    math.Round(hornerMax*10000) / 10000,
		"djb2_final":    hDJB,
		"fnv1a_final":   hFNV,
		"collatz_max":   collatzMax,
		"collatz_n":     collatzN,
		"twin_primes":   twins,
		"cousin_primes": cousins,
		"gcd_sum":       gcdSum,
		"lcm_mod":       lcmMod,
		"digit_count":   digitCount,
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(result)
}
"""

# ── Python ────────────────────────────────────────────────────────────────────
PYTHON_CODE = r"""import time
import math
import random

def sieve(limit):
    s = [True] * (limit + 1); s[0] = s[1] = False
    i = 2
    while i * i <= limit:
        if s[i]:
            j = i * i
            while j <= limit: s[j] = False; j += i
        i += 1
    return [i for i in range(2, limit+1) if s[i]]

def fib(n):
    if n <= 1: return n
    a, b = 0, 1
    for _ in range(n - 1): a, b = b, a + b
    return b

def mat_mul(A, B, n):
    C = [[0.0]*n for _ in range(n)]
    for i in range(n):
        for k in range(n):
            for j in range(n):
                C[i][j] += A[i][k] * B[k][j]
    return C

def make_matrix(n, seed):
    return [[(((i*n+j+seed)%17)*0.1+1.0) for j in range(n)] for i in range(n)]

def shell_sort(arr):
    a = arr[:]
    gap = len(a) // 2
    while gap > 0:
        for i in range(gap, len(a)):
            tmp = a[i]; j = i
            while j >= gap and a[j-gap] > tmp: a[j] = a[j-gap]; j -= gap
            a[j] = tmp
        gap //= 2
    return a

def poly_eval(coeffs, x):
    result, power = 0.0, 1.0
    for c in coeffs: result += c * power; power *= x
    return result

def djb2(s):
    h = 5381
    for c in s: h = ((h << 5) + h + ord(c)) & 0x7fffffff
    return h

def collatz(n):
    steps = 0
    while n != 1: n = n // 2 if n % 2 == 0 else 3 * n + 1; steps += 1
    return steps

def lcg(s): return ((s * 1664525 + 1013904223) & 0x7fffffff)

def main():
    start = time.time()

    # Random delay 250ms-1500ms
    seed = int(start * 1000) & 0xffff
    delay_ms = 250 + lcg(seed) % 1250
    time.sleep(delay_ms / 1000.0)

    # Phase 1: Sieve primes up to 2000
    primes = sieve(2000)
    prime_sum = sum(primes)
    time.sleep(0.05 + (lcg(len(primes)) % 200) / 1000.0)

    # Phase 2: Fibonacci batch
    fibs = {n: fib(n) for n in range(20, 51, 5)}
    time.sleep(0.03 + (lcg(len(fibs) * 7) % 150) / 1000.0)

    # Phase 3: Matrix 20x20
    A = make_matrix(20, 2)
    B = make_matrix(20, 6)
    C = mat_mul(A, B, 20)
    mat_sum = sum(v for row in C for v in row)
    time.sleep(0.02 + (lcg(int(mat_sum) & 0xffff) % 100) / 1000.0)

    # Phase 4: Shell sort 500 elements
    s2 = 33
    arr = []
    for _ in range(500): s2 = lcg(s2); arr.append(s2 % 10000)
    sorted_arr = shell_sort(arr)
    time.sleep(0.01 + (lcg(sorted_arr[0]) % 80) / 1000.0)

    # Phase 5: Polynomial evaluation
    coeffs = [1, -3, 2, 5, -1, 4, -2, 1, 3, -1, 2, 1, -3, 2, 5, -1]
    poly_vals = [poly_eval(coeffs, x * 0.25) for x in range(-20, 21)]
    poly_max = max(poly_vals)
    time.sleep(0.01 + (lcg(len(primes)) % 60) / 1000.0)

    # Phase 6: Hash chain 500 iterations
    h = djb2("bench-python-start")
    chain = [h]
    for _ in range(500): h = djb2(str(h)); chain.append(h)

    # Phase 7: Collatz max steps for 1..300
    collatz_max = max(collatz(n) for n in range(1, 301))
    time.sleep(0.01 + (lcg(chain[-1] & 0xffff) % 50) / 1000.0)

    # Phase 8: Sum of squares (1..200)
    sq_sum = sum(i * i for i in range(1, 201))

    # Phase 9: GCD / LCM chain on primes
    def gcd(a, b):
        while b: a, b = b, a % b
        return a
    gcds = [gcd(primes[i], primes[i+1]) for i in range(min(50, len(primes)-1))]

    elapsed_ms = round((time.time() - start) * 1000)

    return {
        "language":    "python",
        "delay_ms":    delay_ms,
        "elapsed_ms":  elapsed_ms,
        "prime_count": len(primes),
        "prime_sum":   prime_sum,
        "fib45":       fibs[45],
        "mat_sum":     round(mat_sum, 4),
        "sort_ok":     sorted_arr[0] <= sorted_arr[-1],
        "poly_max":    round(poly_max, 4),
        "hash_final":  chain[-1],
        "collatz_max": collatz_max,
        "sq_sum":      sq_sum,
        "gcd_sum":     sum(gcds),
    }
"""

functions = [
    ("bench-node",   "nodejs", NODE_CODE),
    ("bench-php",    "php",    PHP_CODE),
    ("bench-ruby",   "ruby",   RUBY_CODE),
    ("bench-perl",   "perl",   PERL_CODE),
    ("bench-go",     "go",     GO_CODE),
    ("bench-python", "python", PYTHON_CODE),
]

print("=== Удаляем старые bench-функции ===")
for name, _, _ in functions:
    result = subprocess.run(
        ["curl", "-s", "-X", "DELETE", f"{BASE}/functions/{name}",
         "-H", f"X-Test-Sub: {SUB}"],
        capture_output=True, text=True
    )
    print(f"  DELETE {name}: {result.stdout.strip()[:80]}")

print("\n=== Создаём тяжёлые bench-функции (~10KB) ===")
for name, lang, code in functions:
    payload = json.dumps({"name": name, "language": lang, "code": code, "ttl": "2h"})
    size_kb = len(code) / 1024
    result = subprocess.run(
        ["curl", "-s", "-X", "POST", f"{BASE}/functions",
         "-H", f"X-Test-Sub: {SUB}", "-H", "Content-Type: application/json",
         "-d", payload],
        capture_output=True, text=True
    )
    try:
        resp = json.loads(result.stdout)
        route = resp.get("route", "?")
        print(f"  {name} ({size_kb:.1f}KB): {route}")
    except Exception as e:
        print(f"  {name}: PARSE ERROR {result.stdout[:150]}")