#!/usr/bin/env bash
set -euo pipefail

### Test cases
TEST_CASES=(
  "run_test helloworld.xyw assert_output_equals \$'Hello, World!\\n'"
  "run_test d6.xyw assert_output_in_range 1 6"
  "run_test on-error.xyw assert_output_equals \$'Error: Division by zero.\\n'"
  "run_test print-args.xyw test1 test2 -- assert_output_equals \$'print-args.xim, test1, test2\\n'"
  "run_test factorial8.xyw assert_output_equals \$'120\\n'"
  "run_test factorial16.xyw assert_output_equals \$'5040\\n'"
  "run_test fileops.xyw assert_output_equals \$'This is a test file.\\nIt has multiple lines.\\n'"
  "run_test launcher.xyw assert_output_equals \$'Executing: print-args.xim hello world\\nprint-args.xim, hello, world\\nExecuting: helloworld.xim\\nHello, World!\\nDone!\\n'"
)

### Helper functions

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
EXAMPLES_DIR="$ROOT_DIR/examples"

fail() {
  echo "ERROR: $*" >&2
  exit 1
}

dump_file_if_exists() {
  local label="$1"
  local path="$2"
  if [[ -f "$path" ]]; then
    (tr -d '\r' <"$path" | cat -v >&2 || true)
  fi
}

need_file() {
  local path="$1"
  [[ -f "$path" ]] || fail "Missing file: $path"
}

build_xyw() {
  if command -v make >/dev/null 2>&1; then
    (cd "$ROOT_DIR" && make xyw)
  else
    echo "WARN: 'make' not found; using existing xyw binary if present." >&2
  fi
}

clean_examples_images() {
  # Only clean generated images in examples/.
  # (Keeps repository-wide behavior conservative.)
  shopt -s nullglob
  local images=("$EXAMPLES_DIR"/*.xim)
  shopt -u nullglob

  if ((${#images[@]} > 0)); then
    rm -f "${images[@]}"
  fi
}

find_xyw_bin() {
  if [[ -x "$ROOT_DIR/xyw" ]]; then
    echo "$ROOT_DIR/xyw"
    return 0
  fi
  if [[ -x "$ROOT_DIR/xyw.exe" ]]; then
    echo "$ROOT_DIR/xyw.exe"
    return 0
  fi
  fail "Could not find executable xyw binary (expected $ROOT_DIR/xyw or $ROOT_DIR/xyw.exe)."
}

assemble_in_examples_dir() {
  local xyw_bin="$1"
  local src_basename="$2" # e.g. helloworld.xyw

  need_file "$EXAMPLES_DIR/$src_basename"

  local asm_log="$TMPDIR/assemble.${src_basename%.xyw}.log"
  if ! (cd "$EXAMPLES_DIR" && "$xyw_bin" "$src_basename" >"$asm_log" 2>&1); then
    dump_file_if_exists "Assembly output" "$asm_log"
    fail "Assembly failed for $src_basename"
  fi

  # Show assembler output, but keep this function's stdout reserved for the
  # produced .xim basename (so callers can capture it).
  dump_file_if_exists "Assemble $src_basename" "$asm_log"

  local img_basename="${src_basename%.xyw}.xim"
  need_file "$EXAMPLES_DIR/$img_basename"
  echo "$img_basename"
}

run_image_capture_stdout() {
  local xyw_bin="$1"
  local img_basename="$2" # e.g. helloworld.xim
  local out_file="$3"
  shift 3
  local run_args=("$@")

  need_file "$EXAMPLES_DIR/$img_basename"

  local run_log="$TMPDIR/run.${img_basename}.log"
  #if ! (cd "$EXAMPLES_DIR" && "$xyw_bin" "$img_basename" "${run_args[@]}" </dev/null >"$out_file" 2>"$run_log"); then
  if ! (cd "$EXAMPLES_DIR" && "$xyw_bin" "$img_basename" "${run_args[@]}" >"$out_file" 2>"$run_log"); then
    dump_file_if_exists "Runtime stderr" "$run_log"
    dump_file_if_exists "Runtime stdout" "$out_file"
    fail "Execution failed for $img_basename"
  fi
}

normalize_crlf() {
  local in_file="$1"
  local out_file="$2"

  tr -d '\r' <"$in_file" >"$out_file"
}

### Assertion functions

assert_file_equals() {
  local actual_file="$1"
  local expected_file="$2"

  if ! cmp -s "$actual_file" "$expected_file"; then
    echo "--- Expected (cat -v) ---" >&2
    cat -v "$expected_file" >&2 || true
    echo "--- Actual (cat -v) ---" >&2
    cat -v "$actual_file" >&2 || true
    fail "Output did not match expectation."
  fi
}

assert_output_equals() {
  local stdout_file="$1"
  local expected_string="$2"

  local expected_file
  expected_file="$TMPDIR/expected.$$.${RANDOM}.txt"
  printf '%s' "$expected_string" >"$expected_file"
  assert_file_equals "$stdout_file" "$expected_file"
  rm -f "$expected_file"
}

assert_output_in_range() {
  local stdout_file="$1"
  local min_value="$2"
  local max_value="$3"

  local value
  value="$(tr -d '\n\t ' <"$stdout_file")"

  if [[ ! "$value" =~ ^-?[0-9]+$ ]]; then
    echo "--- Actual (cat -v) ---" >&2
    cat -v "$stdout_file" >&2 || true
    fail "Output is not an integer: '$value'"
  fi

  if (( value < min_value || value > max_value )); then
    echo "--- Actual (cat -v) ---" >&2
    cat -v "$stdout_file" >&2 || true
    fail "Output out of range (expected ${min_value}..${max_value}): $value"
  fi
}

### Test runner

# Usage: run_test src.xyw [run_args...] -- assert_fn [assert_args...]
# If no '--' is provided, the second argument is treated as assert_fn.
run_test() {
  local src_basename="$1"
  shift

  local run_args=()
  local assert_fn=""
  local assert_args=()

  # Parse arguments: collect run_args until '--', then assert_fn and assert_args
  while (($# > 0)); do
    if [[ "$1" == "--" ]]; then
      shift
      break
    fi
    run_args+=("$1")
    shift
  done

  # If we found '--', remaining args are assert_fn + assert_args
  # Otherwise, run_args[0] is the assert_fn and rest are assert_args
  if (($# > 0)); then
    assert_fn="$1"
    shift
    assert_args=("$@")
  else
    # No '--' found; first element of run_args is assert_fn
    if ((${#run_args[@]} == 0)); then
      fail "Missing assertion function for $src_basename"
    fi
    assert_fn="${run_args[0]}"
    assert_args=("${run_args[@]:1}")
    run_args=()
  fi

  if ! declare -F "$assert_fn" >/dev/null 2>&1; then
    fail "Assertion function not found: $assert_fn"
  fi

  need_file "$EXAMPLES_DIR/$src_basename"

  local img_basename
  img_basename="$(assemble_in_examples_dir "$XYW_BIN" "$src_basename")"

  local raw_out="$TMPDIR/${src_basename%.xyw}.raw"
  local norm_out="$TMPDIR/${src_basename%.xyw}.norm"

  run_image_capture_stdout "$XYW_BIN" "$img_basename" "$raw_out" "${run_args[@]}"
  normalize_crlf "$raw_out" "$norm_out"

  "$assert_fn" "$norm_out" "${assert_args[@]}"
  echo "-> PASS: $src_basename"
}

### Main

main() {
  need_file "$ROOT_DIR/Makefile"

  build_xyw

  clean_examples_images

  TMPDIR="$(mktemp -d 2>/dev/null || mktemp -d -t xywtest)"
  trap "rm -rf \"$TMPDIR\"" EXIT

  XYW_BIN="$(find_xyw_bin)"

  echo ""

  for tc in "${TEST_CASES[@]}"; do
    eval "$tc"
  done

  echo -e "\n=> All tests passed."
}

main "$@"