std.smash

// Standard operator overrides
fn __add__(a, b) {
    return a + b;
}

fn __sub__(a, b) {
    return a - b;
}

fn __mul__(a, b) {
    return a * b;
}

fn __div__(a, b) {
    return a / b;
}

// Core utility
fn print(x) {
    return x; // placeholder for native print
}

// Async/await support
// This is a special function that the runtime will recognize and handle
fn __createPromise(executor) {
    return __native_create_promise(executor);
}

// Convert a value to a Promise if it's not already one
fn __promisify(value) {
    if (__is_promise(value)) {
        return value;
    }
    return __createPromise(fn(resolve, _) {
        resolve(value);
    });
}

// Control flow support
// These are special functions that the runtime will recognize and handle

// Conditional operators
fn __equals(a, b) {
    return a === b;
}

fn __not_equals(a, b) {
    return a !== b;
}

fn __greater_than(a, b) {
    return a > b;
}

fn __less_than(a, b) {
    return a < b;
}

fn __greater_than_equals(a, b) {
    return a >= b;
}

fn __less_than_equals(a, b) {
    return a <= b;
}

// Logical operators
fn __and(a, b) {
    return a && b;
}

fn __or(a, b) {
    return a || b;
}

fn __not(a) {
    return !a;
}

// Ternary operator helper
fn __ternary(condition, trueValue, falseValue) {
    return condition ? trueValue : falseValue;
}

// Array and object iteration helpers
fn __iterate_array(array, callback) {
    for (let i = 0; i < array.length; i++) {
        callback(array[i], i, array);
    }
}

fn __iterate_object(obj, callback) {
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            callback(key, obj[key], obj);
        }
    }
}

// HTTP/HTTPS functionality - fetch API compatible
fn fetch(url, options = {}) {
    let method = options.method || "GET";
    let headers = options.headers || {};
    let body = options.body || null;
    let timeout = options.timeout || 30000; // 30 seconds default
    
    // This will be implemented natively in the runtime
    // Returns a Promise-like object with .then(), .catch(), and .json() methods
    return __native_fetch(url, method, headers, body, timeout);
}

// Helper methods for common HTTP verbs
fn get(url, options = {}) {
    options.method = "GET";
    return fetch(url, options);
}

fn post(url, data, options = {}) {
    options.method = "POST";
    options.body = data;
    return fetch(url, options);
}

fn put(url, data, options = {}) {
    options.method = "PUT";
    options.body = data;
    return fetch(url, options);
}

fn del(url, options = {}) {
    options.method = "DELETE";
    return fetch(url, options);
}

// Process-related functionality

// System environment variables
const env = {
  // Core environment variables that should be available
  HOME: __native_get_env("HOME"),
  USER: __native_get_env("USER"),
  PATH: __native_get_env("PATH"),
  TEMP: __native_get_env("TEMP") || __native_get_env("TMP"),
  SHELL: __native_get_env("SHELL"),
  LANG: __native_get_env("LANG"),
  
  // Helper method to get any environment variable
  get: function(name) {
    return __native_get_env(name);
  },
  
  // Helper method to set an environment variable
  set: function(name, value) {
    return __native_set_env(name, value);
  }
};

// Command line arguments
// This will be populated by the runtime with the actual command line arguments
const argv = __native_get_argv();

// Current working directory operations
fn cwd() {
  return __native_get_cwd();
}

fn chdir(directory) {
  return __native_set_cwd(directory);
}

// Platform information
const platform = __native_get_platform(); // 'linux', 'darwin', 'win32', etc.
const arch = __native_get_arch();         // 'x64', 'arm64', etc.

// Process control
fn exit(code = 0) {
  return __native_exit(code);
}

// Process information
const pid = __native_get_pid();
const ppid = __native_get_ppid();

// Memory usage
fn memoryUsage() {
  return __native_memory_usage();
}

// CPU usage
fn cpuUsage() {
  return __native_cpu_usage();
}

// High-resolution time measurement
fn hrtime() {
  return __native_hrtime();
}

// Event handling for process events
const eventHandlers = {
  exit: [],
  uncaughtException: [],
  unhandledRejection: []
};

fn on(event, handler) {
  if (eventHandlers[event]) {
    eventHandlers[event].push(handler);
  }
  return this; // For chaining
}

fn removeListener(event, handler) {
  if (eventHandlers[event]) {
    const index = eventHandlers[event].indexOf(handler);
    if (index !== -1) {
      eventHandlers[event].splice(index, 1);
    }
  }
  return this; // For chaining
}

// These functions would be called by the runtime when events occur
fn __triggerEvent(event, ...args) {
  if (eventHandlers[event]) {
    for (const handler of eventHandlers[event]) {
      handler(...args);
    }
  }
}