#!/usr/bin/env bash
# test_heavy.sh — поиск багов: большой код, CPU-нагрузка, большой ответ,
#   архивы из ZIP, быстрые серии invoke, параллельные вызовы,
#   медленные функции, давление по памяти.
#   Все 4 языка: Python, Node.js, Ruby, PHP.
#
# ВАЖНО: Ruby и PHP invoke ранее не тестировались вообще!
# Умеренная нагрузка (кластер небольшой, но нагрузка реальная).
#
# Запуск: bash scripts/test_heavy.sh
# На ВМ: bash ~/terra/fission/scripts/test_heavy.sh
set -uo pipefail

ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
source "${ROOT_DIR}/lib.sh"

RUN_ID=$(mk_run_id)
SUB="livetest@test.local"
TMP=$(mktemp -d)

echo ""
echo "════════════════════════════════════════════════════════"
echo "  test_heavy.sh  run=${RUN_ID}"
echo "════════════════════════════════════════════════════════"

declare -a ALL_FNS=()

cleanup() {
  rm -rf "$TMP" 2>/dev/null || true
  for fn in "${ALL_FNS[@]:-}"; do
    curl -s -X DELETE "${BASE}/functions/${fn}" \
      -H "X-Auth-Token: ${SUB}" >/dev/null 2>&1 || true
  done
}
trap cleanup EXIT

# ─── helpers ───────────────────────────────────────────────────────────────

# reg FN — регистрирует имя функции для cleanup
reg() { ALL_FNS+=("$1"); }

# create_json LANG FN CODE_FILE — создаёт функцию из файла с кодом
create_json() {
  local lang="$1" fn="$2" codefile="$3"
  local code_escaped
  code_escaped=$(cat "$codefile" | json_escape)
  reg "$fn"
  local R
  R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
    -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
    -d "{\"name\":\"${fn}\",\"language\":\"${lang}\",\"code\":${code_escaped}}" 2>/dev/null)
  check_http "$(echo "$R" | tail -1)" "201" "${lang^^} ${fn} CREATE → 201"
}

# invoke_once FN EXPECTED LABEL — один invoke, без retry
invoke_once() {
  local fn="$1" expected="$2" label="$3"
  local resp status raw err
  resp=$(curl -s --max-time 60 -X POST "${BASE}/functions/${fn}/invoke" \
    -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
  status=$(json_field "$resp" status)
  raw=$(json_field "$resp" response_raw)
  err=$(json_field "$resp" error)
  echo "    fn=$fn status=$status raw=$(printf '%s' "$raw" | head -c 100) err=$(printf '%s' "$err" | head -c 80)"
  if [ "$status" = "200" ] && printf '%s' "$raw" | grep -qF "$expected"; then
    pass "$label → 200 + '${expected}'"
    return 0
  else
    fail "$label → status=${status:-?} (ожидали 200 + '${expected}')"
    return 1
  fi
}

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 1: БОЛЬШОЙ КОД — ~100 строк на язык, из inline-кода
# Ищем: лимиты на размер кода, проблемы загрузки, синтаксические баги
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S1: БОЛЬШОЙ КОД (Python / Node.js / Ruby / PHP)"
echo "────────────────────────────────────────────────────────"

FN_BIG_PY="t-big-py-${RUN_ID}"
cat > "${TMP}/big_py.py" << 'PYEOF'
import math, hashlib, json

CONSTS = {f"k{i}": i * 3.14159265 for i in range(20)}

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

def sieve(limit):
    is_p = bytearray([1]) * (limit + 1)
    is_p[0] = is_p[1] = 0
    for i in range(2, int(limit**0.5) + 1):
        if is_p[i]:
            for j in range(i*i, limit+1, i): is_p[j] = 0
    return sum(is_p)

def rot13(s):
    return s.translate(str.maketrans(
        'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM'))

def caesar(s, shift=7):
    res = []
    for c in s:
        if 'a' <= c <= 'z': res.append(chr((ord(c) - 97 + shift) % 26 + 97))
        elif 'A' <= c <= 'Z': res.append(chr((ord(c) - 65 + shift) % 26 + 65))
        else: res.append(c)
    return ''.join(res)

def mat_trace(m):
    return sum(m[i][i] for i in range(len(m)))

def palindrome(s):
    t = s.lower().replace(' ', '')
    return t == t[::-1]

def flatten(lst):
    out = []
    for item in lst:
        if isinstance(item, list): out.extend(flatten(item))
        else: out.append(item)
    return out

def checksum(data):
    return hashlib.sha256(data.encode()).hexdigest()[:16]

def running_sum(lst):
    total = 0; out = []
    for v in lst: total += v; out.append(total)
    return out

def count_distinct(lst):
    return len(set(lst))

def group_by_mod(lst, n):
    g = {i: [] for i in range(n)}
    for v in lst: g[v % n].append(v)
    return {str(k): len(v) for k, v in g.items()}

def pascal_row(n):
    row = [1]
    for i in range(1, n + 1): row.append(row[-1] * (n - i + 1) // i)
    return row

def deduplicate(lst):
    seen = set(); out = []
    for v in lst:
        if v not in seen: seen.add(v); out.append(v)
    return out

def reverse_words(s):
    return ' '.join(s.split()[::-1])

def count_vowels(s):
    return sum(1 for c in s.lower() if c in 'aeiou')

def is_prime(n):
    if n < 2: return False
    if n == 2: return True
    if n % 2 == 0: return False
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        if n % i == 0: return False
    return True

def main(event, context):
    mat = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
    data = list(range(1, 51))
    nested = [[1,[2,3]],[4,[5,[6,7]]],8]
    result = {
        "tag":         "big-code-py-ok",
        "fib_25":      fib(25),
        "primes_50":   sieve(50),
        "rot13":       rot13("Hello Fission"),
        "caesar":      caesar("heavy"),
        "const_sum":   round(sum(CONSTS.values()), 2),
        "mat_trace":   mat_trace(mat),
        "palindrome":  palindrome("racecar"),
        "distinct":    count_distinct([1,2,2,3,3,3,4]),
        "flat_len":    len(flatten(nested)),
        "checksum":    checksum("fission-heavy-test"),
        "rsum_last":   running_sum(data)[-1],
        "pascal_4":    pascal_row(4),
        "dedup_len":   len(deduplicate([1,2,2,3,3,3,4,5,5])),
        "rev_words":   reverse_words("big code python test"),
        "vowels":      count_vowels("fission heavy test"),
        "is_prime_97": is_prime(97),
        "groups_3":    group_by_mod(data[:30], 3),
    }
    return json.dumps(result), 200
PYEOF
create_json "python" "$FN_BIG_PY" "${TMP}/big_py.py"

FN_BIG_NODE="t-big-node-${RUN_ID}"
cat > "${TMP}/big_node.js" << 'JSEOF'
const crypto = require('crypto');
const CONSTS = {};
for (let i = 0; i < 20; i++) CONSTS[`k${i}`] = i * Math.PI;

function fib(n) {
  let a = 0, b = 1;
  for (let i = 1; i < n; i++) { let t = a + b; a = b; b = t; }
  return b;
}
function sieve(limit) {
  const isP = new Uint8Array(limit + 1).fill(1);
  isP[0] = isP[1] = 0;
  for (let i = 2; i * i <= limit; i++)
    if (isP[i]) for (let j = i*i; j <= limit; j += i) isP[j] = 0;
  return isP.reduce((s, v) => s + v, 0);
}
function rot13(s) {
  return s.replace(/[a-zA-Z]/g, c => {
    const b = c <= 'Z' ? 65 : 97;
    return String.fromCharCode((c.charCodeAt(0) - b + 13) % 26 + b);
  });
}
function caesar(s, shift = 7) {
  return s.replace(/[a-zA-Z]/g, c => {
    const b = c <= 'Z' ? 65 : 97;
    return String.fromCharCode((c.charCodeAt(0) - b + shift) % 26 + b);
  });
}
function matTrace(m) { return m.reduce((s, row, i) => s + row[i], 0); }
function palindrome(s) { const t = s.toLowerCase().replace(/ /g, ''); return t === t.split('').reverse().join(''); }
function flatten(arr) { return arr.reduce((a, v) => a.concat(Array.isArray(v) ? flatten(v) : v), []); }
function checksum(d) { return crypto.createHash('sha256').update(d).digest('hex').slice(0, 16); }
function runningSum(arr) { let t = 0; return arr.map(v => (t += v, t)); }
function countDistinct(arr) { return new Set(arr).size; }
function deduplicate(arr) { const s = new Set(); return arr.filter(v => !s.has(v) && s.add(v)); }
function groupByMod(arr, n) { const g = {}; for (let i = 0; i < n; i++) g[i] = 0; arr.forEach(v => g[v % n]++); return g; }
function pascalRow(n) { const r = [1]; for (let i = 1; i <= n; i++) r.push((r[i-1] * (n-i+1) / i) | 0); return r; }
function reverseWords(s) { return s.split(' ').reverse().join(' '); }
function countVowels(s) { return (s.toLowerCase().match(/[aeiou]/g) || []).length; }
function isPrime(n) {
  if (n < 2) return false;
  for (let i = 2; i * i <= n; i++) if (n % i === 0) return false;
  return true;
}

const mat = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]];
const nested = [[1,[2,3]],[4,[5,[6,7]]],8];

module.exports = async function(ctx) {
  const data = Array.from({length: 50}, (_, i) => i + 1);
  const result = {
    tag:        "big-code-node-ok",
    fib_25:     fib(25),
    primes_50:  sieve(50),
    rot13:      rot13("Hello Fission"),
    caesar:     caesar("heavy"),
    const_sum:  Math.round(Object.values(CONSTS).reduce((a,b) => a+b, 0) * 100) / 100,
    mat_trace:  matTrace(mat),
    palindrome: palindrome("racecar"),
    distinct:   countDistinct([1,2,2,3,3,3,4]),
    flat_len:   flatten(nested).length,
    checksum:   checksum("fission-heavy-test"),
    rsum_last:  runningSum(data).at(-1),
    pascal_4:   pascalRow(4),
    dedup_len:  deduplicate([1,2,2,3,3,3,4,5,5]).length,
    rev_words:  reverseWords("big code node test"),
    vowels:     countVowels("fission heavy test"),
    is_prime_97: isPrime(97),
    groups_3:   groupByMod(data.slice(0,30), 3),
  };
  return { status: 200, body: JSON.stringify(result) };
};
JSEOF
create_json "nodejs" "$FN_BIG_NODE" "${TMP}/big_node.js"

FN_BIG_RUBY="t-big-ruby-${RUN_ID}"
cat > "${TMP}/big_ruby.rb" << 'RBEOF'
require 'json'
require 'digest'

CONSTS = (0...20).map { |i| [:"k#{i}", i * Math::PI] }.to_h

def fib(n)
  a, b = 0, 1
  (n - 1).times { a, b = b, a + b }
  b
end

def sieve(limit)
  is_p = Array.new(limit + 1, true)
  is_p[0] = is_p[1] = false
  (2..Math.sqrt(limit).to_i).each do |i|
    next unless is_p[i]
    (i*i..limit).step(i) { |j| is_p[j] = false }
  end
  is_p.count(true)
end

def rot13(s)
  s.tr('a-zA-Z', 'n-za-mN-ZA-M')
end

def caesar(s, shift = 7)
  s.chars.map do |c|
    if    c =~ /[a-z]/ then ((c.ord - 97 + shift) % 26 + 97).chr
    elsif c =~ /[A-Z]/ then ((c.ord - 65 + shift) % 26 + 65).chr
    else  c
    end
  end.join
end

def mat_trace(m)
  m.each_with_index.sum { |row, i| row[i] }
end

def palindrome?(s)
  t = s.downcase.delete(' ')
  t == t.reverse
end

def flatten_nested(lst)
  lst.each_with_object([]) do |item, out|
    item.is_a?(Array) ? out.concat(flatten_nested(item)) : out << item
  end
end

def checksum(data)
  Digest::SHA256.hexdigest(data)[0, 16]
end

def running_sum(arr)
  total = 0
  arr.map { |v| total += v; total }
end

def count_distinct(arr)
  arr.uniq.length
end

def group_by_mod(arr, n)
  (0...n).each_with_object({}) { |i, h| h[i.to_s] = arr.count { |v| v % n == i } }
end

def pascal_row(n)
  row = [1]
  (1..n).each { |i| row << row[-1] * (n - i + 1) / i }
  row
end

def reverse_words(s)
  s.split.reverse.join(' ')
end

def count_vowels(s)
  s.downcase.count('aeiou')
end

def is_prime(n)
  return false if n < 2
  (2..Math.sqrt(n).to_i).none? { |i| n % i == 0 }
end

def handler(ctx)
  mat = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
  data = (1..50).to_a
  nested = [[1,[2,3]],[4,[5,[6,7]]],8]
  result = {
    tag:         "big-code-ruby-ok",
    fib_25:      fib(25),
    primes_50:   sieve(50),
    rot13:       rot13("Hello Fission"),
    caesar:      caesar("heavy"),
    const_sum:   CONSTS.values.sum.round(2),
    mat_trace:   mat_trace(mat),
    palindrome:  palindrome?("racecar"),
    distinct:    count_distinct([1,2,2,3,3,3,4]),
    flat_len:    flatten_nested(nested).length,
    checksum:    checksum("fission-heavy-test"),
    rsum_last:   running_sum(data).last,
    pascal_4:    pascal_row(4),
    rev_words:   reverse_words("big code ruby test"),
    vowels:      count_vowels("fission heavy test"),
    is_prime_97: is_prime(97),
    groups_3:    group_by_mod(data.first(30), 3),
  }
  { statusCode: 200, body: result.to_json }
end
RBEOF
create_json "ruby" "$FN_BIG_RUBY" "${TMP}/big_ruby.rb"

FN_BIG_PHP="t-big-php-${RUN_ID}"
cat > "${TMP}/big_php.php" << 'PHPEOF'
<?php
$CONSTS = [];
for ($i = 0; $i < 20; $i++) $CONSTS["k{$i}"] = $i * M_PI;

function fib($n) {
    $a = 0; $b = 1;
    for ($i = 1; $i < $n; $i++) { $t = $a + $b; $a = $b; $b = $t; }
    return $b;
}
function sieve($limit) {
    $isP = array_fill(0, $limit + 1, true);
    $isP[0] = $isP[1] = false;
    for ($i = 2; $i * $i <= $limit; $i++)
        if ($isP[$i]) for ($j = $i*$i; $j <= $limit; $j += $i) $isP[$j] = false;
    return array_sum(array_map('intval', $isP));
}
function rot13($s) { return str_rot13($s); }
function caesar($s, $shift = 7) {
    $r = '';
    for ($i = 0; $i < strlen($s); $i++) {
        $c = $s[$i];
        if ($c >= 'a' && $c <= 'z') $r .= chr((ord($c) - 97 + $shift) % 26 + 97);
        elseif ($c >= 'A' && $c <= 'Z') $r .= chr((ord($c) - 65 + $shift) % 26 + 65);
        else $r .= $c;
    }
    return $r;
}
function matTrace($m) {
    $s = 0;
    foreach ($m as $i => $row) $s += $row[$i];
    return $s;
}
function palindrome($s) {
    $t = str_replace(' ', '', strtolower($s));
    return $t === strrev($t);
}
function checksumStr($data) { return substr(hash('sha256', $data), 0, 16); }
function runningSum($arr) {
    $t = 0; $out = [];
    foreach ($arr as $v) { $t += $v; $out[] = $t; }
    return $out;
}
function countDistinct($arr) { return count(array_unique($arr)); }
function groupByMod($arr, $n) {
    $g = array_fill(0, $n, 0);
    foreach ($arr as $v) $g[$v % $n]++;
    return $g;
}
function pascalRow($n) {
    $row = [1];
    for ($i = 1; $i <= $n; $i++) $row[] = intdiv($row[$i-1] * ($n-$i+1), $i);
    return $row;
}
function reverseWords($s) { return implode(' ', array_reverse(explode(' ', $s))); }
function countVowels($s) { return preg_match_all('/[aeiou]/i', $s); }
function isPrime($n) {
    if ($n < 2) return false;
    for ($i = 2; $i * $i <= $n; $i++) if ($n % $i === 0) return false;
    return true;
}

function handler($ctx) {
    global $CONSTS;
    $mat = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]];
    $data = range(1, 50);
    $constSum = 0; foreach ($CONSTS as $v) $constSum += $v;
    $rsum = runningSum($data);
    $result = [
        'tag'        => 'big-code-php-ok',
        'fib_25'     => fib(25),
        'primes_50'  => sieve(50),
        'rot13'      => rot13('Hello Fission'),
        'caesar'     => caesar('heavy'),
        'const_sum'  => round($constSum, 2),
        'mat_trace'  => matTrace($mat),
        'palindrome' => palindrome('racecar'),
        'distinct'   => countDistinct([1,2,2,3,3,3,4]),
        'checksum'   => checksumStr('fission-heavy-test'),
        'rsum_last'  => end($rsum),
        'pascal_4'   => pascalRow(4),
        'rev_words'  => reverseWords('big code php test'),
        'vowels'     => countVowels('fission heavy test'),
        'is_prime_97'=> isPrime(97),
        'groups_3'   => groupByMod(array_slice($data, 0, 30), 3),
    ];
    $ctx["response"]->getBody()->write(json_encode($result));
}
PHPEOF
create_json "php" "$FN_BIG_PHP" "${TMP}/big_php.php"

echo ""
echo ">>> S1: invoke больших функций — ждём cold start всех 4 языков..."
for fn_tag in \
  "${FN_BIG_PY}:big-code-py-ok:Python" \
  "${FN_BIG_NODE}:big-code-node-ok:Node.js" \
  "${FN_BIG_RUBY}:big-code-ruby-ok:Ruby" \
  "${FN_BIG_PHP}:big-code-php-ok:PHP"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  (
    if wait_invoke "$SUB" "$fn" "$tag" 20 6; then
      echo "OK"
    else
      echo "FAIL"
    fi
  ) > "${TMP}/s1-${fn}.out" &
done
wait

for fn_tag in \
  "${FN_BIG_PY}:big-code-py-ok:Python" \
  "${FN_BIG_NODE}:big-code-node-ok:Node.js" \
  "${FN_BIG_RUBY}:big-code-ruby-ok:Ruby" \
  "${FN_BIG_PHP}:big-code-php-ok:PHP"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  result=$(cat "${TMP}/s1-${fn}.out" 2>/dev/null || echo "FAIL")
  if [ "$result" = "OK" ]; then
    pass "S1 $label BIG CODE invoke → 200"
  else
    fail "S1 $label BIG CODE invoke — не стабилизировался"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 2: CPU BURN — рекурсивный fib, нагрузка на CPU пода
# Ищем: OOM kill, timeout, зависание пула, медленный poolmgr
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S2: CPU BURN — рекурсивный fib (Python/Node.js/Ruby/PHP)"
echo "────────────────────────────────────────────────────────"

FN_CPU_PY="t-cpu-py-${RUN_ID}"
cat > "${TMP}/cpu_py.py" << 'PYEOF'
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

def main(event, context):
    result = fib(28)
    return "cpu-burn-py:" + str(result), 200
PYEOF
create_json "python" "$FN_CPU_PY" "${TMP}/cpu_py.py"

FN_CPU_NODE="t-cpu-node-${RUN_ID}"
cat > "${TMP}/cpu_node.js" << 'JSEOF'
function fib(n) {
  if (n < 2) return n;
  return fib(n-1) + fib(n-2);
}
module.exports = async function(ctx) {
  return { status: 200, body: "cpu-burn-node:" + fib(35) };
};
JSEOF
create_json "nodejs" "$FN_CPU_NODE" "${TMP}/cpu_node.js"

FN_CPU_RUBY="t-cpu-ruby-${RUN_ID}"
cat > "${TMP}/cpu_ruby.rb" << 'RBEOF'
def fib(n)
  return n if n < 2
  fib(n-1) + fib(n-2)
end

def handler(ctx)
  { statusCode: 200, body: "cpu-burn-ruby:#{fib(25)}" }
end
RBEOF
create_json "ruby" "$FN_CPU_RUBY" "${TMP}/cpu_ruby.rb"

FN_CPU_PHP="t-cpu-php-${RUN_ID}"
cat > "${TMP}/cpu_php.php" << 'PHPEOF'
<?php
function fib($n) {
    if ($n < 2) return $n;
    return fib($n-1) + fib($n-2);
}
function handler($ctx) {
    $ctx["response"]->getBody()->write('cpu-burn-php:' . fib(28));
}
PHPEOF
create_json "php" "$FN_CPU_PHP" "${TMP}/cpu_php.php"

echo ""
echo ">>> S2: invoke CPU-burn функций..."
for fn_tag in \
  "${FN_CPU_PY}:cpu-burn-py:Python" \
  "${FN_CPU_NODE}:cpu-burn-node:Node.js" \
  "${FN_CPU_RUBY}:cpu-burn-ruby:Ruby" \
  "${FN_CPU_PHP}:cpu-burn-php:PHP"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  (
    if wait_invoke "$SUB" "$fn" "$tag" 18 6; then
      echo "OK"
    else
      echo "FAIL"
    fi
  ) > "${TMP}/s2-${fn}.out" &
done
wait

for fn_tag in \
  "${FN_CPU_PY}:cpu-burn-py:Python" \
  "${FN_CPU_NODE}:cpu-burn-node:Node.js" \
  "${FN_CPU_RUBY}:cpu-burn-ruby:Ruby" \
  "${FN_CPU_PHP}:cpu-burn-php:PHP"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  result=$(cat "${TMP}/s2-${fn}.out" 2>/dev/null || echo "FAIL")
  if [ "$result" = "OK" ]; then
    pass "S2 $label CPU BURN invoke → 200"
  else
    fail "S2 $label CPU BURN — не стабилизировался"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 3: БОЛЬШОЙ ОТВЕТ — 50KB body
# Ищем: truncation, proxy memory issues, timeout на больших ответах
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S3: БОЛЬШОЙ ОТВЕТ — 50KB (Python + Node.js)"
echo "────────────────────────────────────────────────────────"

FN_RESP_PY="t-resp-py-${RUN_ID}"
cat > "${TMP}/resp_py.py" << 'PYEOF'
def main(event, context):
    chunk = "FISSION-HEAVY-DATA-" * 100  # 1900 chars
    data = (chunk * 27)[:50000]           # ровно 50000 chars
    return "bigresponse-py-ok:" + data[:20] + "..." + str(len(data)), 200
PYEOF
create_json "python" "$FN_RESP_PY" "${TMP}/resp_py.py"

FN_RESP_NODE="t-resp-node-${RUN_ID}"
cat > "${TMP}/resp_node.js" << 'JSEOF'
module.exports = async function(ctx) {
  const chunk = "FISSION-HEAVY-DATA-".repeat(100);
  const data = (chunk.repeat(27)).slice(0, 50000);
  return { status: 200, body: "bigresponse-node-ok:" + data.slice(0,20) + "..." + data.length };
};
JSEOF
create_json "nodejs" "$FN_RESP_NODE" "${TMP}/resp_node.js"

echo ""
echo ">>> S3: invoke и проверка размера ответа..."
for fn_tag in \
  "${FN_RESP_PY}:bigresponse-py-ok:Python" \
  "${FN_RESP_NODE}:bigresponse-node-ok:Node.js"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  if wait_invoke "$SUB" "$fn" "$tag" 15 6; then
    # Проверяем реальный размер ответа
    RESP=$(curl -s --max-time 60 -X POST "${BASE}/functions/${fn}/invoke" \
      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
    RAW=$(json_field "$RESP" response_raw)
    RAW_LEN=${#RAW}
    echo "    response_raw length = $RAW_LEN chars"
    if [ "$RAW_LEN" -gt 40000 ]; then
      pass "S3 $label BIG RESPONSE size=$RAW_LEN (>40000)"
    else
      fail "S3 $label BIG RESPONSE слишком мал: size=$RAW_LEN"
    fi
  else
    fail "S3 $label BIG RESPONSE — invoke не стабилизировался"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 4: АРХИВЫ ИЗ ZIP — создаём архивы на лету, все 4 языка
# Ищем: баги пути upload vs inline, entrypoint defaults, storagesvc PV
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S4: АРХИВ ИЗ ZIP (Python / Node.js / Ruby / PHP)"
echo "────────────────────────────────────────────────────────"

# --- Создаём ZIP-архивы на лету через python3 ---

# Python archive: main.py (entrypoint по умолчанию: main.main)
python3 - > "${TMP}/arc-py.zip" << 'EOF'
import zipfile, io, sys
buf = io.BytesIO()
code = """import json
def main(event, context):
    return json.dumps({"tag": "archive-py-ok", "fib25": 75025}), 200
"""
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
    zf.writestr('main.py', code)
sys.stdout.buffer.write(buf.getvalue())
EOF

# Node.js archive: main.js (entrypoint: main → файл main.js)
python3 - > "${TMP}/arc-node.zip" << 'EOF'
import zipfile, io, sys
buf = io.BytesIO()
code = """module.exports = async function(ctx) {
  return { status: 200, body: JSON.stringify({ tag: "archive-node-ok", fib25: 75025 }) };
};
"""
pkg = '{"name":"heavy-node","version":"1.0.0"}'
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
    zf.writestr('main.js', code)
    zf.writestr('package.json', pkg)
sys.stdout.buffer.write(buf.getvalue())
EOF

# Ruby archive: handler.rb (entrypoint: handler)
python3 - > "${TMP}/arc-ruby.zip" << 'EOF'
import zipfile, io, sys
buf = io.BytesIO()
code = """require 'json'
def handler(ctx)
  { statusCode: 200, body: JSON.generate({ tag: "archive-ruby-ok", fib25: 75025 }) }
end
"""
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
    zf.writestr('handler.rb', code)
sys.stdout.buffer.write(buf.getvalue())
EOF

# PHP archive: main.php (entrypoint: main.php::handler)
python3 - > "${TMP}/arc-php.zip" << 'EOF'
import zipfile, io, sys
buf = io.BytesIO()
code = """<?php
function handler($ctx) {
    $ctx[\"response\"]->getBody()->write(json_encode(['tag' => 'archive-php-ok', 'fib25' => 75025]));
}
"""
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
    zf.writestr('main.php', code)
sys.stdout.buffer.write(buf.getvalue())
EOF

# Загружаем архивы через multipart POST /functions
declare -A ARC_LANGS=( ["py"]="python" ["node"]="nodejs" ["ruby"]="ruby" ["php"]="php" )
declare -A ARC_TAGS=( ["py"]="archive-py-ok" ["node"]="archive-node-ok" ["ruby"]="archive-ruby-ok" ["php"]="archive-php-ok" )

for lang_short in py node ruby php; do
  fn="t-arc-${lang_short}-${RUN_ID}"
  reg "$fn"
  lang="${ARC_LANGS[$lang_short]}"
  arcfile="${TMP}/arc-${lang_short}.zip"

  R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
    -H "X-Auth-Token: ${SUB}" \
    -F "name=${fn}" \
    -F "language=${lang}" \
    -F "archive=@${arcfile};type=application/zip" 2>/dev/null)
  CODE=$(echo "$R" | tail -1)
  BODY=$(echo "$R" | head -n -1)
  check_http "$CODE" "201" "S4 ${lang_short^^} ARCHIVE upload → 201"
  if [ "$CODE" != "201" ]; then
    echo "    upload error: $(printf '%s' "$BODY" | head -c 200)"
  fi
done

echo ""
echo ">>> S4: invoke архивных функций — ждём cold start..."
for lang_short in py node ruby php; do
  fn="t-arc-${lang_short}-${RUN_ID}"
  tag="${ARC_TAGS[$lang_short]}"
  (
    if wait_invoke "$SUB" "$fn" "$tag" 20 6; then
      echo "OK"
    else
      echo "FAIL"
    fi
  ) > "${TMP}/s4-${fn}.out" &
done
wait

for lang_short in py node ruby php; do
  fn="t-arc-${lang_short}-${RUN_ID}"
  tag="${ARC_TAGS[$lang_short]}"
  result=$(cat "${TMP}/s4-${fn}.out" 2>/dev/null || echo "FAIL")
  if [ "$result" = "OK" ]; then
    pass "S4 ${lang_short^^} ARCHIVE invoke → 200"
  else
    fail "S4 ${lang_short^^} ARCHIVE invoke — не стабилизировался"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 5: БЫСТРЫЕ СЕРИИ — 12 последовательных invoke одной функции
# Ищем: poolmgr reuse bugs, утечки памяти, деградацию latency
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S5: БЫСТРЫЕ СЕРИИ — 12x invoke подряд (Python)"
echo "────────────────────────────────────────────────────────"

FN_RAPID="t-rapid-py-${RUN_ID}"
cat > "${TMP}/rapid_py.py" << 'PYEOF'
import time
_count = 0
def main(event, context):
    global _count
    _count += 1
    return "rapid-ok:{}".format(_count), 200
PYEOF
create_json "python" "$FN_RAPID" "${TMP}/rapid_py.py"

echo ">>> Ждём cold start..."
if wait_invoke "$SUB" "$FN_RAPID" "rapid-ok" 15 5; then
  echo ">>> S5: Запускаем 12 последовательных invoke..."
  RAPID_OK=0
  RAPID_FAIL=0
  LATENCIES=()
  for i in $(seq 1 12); do
    T_START=$(date +%s%3N)
    RESP=$(curl -s --max-time 20 -X POST "${BASE}/functions/${FN_RAPID}/invoke" \
      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
    T_END=$(date +%s%3N)
    LAT=$(( T_END - T_START ))
    STATUS=$(json_field "$RESP" status)
    RAW=$(json_field "$RESP" response_raw)
    echo "    invoke ${i}/12: status=$STATUS raw=$(printf '%s' "$RAW" | head -c 40) latency=${LAT}ms"
    if [ "$STATUS" = "200" ]; then
      RAPID_OK=$((RAPID_OK+1))
      LATENCIES+=("$LAT")
    else
      RAPID_FAIL=$((RAPID_FAIL+1))
    fi
  done
  [ "$RAPID_FAIL" -eq 0 ] && pass "S5 RAPID FIRE: 12/12 invoke → 200" \
                           || fail "S5 RAPID FIRE: ${RAPID_FAIL}/12 упали"
  # Статистика latency
  if [ "${#LATENCIES[@]}" -gt 0 ]; then
    LAT_MIN="${LATENCIES[0]}"; LAT_MAX="${LATENCIES[0]}"
    for lat in "${LATENCIES[@]}"; do
      [ "$lat" -lt "$LAT_MIN" ] && LAT_MIN="$lat"
      [ "$lat" -gt "$LAT_MAX" ] && LAT_MAX="$lat"
    done
    echo "    latency min=${LAT_MIN}ms max=${LAT_MAX}ms"
  fi
else
  fail "S5 RAPID FIRE — cold start не прошёл, тест пропущен"
fi

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 6: ПАРАЛЛЕЛЬНЫЕ ВЫЗОВЫ — 5 параллельных invoke на каждый язык
# Ищем: race conditions, конфликты при pod scheduling, deadlocks
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S6: ПАРАЛЛЕЛЬНЫЕ ВЫЗОВЫ — 5 одновременных invoke × 4 языка"
echo "────────────────────────────────────────────────────────"
PARALLEL_N=5

# Используем уже тёплые функции из S2 (CPU burn — уже invoke'd)
declare -A PAR_FNS=( ["Python"]="$FN_CPU_PY" ["Node.js"]="$FN_CPU_NODE" ["Ruby"]="$FN_CPU_RUBY" ["PHP"]="$FN_CPU_PHP" )
declare -A PAR_TAGS=( ["Python"]="cpu-burn-py" ["Node.js"]="cpu-burn-node" ["Ruby"]="cpu-burn-ruby" ["PHP"]="cpu-burn-php" )

for lang in "Python" "Node.js" "Ruby" "PHP"; do
  fn="${PAR_FNS[$lang]}"
  tag="${PAR_TAGS[$lang]}"
  echo ""
  echo ">>> S6 $lang: $PARALLEL_N параллельных invoke..."
  for i in $(seq 1 "$PARALLEL_N"); do
    (
      RESP=$(curl -s --max-time 60 -X POST "${BASE}/functions/${fn}/invoke" \
        -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
      STATUS=$(json_field "$RESP" status)
      RAW=$(json_field "$RESP" response_raw)
      if [ "$STATUS" = "200" ] && printf '%s' "$RAW" | grep -qF "$tag"; then
        echo "OK" > "${TMP}/par-${lang}-${i}.out"
      else
        echo "FAIL:status=${STATUS}" > "${TMP}/par-${lang}-${i}.out"
      fi
    ) &
  done
  wait

  PAR_OK=0; PAR_FAIL=0
  for i in $(seq 1 "$PARALLEL_N"); do
    result=$(cat "${TMP}/par-${lang}-${i}.out" 2>/dev/null || echo "FAIL:no-file")
    if [ "$result" = "OK" ]; then
      PAR_OK=$((PAR_OK+1))
    else
      PAR_FAIL=$((PAR_FAIL+1))
      echo "    invoke $i: $result"
    fi
  done
  [ "$PAR_FAIL" -eq 0 ] \
    && pass "S6 $lang PARALLEL: ${PARALLEL_N}/${PARALLEL_N} invoke → 200" \
    || fail "S6 $lang PARALLEL: ${PAR_FAIL}/${PARALLEL_N} упали"
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 7: МЕДЛЕННЫЕ ФУНКЦИИ — sleep 6s, Python + Node.js
# Ищем: router timeout, poolmgr idle eviction, 504 под нагрузкой
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S7: МЕДЛЕННЫЕ ФУНКЦИИ — sleep(6s) × Python + Node.js"
echo "────────────────────────────────────────────────────────"

FN_SLOW_PY="t-slow-py-${RUN_ID}"
cat > "${TMP}/slow_py.py" << 'PYEOF'
import time
def main(event, context):
    time.sleep(6)
    return "slow-py-ok", 200
PYEOF
create_json "python" "$FN_SLOW_PY" "${TMP}/slow_py.py"

FN_SLOW_NODE="t-slow-node-${RUN_ID}"
cat > "${TMP}/slow_node.js" << 'JSEOF'
module.exports = async function(ctx) {
  await new Promise(r => setTimeout(r, 6000));
  return { status: 200, body: "slow-node-ok" };
};
JSEOF
create_json "nodejs" "$FN_SLOW_NODE" "${TMP}/slow_node.js"

echo ""
echo ">>> S7: invoke (ждём cold start + 6s sleep)..."
for fn_tag in \
  "${FN_SLOW_PY}:slow-py-ok:Python" \
  "${FN_SLOW_NODE}:slow-node-ok:Node.js"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  T_START=$(date +%s%3N)
  if wait_invoke "$SUB" "$fn" "$tag" 15 8; then
    T_END=$(date +%s%3N)
    LAT=$(( T_END - T_START ))
    pass "S7 $label SLOW(6s) → 200 за ~${LAT}ms total"
    # Повторный invoke (warm pod): должно занять ≥6s
    T2=$(date +%s%3N)
    RESP=$(curl -s --max-time 30 -X POST "${BASE}/functions/${fn}/invoke" \
      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
    T2E=$(date +%s%3N)
    LAT2=$(( T2E - T2 ))
    STATUS=$(json_field "$RESP" status)
    RAW=$(json_field "$RESP" response_raw)
    echo "    warm invoke: status=$STATUS latency=${LAT2}ms raw=$(printf '%s' "$RAW" | head -c 40)"
    if [ "$STATUS" = "200" ] && [ "$LAT2" -ge 5000 ]; then
      pass "S7 $label SLOW warm invoke → 200 latency=${LAT2}ms (≥5s)"
    elif [ "$STATUS" = "200" ]; then
      fail "S7 $label SLOW warm слишком быстро: ${LAT2}ms — sleep не сработал?"
    else
      fail "S7 $label SLOW warm invoke → status=$STATUS"
    fi
  else
    fail "S7 $label SLOW — cold start не прошёл"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
# SECTION 8: ДАВЛЕНИЕ ПО ПАМЯТИ — аллокация 20MB, Python + Node.js
# Ищем: OOM kill на поде, зависание, некорректный ответ
# ═══════════════════════════════════════════════════════════════════════════
echo ""
echo "────────────────────────────────────────────────────────"
echo "  S8: ПАМЯТЬ — аллокация 20MB (Python + Node.js)"
echo "────────────────────────────────────────────────────────"

FN_MEM_PY="t-mem-py-${RUN_ID}"
cat > "${TMP}/mem_py.py" << 'PYEOF'
def main(event, context):
    # Аллоцируем 20MB и суммируем (чтобы не оптимизировалось)
    data = bytearray(20 * 1024 * 1024)
    for i in range(0, len(data), 4096):
        data[i] = i % 256
    checksum = sum(data[i] for i in range(0, len(data), 4096)) % 65536
    return "mem-py-ok:{}:{}".format(len(data), checksum), 200
PYEOF
create_json "python" "$FN_MEM_PY" "${TMP}/mem_py.py"

FN_MEM_NODE="t-mem-node-${RUN_ID}"
cat > "${TMP}/mem_node.js" << 'JSEOF'
module.exports = async function(ctx) {
  const size = 20 * 1024 * 1024;
  const buf = Buffer.alloc(size);
  for (let i = 0; i < size; i += 4096) buf[i] = i % 256;
  let checksum = 0;
  for (let i = 0; i < size; i += 4096) checksum = (checksum + buf[i]) % 65536;
  return { status: 200, body: `mem-node-ok:${size}:${checksum}` };
};
JSEOF
create_json "nodejs" "$FN_MEM_NODE" "${TMP}/mem_node.js"

echo ""
echo ">>> S8: invoke (20MB аллокация)..."
for fn_tag in \
  "${FN_MEM_PY}:mem-py-ok:Python" \
  "${FN_MEM_NODE}:mem-node-ok:Node.js"; do
  fn="${fn_tag%%:*}"; rest="${fn_tag#*:}"; tag="${rest%%:*}"; label="${rest#*:}"
  if wait_invoke "$SUB" "$fn" "$tag" 18 6; then
    pass "S8 $label MEMORY(20MB) → 200"
    # Проверяем что данные в ответе правильные
    RESP=$(curl -s --max-time 30 -X POST "${BASE}/functions/${fn}/invoke" \
      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
    RAW=$(json_field "$RESP" response_raw)
    if printf '%s' "$RAW" | grep -qE "$tag:[0-9]+:[0-9]+"; then
      pass "S8 $label MEMORY ответ содержит checksum: $(printf '%s' "$RAW" | head -c 60)"
    else
      fail "S8 $label MEMORY ответ некорректен: $(printf '%s' "$RAW" | head -c 60)"
    fi
  else
    fail "S8 $label MEMORY(20MB) — не вернулась (OOM kill?)"
  fi
done

# ═══════════════════════════════════════════════════════════════════════════
print_summary