# 標準ライブラリ

channel = input::channel()

if (channel == "input") {
    // The main toggle input was triggered
    ...
} else if (channel == "on") {
    // The dedicated "on" input was triggered
    ...
} else if (channel == "off") {
    // The dedicated "off" input was triggered
    ...
}

channel = input::channel()
value = input::value()

// React to a rising edge on a boolean input
if (channel == "input" and value) {
    output::toggle("output")
}

// Read the current temperature from an input
current_temp = input::get("value")

// Use the value in control logic
if (current_temp > 25.0) {
    output::set("cooling", true)
}

// Check the current output state before toggling
prev = output::get("output")
if (prev) {
    std::print("Output is currently ON, turning OFF")
}
output::set("output", !prev)

// Set a boolean output
output::set("output", true)

// Set a numeric output based on calculation
midpoint = config::get("midpoint")
hysteresis = config::get("hysteresis")
value = input::get("value")

if (value >= midpoint + hysteresis) {
    output::set("output", true)
} else if (value <= midpoint - hysteresis) {
    output::set("output", false)
}

channel = input::channel()
value = input::value()

// Toggle the output on a rising edge of the input
if (channel == "input") {
    last_state = state::get("last_input_state")
    if (value and !last_state) {
        output::toggle("output")
    }
    state::set("last_input_state", value)
}

// Use state to detect a rising edge (transition from false to true)
value = input::value()
last_state = state::get("last_input_state")

if (value and !last_state) {
    // Rising edge detected - take action
    output::toggle("output")
}

state::set("last_input_state", value)

// Track the timestamp of the last input change
channel = input::channel()
value = input::value()

if (channel == "input") {
    state::set("last_change_time", time::now())

    // Calculate how long the input was in its previous state
    elapsed = time::now() - state::get("last_change_time")
    if (elapsed > 60) {
        std::print("Input was stable for over a minute")
    }
}

// Read delay configuration in milliseconds
delay_on_ms = config::get("delay_on_ms")
delay_off_ms = config::get("delay_off_ms")

// Use an enum config to select behavior mode
mode = config::get("mode") // Returns 0, 1, 2... based on selected option

if (mode == 0) {
    // First mode logic
    ...
} else if (mode == 1) {
    // Second mode logic
    ...
}

// Read a numeric threshold from config
scale = config::get("scale")
offset = config::get("offset")
result = input::value() * scale + offset
output::set("value", result)

// Define a simple callback handler
extern fn onTimeout() {
    output::set("output", true)
}

// Schedule the callback to fire after a configurable delay
delay_ms = config::get("delay_ms")
callback::set(delay_ms, "onTimeout")

// Callback that chains into the next step
extern fn onSequence(step) {
    if (step == 1) {
        output::set("output", true)
        // Schedule step 2 after a pulse duration
        pulse_ms = config::get("pulse_ms")
        callback::set(pulse_ms, "onSequence", 2)
        return
    }
    if (step == 2) {
        output::set("output", false)
        return
    }
}

// Start the sequence after an initial delay
callback::set(1000, "onSequence", 1)

extern fn onCallback(value) {
    if (value == 1) {
        output::set("output", true)
    } else if (value == 2) {
        output::set("output", false)
    }
}

channel = input::channel()
value = input::value()

if (channel == "input") {
    last = state::get("last_input_state")
    if (value != last) {
        state::set("last_input_state", value)

        // Always clear the previous callback before scheduling a new one
        callback::clear()

        if (value) {
            delay_ms = config::get("delay_on_ms")
            if (delay_ms > 0) {
                callback::set(delay_ms, "onCallback", 1)
            } else {
                output::set("output", true)
            }
        } else {
            delay_ms = config::get("delay_off_ms")
            if (delay_ms > 0) {
                callback::set(delay_ms, "onCallback", 2)
            } else {
                output::set("output", false)
            }
        }
    }
}

// Check if the user PIN code has the required length
user_pin = "1234"
if (str::len(user_pin) == 4) {
    ...
}

// Clean up a command received from an external module
input = "  START  "
command = str::trim(input)

// Now the string is "START" and can be compared safely
if (command == "START") {
    ....
}

room = "Living Room"
temp = "22.5"

// Construct a full status message using multiple arguments
message = str::concat("Status: ", room, " is currently ", temp, "°C")

// Result: "Status: Living Room is currently 22.5°C"

// Count all occurrences of a word
text = "I love apples, apple are my favorite fruit"
count = str::count(text, "apple") // Returns 2

// Count occurrences within a range
data = "abcabcabc"
count = str::count(data, "abc", 1)    // Returns 2 (skips first "abc")
count = str::count(data, "abc", 1, 7) // Returns 1

// Empty substring returns length + 1
count = str::count("hello", "") // Returns 6

// Non-overlapping: "aaaa" contains 2 non-overlapping "aa"
count = str::count("aaaa", "aa") // Returns 2

// Replace all occurrences
result = str::replace("one one was a horse", "one", "three")
// Returns "three three was a horse"

// Replace only the first occurrence
result = str::replace("one one was a horse", "one", "three", 1)
// Returns "three one was a horse"

// Delete by replacing with empty string
result = str::replace("hello", "l", "") // Returns "heo"

// Empty old string inserts between every character
result = str::replace("abc", "", "-") // Returns "-a-b-c-"

// Case 1: Parsing an integer (e.g., brightness level)
brightness = str::number("80") // Returns Integer 80

// Case 2: Parsing a float (e.g., temperature)
temp_str = "21.5"
threshold = str::number(temp_str) // Returns Float 21.5
current_temp = 22

// Using the converted value in logic
if (current_temp > threshold) {
    ...
}

sensorName = "Kitchen_Main"
temp = 22.5
isActive = true

// Format a complex log message without manual concatenation
log = str::fmt("Sensor {} status: Active={}, Value={}°C", sensorName, isActive, temp)

// Result: "Sensor Kitchen_Main status: Active=true, Value=22.5°C"

rawData = "sensor1;25.5;active"

// Initialize the splitter. 'iterator' now holds the state.
iterator = str::split(rawData, ";")

// The iterator is now ready to be consumed by split_next...

data = "RED,GREEN,BLUE"
iterator = str::split(data, ",")

// Loop as long as there are tokens left
while (str::split_has_next(iterator)) {
    ...
    // Safe to call split_next() here
    // color = str::split_next(iterator) 
}

// Scenario: Parsing a command string "SET_COLOR;255;0;0"
commandRaw = "SET_COLOR;255;0;0"
iter = str::split(commandRaw, ";")

// We know the format, so we can extract parts manually
if (str::split_has_next(iter)) {
    cmd = str::split_next(iter)   // "SET_COLOR"
    r = str::split_next(iter)     // "255"
    g = str::split_next(iter)     // "0"
    b = str::split_next(iter)     // "0"
    ...
}

// Create an empty array
empty = array::new()

// Create an array with initial numeric values
temperatures = array::new(21.5, 22.0, 19.8, 23.1)

// Create an array with mixed types
config = array::new("sensor1", 100, true)

// Create an array with string values for room names
rooms = array::new("Living Room", "Kitchen", "Bedroom", "Bathroom")

// Arrays can be used to collect sensor readings over time
readings = array::new()
// Later: array::push(readings, current_value)

// Check the size of an array
temps = array::new(21.5, 22.0, 19.8)
count = array::len(temps) // Returns 3

// Check if an array is empty
data = array::new()
if (array::len(data) == 0) {
    std::print("No data collected yet")
}

// Use length for iteration bounds
sensors = array::new("temp1", "temp2", "humidity")
i = 0
while (i < array::len(sensors)) {
    // Process each sensor...
    i = i + 1
}

temps = array::new(21.5, 22.0, 19.8, 23.1)

// Safe access: check bounds first
index = 2
if (index < array::len(temps)) {
    value = array::get_at(temps, index) // Returns 19.8
    std::print(str::fmt("Temperature at index {}: {}°C", index, value))
}

// Iterate safely over all elements
i = 0
while (i < array::len(temps)) {
    temp = array::get_at(temps, i)
    if (temp > 22.0) {
        std::print(str::fmt("High temperature detected: {}°C", temp))
    }
    i = i + 1
}

// DANGEROUS: Never do this without bounds checking!
// value = array::get_at(temps, 10) // Undefined behavior - may crash!

// Create an array with initial values
temps = array::new(21.5, 22.0, 19.8, 23.1)

// Safe update: check bounds first
index = 1
if (index < array::len(temps)) {
    array::put_at(temps, index, 25.0) // Replace 22.0 with 25.0
}

// Update all values in a loop
i = 0
while (i < array::len(temps)) {
    current = array::get_at(temps, i)
    // Apply a correction factor
    array::put_at(temps, i, current + 0.5)
    i = i + 1
}

// Update specific elements in an array of strings
sensors = array::new("sensor1", "sensor2", "sensor3")
array::put_at(sensors, 0, "temp1")
array::put_at(sensors, 1, "temp2")
array::put_at(sensors, 2, "humidity")

// DANGEROUS: Never do this without bounds checking!
// array::put_at(temps, 10, 99.9) // Undefined behavior - may crash!

// Build an array dynamically by appending values
temps = array::new(21.5)
array::append(temps, 22.0)
array::append(temps, 19.8)
array::append(temps, 23.1)
// temps now contains: [21.5, 22.0, 19.8, 23.1]

// Collect sensor readings over time
readings = array::new(0.0) // Initialize with first reading
array::append(readings, 0.5)
array::append(readings, 1.2)

// Check the new size
count = array::len(readings) // Returns 3

// Append in a loop (e.g., collecting 5 readings)
data = array::new(100)
i = 0
while (i < 4) {
    array::append(data, 100 + i)
    i = i + 1
}
// data now contains: [100, 100, 101, 102, 103]

// Create and populate an array
temps = array::new(21.5, 22.0, 19.8, 23.1)
std::print(str::fmt("Length before clear: {}", array::len(temps))) // 4

// Clear all elements
array::clear(temps)
std::print(str::fmt("Length after clear: {}", array::len(temps))) // 0

// The array can be reused
array::append(temps, 25.0)
array::append(temps, 26.5)
// temps now contains: [25.0, 26.5]

// Useful for periodic data collection - clear old readings
readings = array::new(0.0)
// ... collect readings ...
array::append(readings, 1.5)
array::append(readings, 2.3)
// ... process readings ...
// Reset for next collection cycle
array::clear(readings)

// Create an empty map
config = map::new()

// The map is now ready to store key-value pairs
// map::set(config, "temperature", 22.5)
// map::set(config, "location", "Living Room")

// Maps are also returned by some functions, e.g., HTTP response headers
// In http::on_response callback, 'headers' parameter is a map

config = map::new()

// Check the size of an empty map
count = map::len(config) // Returns 0

// After adding elements, the count increases
// map::set(config, "temperature", 22.5)
// map::set(config, "humidity", 45)
// count = map::len(config) // Returns 2

// Check if a map is empty
if (map::len(config) == 0) {
    std::print("Map is empty")
}

config = map::new()

// Add new key-value pairs
map::set(config, "temperature", 22.5)
map::set(config, "location", "Living Room")
map::set(config, "active", true)

// Update existing value (same type required)
map::set(config, "temperature", 23.0) // OK - float to float

// Store different types under different keys
map::set(config, "sensor_count", 5)      // integer
map::set(config, "sensor_name", "temp1") // string
map::set(config, "enabled", true)        // boolean

config = map::new()
map::set(config, "temperature", 22.5)
map::set(config, "location", "Living Room")

// Safe access: check if key exists first
if (map::contains(config, "temperature")) {
    temp = map::get(config, "temperature")
    std::print(str::fmt("Temperature: {}°C", temp))
}

// Access value when you know the key exists
location = map::get(config, "location") // Returns "Living Room"

// DANGEROUS: Never do this without checking first!
// value = map::get(config, "nonexistent") // Runtime error!

config = map::new()
map::set(config, "temperature", 22.5)
map::set(config, "humidity", 45)
std::print(str::fmt("Size before clear: {}", map::len(config))) // 2

// Clear all entries
map::clear(config)
std::print(str::fmt("Size after clear: {}", map::len(config))) // 0

// The map can be reused
map::set(config, "new_key", "new_value")

config = map::new()
map::set(config, "temperature", 22.5)
map::set(config, "location", "Living Room")

// Check if a key exists
if (map::contains(config, "temperature")) {
    std::print("Temperature key exists")
    temp = map::get(config, "temperature")
}

// Check for non-existent key
if (map::contains(config, "humidity")) {
    humidity = map::get(config, "humidity")
} else {
    std::print("Humidity not set")
}

// Use in conditional logic
key = "location"
if (map::contains(config, key)) {
    value = map::get(config, key)
    std::print(str::fmt("Found {}: {}", key, value))
}

settings = map::new()
map::set(settings, "brightness", 80)
map::set(settings, "color", "warm")
map::set(settings, "enabled", true)

keys = map::keys(settings)
i = 0
while (i < array::len(keys)) {
    key = array::get_at(keys, i)
    value = map::get(settings, key)
    std::print(str::fmt("{} = {}", key, value))
    i = i + 1
}

sensors = map::new()
map::set(sensors, "temp", 22.5)
map::set(sensors, "humidity", 65)

values = map::values(sensors)
i = 0
while (i < array::len(values)) {
    std::print(array::get_at(values, i))
    i = i + 1
}

// Simple JSON object
json_data = """{"temperature": 22.5, "location": "Living Room", "active": true}"""
temp = json::get(json_data, "temperature") // Returns 22.5
location = json::get(json_data, "location") // Returns "Living Room"
active = json::get(json_data, "active") // Returns true

// Nested JSON object
nested = """{"sensor": {"id": "temp1", "value": 23.5, "enabled": false}}"""
sensor_id = json::get(nested, "sensor.id") // Returns "temp1"
sensor_value = json::get(nested, "sensor.value") // Returns 23.5
sensor_enabled = json::get(nested, "sensor.enabled") // Returns false

// Deeply nested structure
deep = """{"building": {"floor": {"room": {"temperature": 22.0}}}}"""
room_temp = json::get(deep, "building.floor.room.temperature") // Returns 22.0

// Getting an array value
json_with_array = """{"readings": [21.5, 22.0, 22.5]}"""
readings = json::get(json_with_array, "readings") // Returns array [21.5, 22.0, 22.5]

// Create an HTTP client
client = http::client()

// The client is now ready to make requests

client = http::client()

// Set method to POST for sending data
http::set_method(client, "POST")

// Set method to GET for retrieving data (this is the default)
http::set_method(client, "GET")

// Set method to PUT for updating resources
http::set_method(client, "PUT")

// Set method to DELETE for removing resources
http::set_method(client, "DELETE")

client = http::client()
http::set_method(client, "POST")

// Set content type for JSON data
http::set_header(client, "Content-Type", "application/json")

// Add authorization header with API key
http::set_header(client, "Authorization", "Bearer my-api-token-123")

// Add custom headers
http::set_header(client, "X-Custom-Header", "custom-value")
http::set_header(client, "Accept", "application/json")

client = http::client()
http::set_method(client, "POST")
http::set_header(client, "Content-Type", "application/json")

// Set JSON body
http::set_body(client, """{"temperature": 22.5, "humidity": 45}""")

// Or build the body dynamically using str::fmt
temp = 22.5
humidity = 45
body = str::fmt("""{"temperature": {}, "humidity": {}}""", temp, humidity)
http::set_body(client, body)

extern fn http::on_response(status, body, headers) {
    // Handle the response here
}

// Define the response callback - this will be called when the response arrives
extern fn http::on_response(status, body, headers) {
    if (status == 200) {
        std::print(str::fmt("Success! Response: {}", body))
    } else {
        std::print(str::fmt("Error: HTTP {}", status))
    }
}

// Prepare and send the request
client = http::client()
http::set_method(client, "GET")
http::set_header(client, "Accept", "application/json")
http::call(client, "http://192.168.1.100/api/status")

// For POST request with data
client2 = http::client()
http::set_method(client2, "POST")
http::set_header(client2, "Content-Type", "application/json")
http::set_body(client2, """{"command": "turn_on"}""")
http::call(client2, "http://192.168.1.100/api/device/relay1")

extern fn on_result(result, dout) {
    // Handle the response here
}

// Handle the response once the exchange completes
extern fn on_result(result, dout) {
    if (result != 0) {
        // Mark the device as unreachable
        output::set("online", false)
        return
    }

    // Read the first byte of the response and expose its state
    if (array::len(dout) > 0) {
        status = array::get_at(dout, 0)
        output::set("online", true)
        output::set("status", status)
    }
}

// Build the request payload as a byte array
request = array::new(0x01, 0x03, 0x00, 0x00)

// Send 4 bytes and expect an 8-byte reply
tcp::oneshot("192.168.1.50:9100", request, 8, "on_result")

// Connect to a device that speaks a persistent TCP protocol
tcp::open("192.168.1.50:4998")

// The connection is now available for tcp::send and tcp::receive

// Finished talking to the device - release the connection
tcp::close()

// A new connection can now be opened
tcp::open("192.168.1.60:4998")

extern fn on_sent(result) {
    // Handle the send result here
}

extern fn on_sent(result) {
    if (result == 0) {
        std::print("Command sent")
    } else {
        // Sending failed - the connection is likely broken
        output::set("online", false)
    }
}

tcp::open("192.168.1.50:4998")

// Send a 3-byte command
command = array::new(0x02, 0x10, 0x03)
tcp::send(command, "on_sent")

extern fn on_data(bytes) {
    // Process the received bytes here
}

extern fn on_closed() {
    // React to the connection being closed or lost
}

// The device sends 2-byte status frames: [frame type, value].
// A frame may arrive split across two callbacks, so incoming bytes
// are collected in the "rx_buffer" array state variable.
extern fn on_data(bytes) {
    buf = state::get("rx_buffer")

    // Append the new bytes to the buffered ones
    i = 0
    while (i < array::len(bytes)) {
        array::append(buf, array::get_at(bytes, i))
        i = i + 1
    }

    // Process every complete 2-byte frame
    i = 0
    while (i + 1 < array::len(buf)) {
        frame_type = array::get_at(buf, i)
        value = array::get_at(buf, i + 1)
        if (frame_type == 0x01) {
            output::set("status", value)
        }
        i = i + 2
    }

    // Keep the unconsumed byte (if any) for the next callback.
    // "buf" is a shared handle to the state array, so no state::set
    // is needed - these modifications update the state directly.
    if (i < array::len(buf)) {
        leftover = array::get_at(buf, i)
        array::clear(buf)
        array::append(buf, leftover)
    } else {
        array::clear(buf)
    }
}

extern fn on_closed() {
    // The device dropped the connection
    output::set("online", false)
}

tcp::open("192.168.1.50:4998")
tcp::receive("on_data", "on_closed")
output::set("online", true)

// Store the time when the motion was last detected
last_motion_time = time::now()

// ... later in the code ...

// Check if more than 60 seconds have passed since the last motion
if (time::now() > last_motion_time + 60) {
   ...
}

// Log a warning if the module has been running for more than 24 hours
// (might indicate it hasn't been restarted for maintenance)
if (time::uptime() > 86400) {
    std::print("Module running for over 24 hours")
}

// Delay initialization logic until the module has been stable for 10 seconds
if (time::uptime() > 10) {
    // Safe to assume all sensors have initialized
    ...
}

// Detect if the module was recently restarted
if (time::uptime() < 60) {
    std::print("Module just started, initializing...")
}

target_temp = 21.0
current_temp = 19.5

// Calculate the difference ignoring direction
delta = math::abs(target_temp - current_temp)

// If the difference is significant (more than 0.5 degrees), take action
if (delta > 0.5) {
    ....
}

// Example 1: Rounding sensor data for display
rawTemp = 21.7
displayTemp = math::round(rawTemp) // Returns 22

// Example 2: Halfway cases (rounding away from zero)
val1 = math::round(2.5)  // Returns 3
val2 = math::round(-2.5) // Returns -3

// Setting a dimmer level (must be an integer 0-100)
calculatedLevel = 55.4
dimmerLevel = math::round(calculatedLevel) // Returns 55

// Get a random value between 0.0 and 1.0
r = math::random()

// Generate a random integer between 1 and 100
n = math::round(math::random() * 100) + 1

// Random boolean decision (50/50)
if (math::random() < 0.5) {
    output::set("led", true)
} else {
    output::set("led", false)
}

// Encode a simple string
encoded = base64::encode("Hello, World!") // Returns "SGVsbG8sIFdvcmxkIQ=="

// Encode credentials for HTTP Basic Auth
credentials = str::concat("user", ":", "password")
auth = str::concat("Basic ", base64::encode(credentials))
http::set_header(client, "Authorization", auth)

// Empty string encodes to empty string
encoded = base64::encode("") // Returns ""

// Encode for URL-safe usage
encoded = base64::url_encode("Hello, World!") // Returns "SGVsbG8sIFdvcmxkIQ"

// Build a JWT header and payload
header = base64::url_encode("""{"alg":"RS256","typ":"JWT"}""")
payload = base64::url_encode("""{"sub":"1234567890","name":"John"}""")
signing_input = str::concat(header, ".", payload)

// Note the difference from standard base64:
// base64::encode("subjects?_d")     returns "c3ViamVjdHM/X2Q="
// base64::url_encode("subjects?_d") returns "c3ViamVjdHM_X2Q"

// Create a JWT signature
header = base64::url_encode("""{"alg":"RS256","typ":"JWT"}""")
payload = base64::url_encode("""{"sub":"device-001","iat":1700000000}""")
signing_input = str::concat(header, ".", payload)

// Sign with the private key
signature = crypto::rs256_sign(signing_input, private_key)

// Assemble the complete JWT
jwt = str::concat(signing_input, ".", signature)