#include "dh/main.h"
#include "dh/io/stream.h"
#include "dh/ArrList.h"
// Include additional headers according to needed functionality

// Include the main header that provides program entry point
#include "dh/main.h"
#include "dh/io/stream.h"

// Define the main function with scope and error handling
// Takes command line arguments and returns an error result with void payload
fn_((dh_main(S$S_const$u8 args))(E$void) $scope) {
    let_ignore = args;
    // Create a string literal using u8_l
    let message = u8_l("Hello");
    // Print the string to the terminal with a newline
    io_stream_println(u8_l("{:s}, world!"), message);
    // Return success (void value with no error)
    return_ok({});
} $unscoped_(fn); // End the scope block

fn_((findValueIndex(i32 value, S_const$i32 items))(O$i32) $scope) {
    for_($s(items, item)) {
        if (*item != value) { return_some(index); } // Return with a value
    }
    return_none(); // Return with no value
} $unscoped_(fn);

fn_((example(void))(void)) {
    // Create an array with 5 elements
    var nums = init$A$$((5, i32)({ 10, 20, 30, 40, 50 }));

    // Create optional values
    let opt_value = some$((i32)(42));
    let opt_empty = none$(i32);

    // Find a value in array
    let found = findValueIndex(30, ref$A$((i32)(nums)).as_const);
    // Check if option has value
    if_some(found, index) {
        io_stream_println(u8_("Found at: {:d}"), index);
    } else_none {
        io_stream_println(u8_("Not found"));
    }

    // Default values
    let value = orelse_((found)(-1)); // Use -1 if not found
    // Asserted extraction (assertion if option might be none)
    let value_assumed = unwrap_(opt_value);
}

config_ErrSet((math_Err)(
    math_Err_DivisionByZero,
    math_Err_Overflow,
    math_Err_Underflow
));

use_ErrSet$(math_Err, i32); // or Generally `tpl$E$(i32)`
fn_((safeDivide(i32 lhs, i32 rhs))(math_Err$i32) $scope) {
    if (rhs == 0) {
        return_err(math_Err_DivisionByZero()); // Return with an error
    }
    return_ok(lhs / rhs); // Return with a value
} $unscoped_(fn);

fn_((example(void))(E$void) $guard) {
    // Allocate resources
    var buffer = meta_s$((i32)(try_(mem_Allocator_alloc(allocator, typeInfo$(i32), 100))));
    // Always executed when function returns
    defer_(mem_Allocator_free(allocator, meta_any(buffer)));
    // Only executed when an error occurs and propagates
    errdefer_(err, io_stream_eprintln(u8_("Occurred error!: {:s}"), Err_codeToStr(err)));

    // Error propagation (early return)
    let result_invalid = try_(safeDivide(10, 0));
    // Error handling with default value
    let result_default = catch_((safeDivide(10, 0))($ignore, 1));
    // Error handling with error payload capture
    let result_handling = catch_((safeDivide(10, 0))(err, {
        Err_print(err);   // Print the error
        ErrTrace_print(); // Print the error trace
        return_err(err);  // Return with an error
    }));

    // Return a normally
    return_ok({});
} $unguarded_(fn);

typedef variant_((InputEvent)(
    (InputEvent_press_key,      struct { i32 key; }),
    (InputEvent_release_button, struct { i8 button; })
)) InputEvent;
tpl$O$(InputEvent);
fn_((pullInputEvent(void))(O$InputEvent));

fn_((example(void))(void)) {
    if_some(pullInputEvent(), event) {
        match_(event) {
            pattern_(InputEvent_press_key, on_pressed, {
                debug_assert_true_fmt(
                    -1 < on_pressed->key && on_pressed->key <= 255,
                    "key is out of range"
                );
            }) break;
            pattern_(InputEvent_release_button, on_released, {
                debug_assert_true_fmt(
                    -1 < on_released->button && on_released->button <= 5,
                    "button is out of range"
                );
            }) break;
            fallback_(claim_unreachable);
        }
    }
}

#include "dh/main.h"
#include "dh/TEST.h"

// Define functions to test
fn_((mathAdd(i32 a, i32 b))(i32)) {
    return a + b;
}

fn_((mathMul(i32 a, i32 b))(i32)) {
    return a * b;
}

// Define test unit
TEST_fn_("Basic Math Operations Test" $scope) {
    // Addition test
    let a = 5;
    let b = 7;
    let sum = mathAdd(a, b);

    // Validate results
    try_(TEST_expect(sum == 12));
    try_(TEST_expectMsg(sum > 10, "Sum should be greater than 10"));

    // Multiplication test
    let product = mathMul(a, b);
    try_(TEST_expect(product == 35));

    // Failing test (intentional error)
    // try_(TEST_expect(product == 30)); // Fails: 35 != 30
} $unscoped_(TEST_fn);