# Float to String
#
# `0.1 + 0.2` printed as its shortest round-trip form, the same digits CRuby
# gives you everywhere. CRuby computes this with its own dtoa rather than the C
# library, so it holds on wasm too.
#
# Ported from ruby_wasm_builder challenges/float (introduced 0.1.0, ported at 0.6.0).
def float_main
  (0.1 + 0.2).to_s
end

# External enumerators
#
# `Enumerator#next` runs the iteration in a Fiber and switches back and forth
# with it. Fibers switch stacks, which on wasm means unwinding and rewinding the
# call stack, and this shows that it works inside a canister.
#
# Ported from ruby_wasm_builder challenges/enumerator (introduced 0.1.0, ported at 0.6.0).
def enumerator_main
  e = [10, 20, 30].each
  [e.next, e.next, e.next].sum.to_s
end

# Raise and rescue
#
# A `raise` caught by an ordinary Ruby `rescue`. Exceptions unwind through the
# wasm call stack and land in the handler, just as on a desktop Ruby.
#
# Ported from ruby_wasm_builder challenges/raise (introduced 0.1.0, ported at 0.6.0).
module RaisePort
  class ChallengeError < StandardError; end
end

def raise_main
  raise RaisePort::ChallengeError, "raised"
rescue RaisePort::ChallengeError => e
  "rescued #{e.class.name.split('::').last}: #{e.message}"
end

# Deep recursion
#
# Three hundred frames deep, each one through a C method (`map` calls the block
# from C), so every level is a C frame as well as a Ruby one. 300 is a floor
# that holds with room to spare: past roughly 650 levels a call traps rather
# than raising SystemStackError, and the IC rolls the call back.
#
# Ported from ruby_wasm_builder challenges/recursion (introduced 0.2.0, ported at 0.6.0).
def recursion_depth(n) = n.zero? ? 0 : [n - 1].map { |m| recursion_depth(m) }.first + 1

def recursion_main
  recursion_depth(300).to_s
end

# Garbage collection
#
# An allocation heavy enough to force a collection, with live objects that must
# survive it intact. A broken collector would free or move a live object, and
# it would then no longer read back correctly.
#
# Ported from ruby_wasm_builder challenges/gc (introduced 0.1.0, ported at 0.6.0).
def gc_main
  before = GC.count
  kept = Array.new(1_000) { |i| "kept-#{i}" }
  200_000.times { |i| "garbage-#{i}" }
  intact = kept.each_with_index.all? { |s, i| s == "kept-#{i}" }
  "collected: #{GC.count > before}, survivors intact: #{intact}"
end

# Objects that clean themselves up
#
# One call builds a 50,000-string object five times in a row, dropping each one
# before building the next, and reports the live-object count after every round.
# If nothing were reclaimed the count would climb by about 50,000 each round; it
# stays flat instead. Nothing here frees memory or asks for a collection: the
# Ruby runtime collects on its own. (A Rust canister frees an object when its
# owner goes out of scope, by rule. Ruby does it by collecting.)
#
# What did not work: showing a single object appear and then vanish. On this
# build the most recent large object is still counted after it is dropped, even
# after more collections, a forced GC, a deep call to scrub the stack, or a
# separate call. Earlier objects are reclaimed, which is why the rounds are flat.
# What holds the last one is not identified. The counts are also approximate,
# since they include whatever else the VM holds.
#
# Showcase for ruby_wasm_builder challenges/gc_state (introduced 0.1.0, written for 0.6.0).
GC_LIFECYCLE_ROUNDS = 5

def gc_lifecycle_live = GC.stat(:heap_live_slots)

# Built inside its own method so nothing in the caller refers to it afterwards.
def gc_lifecycle_build = Array.new(50_000) { |i| "object-#{i}" }.size

def gc_lifecycle
  before = gc_lifecycle_live
  collections = GC.count
  rounds = Array.new(GC_LIFECYCLE_ROUNDS) do
    gc_lifecycle_build
    gc_lifecycle_live
  end
  "live objects: #{before} before; after each round: #{rounds.join(', ')}; " \
    "the runtime ran #{GC.count - collections} collection(s) by itself"
end

# Objects kept across messages and collections
#
# Each call adds a thousand objects to a global and forces a collection, and
# every object from the earlier calls must still read back intact. A call is a
# fresh entry into the VM, so this checks the collector still finds what
# previous messages left behind.
# Stateful: yes
#
# Ported from ruby_wasm_builder challenges/gc_state (introduced 0.1.0, ported at 0.6.0).
$gc_state_kept = []

def gc_state_main
  1_000.times { $gc_state_kept << "kept-#{$gc_state_kept.size}" }
  GC.start
  intact = $gc_state_kept.each_with_index.all? { |s, i| s == "kept-#{i}" }
  "#{$gc_state_kept.size} kept, intact: #{intact}"
end

# The standard library
#
# `Set` is loaded from the Ruby standard library on first use. The base module
# ships the standard library, so a canister can `require` it without carrying
# its own copy.
#
# Ported from ruby_wasm_builder challenges/stdlib (introduced 0.2.0, ported at 0.6.0).
def stdlib_main
  Set.new([1, 2, 2, 3]).size.to_s
end

# An application of more than one file
#
# One Ruby file loads a second one beside it with `require_relative`. A canister
# is a directory of Ruby, not a single script.
#
# Ported from ruby_wasm_builder challenges/require_relative (introduced 0.1.0, ported at 0.6.0).
require_relative "require_relative/greeting"

def require_relative_main
  Greeting.hello
end

# Files read as text
#
# A file read with no encoding is text: `Encoding.default_external` is UTF-8,
# the locale's, as `ruby` sets it under a UTF-8 locale, and so are the
# `locale` and `filesystem` pseudo-encodings. `write` stores a line with
# accents, an em dash and kanji as raw bytes; `read` gets it back as UTF-8 text,
# so its length counts 25 characters (not 32 bytes), it equals the literal, and
# a UTF-8 Regexp finds "José" at character 9. Reading the same file as bytes is
# still ASCII-8BIT, as a Candid blob is. Up to 0.8.0 it was ASCII-8BIT: `env`
# raised and `read` failed with Encoding::CompatibilityError. The setting is
# made at every boot, so the command below shows it again after an upgrade.
# Methods: env, write, read, binread
# Cli: yes
#
# Ported from ruby_wasm_builder challenges/default_external (introduced 0.9.0, ported at 0.10.0).
DEFAULT_EXTERNAL_TEXT = "Aklatan: José Rizal — 日本\n"
DEFAULT_EXTERNAL_PATH = File.join(IC::DATA_DIR, "default_external_aklatan.txt")

def default_external_env
  "external=#{Encoding.default_external.name} internal=#{Encoding.default_internal&.name || 'nil'} " \
    "locale=#{Encoding.find('locale').name} filesystem=#{Encoding.find('filesystem').name}"
end

def default_external_write
  File.binwrite(DEFAULT_EXTERNAL_PATH, DEFAULT_EXTERNAL_TEXT.b)
  "wrote #{File.size(DEFAULT_EXTERNAL_PATH)} bytes"
end

def default_external_read
  s = File.read(DEFAULT_EXTERNAL_PATH)
  "#{s.encoding.name} #{s.length} #{s == DEFAULT_EXTERNAL_TEXT} #{s =~ /José/}"
end

def default_external_binread = File.binread(DEFAULT_EXTERNAL_PATH).encoding.name

# State kept across messages
#
# Each call is one update message to the same canister, and the Ruby heap
# carries on between them, so the count goes up by one every time. State in a
# Ruby global is shared by every visitor and is lost when the canister is
# upgraded.
# Stateful: yes
#
# Ported from ruby_wasm_builder challenges/counter (introduced 0.1.0, ported at 0.6.0).
$counter_count = 0

def counter_main
  ($counter_count += 1).to_s
end

# Declared methods
#
# Two updates, each served by the top-level method of its name and sharing one
# VM. `bump` counts; `total` reads the count and replies in a different shape.
# The shared count shows one VM, and the different replies show one method per
# export.
# Stateful: yes
# Methods: bump, total
#
# Ported from ruby_wasm_builder challenges/declared_methods (introduced 0.3.0, ported at 0.6.0).
$declared_methods_n = 0

def declared_methods_bump = ($declared_methods_n += 1).to_s

def declared_methods_total = "total=#{$declared_methods_n}"

# A bounded refusal
#
# A refusal's text is cut to at most 1,024 bytes, on a character boundary, and
# ends with " [truncated]". Here the reason is 1,001 `a`s followed by ten
# emoji, so the cut lands inside the first emoji and backs up to keep it whole
# or leave it out. A call afterwards still works: the refusal rolled back
# cleanly.
# Outcome: refusal
# Methods: long_refusal, read
#
# Ported from ruby_wasm_builder challenges/trap_text_bound (introduced 0.3.0, ported at 0.6.0).
def trap_text_bound_long_refusal = IC.refuse("a" * 1001 + "\u{1F600}" * 10)

def trap_text_bound_read = "ok"

# What survives an upgrade
#
# Each call counts twice: in a Ruby global (the heap) and in a file. Upgrade the
# canister yourself with the command below and call again. The heap is discarded
# by an upgrade, so it starts again at 1; the file lives in stable memory, so
# its count carries on. State you want to keep belongs in a file.
# Stateful: yes
# Cli: yes
#
# Ported from ruby_wasm_builder challenges/upgrade (introduced 0.3.0, ported at 0.6.0).
UPGRADE_FILE = File.join(IC::DATA_DIR, "upgrade_n")

$upgrade_heap = 0

def upgrade_main
  $upgrade_heap += 1
  n = (File.exist?(UPGRADE_FILE) ? File.read(UPGRADE_FILE).to_i : 0) + 1
  File.write(UPGRADE_FILE, n.to_s)
  "n=#{n} heap=#{$upgrade_heap}"
end

# Demo-scale state survives an upgrade
#
# 1,000 files of 1 KiB and a 10,000-line log are written in batches, then the
# canister is upgraded. Every boot, including the upgrade's, rebuilds an index
# of all of them, and `check` reports how many files and lines are intact and
# how many each index found at the last boot: 0 before an upgrade, 1000 and
# 10000 after. Updating one file and appending to a log are single cheap calls.
# Load 10 batches of each (×10 does that for you), then upgrade with the command
# below and `check` again. The log stops at 10,100 lines so it can't grow forever.
# Stateful: yes
# Methods: load_units, append_lines, check, rewrite_one, append_one
# Repeat: load_units, append_lines
# Cli: yes
#
# Ported from ruby_wasm_builder challenges/persist_both (introduced 0.4.0, ported at 0.6.0).
PERSIST_BOTH_UNITS      = File.join(IC::DATA_DIR, "persist_both_units")
PERSIST_BOTH_LOG        = File.join(IC::DATA_DIR, "persist_both_log.txt")
PERSIST_BOTH_PATTERN    = "abcdefghijklmnopqrstuvwxyz0123456789"
PERSIST_BOTH_FILES      = 1000
PERSIST_BOTH_UNIT_BATCH = 100
PERSIST_BOTH_LINES      = 10_000
PERSIST_BOTH_LINES_MAX  = 10_100
PERSIST_BOTH_LINE_BATCH = 1_000
PERSIST_BOTH_WIDTH      = 256

def persist_both_rotated(i)
  r = i % PERSIST_BOTH_PATTERN.size
  PERSIST_BOTH_PATTERN[r..] + PERSIST_BOTH_PATTERN[0, r]
end

def persist_both_unit_name(i) = format("unit-%04d.dat", i)
def persist_both_unit_bytes(i) = format("%04d:", i) + (persist_both_rotated(i) * 29)[0, 1019]
def persist_both_unit_names = Dir.exist?(PERSIST_BOTH_UNITS) ? Dir.children(PERSIST_BOTH_UNITS) : []

def persist_both_log_line(i) = format("%05d ", i) + (persist_both_rotated(i) * 7)[0, 249] + "\n"
def persist_both_lines_written = File.exist?(PERSIST_BOTH_LOG) ? File.size(PERSIST_BOTH_LOG) / PERSIST_BOTH_WIDTH : 0

# Both indexes on every boot; no call changes either.
$persist_both_unit_index = {}
persist_both_unit_names.each { |n| $persist_both_unit_index[n] = File.read(File.join(PERSIST_BOTH_UNITS, n))[0, 4] }
$persist_both_line_index = {}
if File.exist?(PERSIST_BOTH_LOG)
  File.foreach(PERSIST_BOTH_LOG).with_index { |line, n| $persist_both_line_index[line[0, 5]] = n }
end

def persist_both_load_units
  Dir.mkdir(PERSIST_BOTH_UNITS) unless Dir.exist?(PERSIST_BOTH_UNITS)
  from = persist_both_unit_names.size
  (from...[from + PERSIST_BOTH_UNIT_BATCH, PERSIST_BOTH_FILES].min).each do |i|
    File.write(File.join(PERSIST_BOTH_UNITS, persist_both_unit_name(i)), persist_both_unit_bytes(i))
  end
  "files=#{persist_both_unit_names.size}"
end

def persist_both_append_lines
  from = persist_both_lines_written
  File.open(PERSIST_BOTH_LOG, "a") do |f|
    f.write((from...[from + PERSIST_BOTH_LINE_BATCH, PERSIST_BOTH_LINES].min).map { |i| persist_both_log_line(i) }.join)
  end
  "lines=#{persist_both_lines_written}"
end

def persist_both_check
  files = (0...PERSIST_BOTH_FILES).count do |i|
    path = File.join(PERSIST_BOTH_UNITS, persist_both_unit_name(i))
    File.exist?(path) && File.read(path) == persist_both_unit_bytes(i)
  end
  lines = File.exist?(PERSIST_BOTH_LOG) ? File.read(PERSIST_BOTH_LOG).lines : []
  intact = lines.each_with_index.count { |line, i| line == persist_both_log_line(i) }
  "files=#{persist_both_unit_names.size} intact=#{files} lines=#{lines.size} intact=#{intact} " \
    "boot_index=#{$persist_both_unit_index.size}/#{$persist_both_line_index.size}"
end

def persist_both_rewrite_one
  File.write(File.join(PERSIST_BOTH_UNITS, persist_both_unit_name(500)), persist_both_unit_bytes(500))
  "rewrote unit-0500"
end

def persist_both_append_one
  IC.refuse("the log is full (#{PERSIST_BOTH_LINES_MAX} lines)") if persist_both_lines_written >= PERSIST_BOTH_LINES_MAX
  File.open(PERSIST_BOTH_LOG, "a") { |f| f.write(persist_both_log_line(persist_both_lines_written)) }
  "lines=#{persist_both_lines_written}"
end