/**
 * Network Module based on native network_bridge C library.
 * This module provides a singleton interface to network management.
 * Can be used across threads, but `on` and `loop` functions need to be called in the same thread.
 * Features:
 * - Initialize/deinitialize network stack
 * - Connect/disconnect to Ethernet/WiFi/4G
 * - Query network status, local IP, RSSI
 * - Scan WiFi hotspots
 * - Register event callbacks (status change, WiFi scan complete)
 *
 * Usage:
 * - Call `init()` once to initialize.
 * - Use connect/disconnect/getStatus/isConnected/getLocalIP/getRSSI/scanWifi as needed.
 * - Use `on` to register event handlers.
 * - Call loop() periodically to process events (e.g. in setInterval).
 *
 * Doc/Demo: https://github.com/DejaOS/DejaOS
 */
import { netClass } from './libvbar-m-dxnetwork.so'

/**
 * @typedef {object} NetOption
 * @property {string} ip - Static IP address.
 * @property {string} gateway - Static gateway address.
 * @property {string} netmask - Static netmask.
 * @property {string} [dns] - Static DNS server address.
 */

const dxnetwork = {};

// 常量与枚举
dxnetwork.NET_TYPE = { ETH: 1, WIFI: 2, MODEM: 4 }; // 4 = 4G Modem
dxnetwork.IP_MODE = { DHCP: 0, STATIC: 1 };

const net = new netClass();
let _callbacks = {};

/**
 * Initializes the network.
 * @returns {void}
 */
dxnetwork.init = function () {
    net.init();
}

/**
 * Deinitializes the network stack and releases resources.
 * @returns {void}
 */
dxnetwork.deinit = function () {
    net.deinit();
}

/**
 * Connects to a network (Ethernet/WiFi/4G).
 * @param {object} options - Connection options.
 * @param {number} options.netType - Network type:
 *   1 = Ethernet,
 *   2 = WiFi,
 *   4 = 4G Modem.
 * @param {number} [options.ipMode] - IP mode: 0 = DHCP, 1 = Static.
 * @param {string} [options.ssid] - WiFi SSID (for WiFi only).
 * @param {string} [options.psk] - WiFi password (for WiFi only).
 * @param {string} [options.apn] - APN for 4G connection.
 * @param {string} [options.user] - Username for 4G APN.
 * @param {string} [options.password] - Password for 4G APN.
 * @param {string} [options.ip] - Static IP address (for static mode).
 * @param {string} [options.gateway] - Static gateway (for static mode).
 * @param {string} [options.netmask] - Static netmask (for static mode).
 * @param {string} [options.dns] - Static DNS (for static mode).
 * @param {string} [options.macaddr] - Custom MAC address (for Ethernet only).
 * @returns {void}
 * @example
 * dxnetwork.connect({ netType: 2, ssid: 'MyWiFi', psk: 'password' });
 */
dxnetwork.connect = function (options) {
    return net.connect(options);
}

/**
 * Connects to Ethernet with DHCP.
 * @param {string} [macaddr] - Optional custom MAC address.Usually not needed.
 * @returns {void}
 * @example
 * dxnetwork.connectEthWithDHCP();
 * dxnetwork.connectEthWithDHCP('00:11:22:33:44:55');
 */
dxnetwork.connectEthWithDHCP = function (macaddr) {
    const options = {
        netType: 1, // Ethernet
        ipMode: 0   // DHCP
    };
    if (macaddr) {
        options.macaddr = macaddr;
    }
    return net.connect(options);
};

/**
 * Connects to Ethernet with a static IP configuration.
 * @param {NetOption} netOption - The static IP configuration.
 * @param {string} [macaddr] - Optional custom MAC address. Usually not needed.
 * @returns {void}
 * @example
 * dxnetwork.connectEth({
 *   ip: '192.168.1.100',
 *   gateway: '192.168.1.1',
 *   netmask: '255.255.255.0',
 *   dns: '8.8.8.8'
 * });
 */
dxnetwork.connectEth = function (netOption, macaddr) {
    if (!netOption || !netOption.ip || !netOption.gateway || !netOption.netmask) {
        throw new Error('Static IP configuration (ip, gateway, netmask) is required for connectEth.');
    }
    const options = {
        netType: 1, // Ethernet
        ipMode: 1,  // Static
        ip: netOption.ip,
        gateway: netOption.gateway,
        netmask: netOption.netmask,
        dns: netOption.dns
    };
    if (macaddr) {
        options.macaddr = macaddr;
    }
    return net.connect(options);
};

/**
 * Connects to a WiFi network with DHCP.
 * @param {string} ssid - The SSID of the WiFi network.
 * @param {string} psk - The password (Pre-Shared Key) of the WiFi network.
 * @returns {void}
 * @example
 * dxnetwork.connectWifiWithDHCP('MyWiFi', 'MyPassword');
 */
dxnetwork.connectWifiWithDHCP = function (ssid, psk) {
    if (!ssid) {
        throw new Error('SSID is required for connectWifiWithDHCP.');
    }
    const options = {
        netType: 2, // WiFi
        ipMode: 0,  // DHCP
        ssid: ssid,
        psk: psk
    };
    return net.connect(options);
};

/**
 * Connects to a WiFi network with a static IP configuration.
 * @param {string} ssid - The SSID of the WiFi network.
 * @param {string} psk - The password (Pre-Shared Key) of the WiFi network.
 * @param {NetOption} netOption - The static IP configuration.
 * @returns {void}
 * @example
 * dxnetwork.connectWifi('MyWiFi', 'MyPassword', {
 *   ip: '192.168.1.101',
 *   gateway: '192.168.1.1',
 *   netmask: '255.255.255.0'
 * });
 */
dxnetwork.connectWifi = function (ssid, psk, netOption) {
    if (!netOption || !netOption.ip || !netOption.gateway || !netOption.netmask) {
        throw new Error('Static IP configuration (ip, gateway, netmask) is required for connectWifi with static IP.');
    }
    if (!ssid) {
        throw new Error('SSID is required for connectWifi with static IP.');
    }
    const options = {
        netType: 2, // WiFi
        ipMode: 1,  // Static
        ssid: ssid,
        psk: psk,
        ip: netOption.ip,
        gateway: netOption.gateway,
        netmask: netOption.netmask,
        dns: netOption.dns
    };
    return net.connect(options);
};

/**
 * Connects to a 4G mobile network with default settings.
 * @returns {void}
 * @example
 * dxnetwork.connect4G();
 */
dxnetwork.connect4G = function () {
    const options = {
        netType: 4, // 4G Modem
    };
    return net.connect(options);
};

/**
 * Disconnects from the current network.
 * @returns {void}
 */
dxnetwork.disconnect = function () {
    net.disconnect();
}

/**
 * Gets the current network status.
 * @returns {number} Network status code.
 */
dxnetwork.getStatus = function () {
    return net.getStatus();
}

/**
 * Gets the current network type
 * @returns {number} Network type code.
 */
dxnetwork.getType = function () {
    return net.getType();
}

/**
 * Checks if the network is currently connected.
 * @returns {boolean} True if connected, false otherwise.
 */
dxnetwork.isConnected = function () {
    return net.isConnected();
}

/**
 * Gets the local IP address.
 * @returns {string} ip address.
 * @returns {string} gateway address.
 * @returns {string} netmask address.
 * @returns {string} dns address.
 */
dxnetwork.getNetParam = function () {
    return net.getNetParam();
}

/**
 * Gets the current signal strength (RSSI).
 * @returns {number} RSSI value.
 */
dxnetwork.getRSSI = function () {
    return net.getRSSI();
}

/**
 * Gets the current network MAC address.
 * @returns {string} MAC address.
 */
dxnetwork.getNetMac = function () {
    return net.getNetMac();
}

/**
 * Scans for available WiFi hotspots.
 * @param {number} [timeout=2500] - Timeout in milliseconds.
 * @param {number} [interval=100] - Scan interval in milliseconds.
 * @returns {Array} List of WiFi hotspots.
 */
dxnetwork.scanWifi = function (timeout, interval) {
    return net.scanWifi(timeout, interval);
};

/**
 * Sets callback handlers for network events.
 * Current only support status change event.
 * @param {object} callbacks - Callback functions.
 * @param {function(netType:number, status:number)} [callbacks.onStatusChange] - Called when network status changes.
 * @example
 * dxnetwork.setCallbacks({
 *   onStatusChange: function(netType, status) {
 *   }
 * });
 * @returns {void}
 */

dxnetwork.setCallbacks = function (callbacks) {
    _callbacks = callbacks;
}

/**
 * Processes events from the network event queue. Should be called periodically (e.g. in setInterval).
 * Handles status change event.
 * @example
 * setInterval(() => {
 *   try{
 *     dxnetwork.loop();
 *   } catch (e) {
 *     log.error('Error in network loop:', e);
 *   } 
 * }, 50); // Process events every 50ms
 */
dxnetwork.loop = function () {
    let ev = net.getEvent()
    if (ev && ev.type === 0 && _callbacks.onStatusChange) {
        _callbacks.onStatusChange(ev.netType, ev.netStatus);
    }
}

/**
 * Gets the native network client object.
 * @returns {Object|null} The native client object, or null if not initialized.
 */
dxnetwork.getNative = function () {
    return net;
}

export default dxnetwork;