const sys = @import("sys");
const errors = @import("error");

pub const WIFI_ENABLE_ENTERPRISE = 1 << 7;

pub const CONFIG_FEATURE_WPA3_SAE_BIT = 1 << 0;
pub const CONFIG_FEATURE_CACHE_TX_BUF_BIT = 1 << 1;
pub const CONFIG_FEATURE_FTM_INITIATOR_BIT = 1 << 2;
pub const CONFIG_FEATURE_FTM_RESPONDER_BIT = 1 << 3;
pub const CONFIG_FEATURE_GCMP_BIT = 1 << 4;
pub const CONFIG_FEATURE_GMAC_BIT = 1 << 5;
pub const CONFIG_FEATURE_11R_BIT = 1 << 6;
pub const CONFIG_FEATURE_WIFI_ENT_BIT = 1 << 7;

pub const WIFI_FEATURE_CAPS =
    CONFIG_FEATURE_WPA3_SAE_BIT |
    CONFIG_FEATURE_CACHE_TX_BUF_BIT |
    CONFIG_FEATURE_FTM_INITIATOR_BIT |
    CONFIG_FEATURE_FTM_RESPONDER_BIT |
    CONFIG_FEATURE_GCMP_BIT |
    CONFIG_FEATURE_GMAC_BIT |
    CONFIG_FEATURE_11R_BIT |
    WIFI_ENABLE_ENTERPRISE;

pub const wifi_mode_t = enum(sys.wifi_mode_t) {
    WIFI_MODE_NULL = sys.WIFI_MODE_NULL,
    WIFI_MODE_STA = sys.WIFI_MODE_STA,
    WIFI_MODE_AP = sys.WIFI_MODE_AP,
    WIFI_MODE_APSTA = sys.WIFI_MODE_APSTA,
    WIFI_MODE_NAN = sys.WIFI_MODE_NAN,
    WIFI_MODE_MAX = sys.WIFI_MODE_MAX,
};
pub const wifi_interface_t = enum(sys.wifi_interface_t) {
    WIFI_IF_STA = sys.WIFI_IF_STA,
    WIFI_IF_AP = sys.WIFI_IF_AP,
    WIFI_IF_NAN = sys.WIFI_IF_NAN,
    WIFI_IF_MAX = sys.WIFI_IF_MAX,
};
pub const wifi_country_policy_t = enum(sys.wifi_country_policy_t) {
    WIFI_COUNTRY_POLICY_AUTO = sys.WIFI_COUNTRY_POLICY_AUTO,
    WIFI_COUNTRY_POLICY_MANUAL = sys.WIFI_COUNTRY_POLICY_MANUAL,
};

pub fn init(config: *const sys.wifi_init_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_init(config));
}
pub fn setDefaultWifiStationHandlers() !void {
    return try errors.espCheckError(sys.esp_wifi_set_default_wifi_sta_handlers());
}
pub fn setDefaultWifiAPHandlers() !void {
    return try errors.espCheckError(sys.esp_wifi_set_default_wifi_ap_handlers());
}
pub fn setDefaultWifiNANHandlers() !void {
    return try errors.espCheckError(sys.esp_wifi_set_default_wifi_nan_handlers());
}
pub fn clearDefaultWifiDriverHandlers(esp_netif: ?*anyopaque) !void {
    return try errors.espCheckError(sys.esp_wifi_clear_default_wifi_driver_and_handlers(esp_netif));
}
pub fn deinit() !void {
    return try errors.espCheckError(sys.esp_wifi_deinit());
}
pub fn setMode(mode: wifi_mode_t) !void {
    return try errors.espCheckError(sys.esp_wifi_set_mode(@intFromEnum(mode)));
}
pub fn getMode(mode: [*]wifi_mode_t) !void {
    return try errors.espCheckError(sys.esp_wifi_get_mode(mode));
}
pub fn start() !void {
    return try errors.espCheckError(sys.esp_wifi_start());
}
pub fn stop() !void {
    return try errors.espCheckError(sys.esp_wifi_stop());
}
pub fn restore() !void {
    return try errors.espCheckError(sys.esp_wifi_restore());
}
pub fn connect() !void {
    return try errors.espCheckError(sys.esp_wifi_connect());
}
pub fn disconnect() !void {
    return try errors.espCheckError(sys.esp_wifi_disconnect());
}
pub fn clearFastConnect() !void {
    return try errors.espCheckError(sys.esp_wifi_clear_fast_connect());
}
pub const Scan = struct {
    pub fn start(config: [*c]const sys.wifi_scan_config_t, block: bool) !void {
        return try errors.espCheckError(sys.esp_wifi_scan_start(config, block));
    }
    pub fn stop() !void {
        return try errors.espCheckError(sys.esp_wifi_scan_stop());
    }
    pub fn getAPNum(number: [*c]u16) !void {
        return try errors.espCheckError(sys.esp_wifi_scan_get_ap_num(number));
    }
    pub fn getAPRecords(number: [*c]u16, ap_records: ?*sys.wifi_ap_record_t) !void {
        return try errors.espCheckError(sys.esp_wifi_scan_get_ap_records(number, ap_records));
    }
    pub fn getAPRecord(ap_record: ?*sys.wifi_ap_record_t) !void {
        return try errors.espCheckError(sys.esp_wifi_scan_get_ap_record(ap_record));
    }
};
pub const PowerSave = struct {
    pub fn set(@"type": sys.wifi_ps_type_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_ps(@"type"));
    }
    pub fn get(@"type": [*c]sys.wifi_ps_type_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_ps(@"type"));
    }
};
pub const Protocol = struct {
    pub fn set(ifx: wifi_interface_t, protocol_bitmap: u8) !void {
        return try errors.espCheckError(sys.esp_wifi_set_protocol(ifx, protocol_bitmap));
    }
    pub fn get(ifx: wifi_interface_t, protocol_bitmap: [*:0]u8) !void {
        return try errors.espCheckError(sys.esp_wifi_get_protocol(ifx, protocol_bitmap));
    }
};
pub const Bandwidth = struct {
    pub fn set(ifx: wifi_interface_t, bw: sys.wifi_bandwidth_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_bandwidth(ifx, bw));
    }
    pub fn get(ifx: wifi_interface_t, bw: [*c]sys.wifi_bandwidth_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_bandwidth(ifx, bw));
    }
};
pub const Channel = struct {
    pub fn set(primary: u8, second: sys.wifi_second_chan_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_channel(primary, second));
    }
    pub fn get(primary: [*c]u8, second: [*c]sys.wifi_second_chan_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_channel(primary, second));
    }
};
pub const Country = struct {
    pub fn set(country: [*c]const sys.wifi_country_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_country(country));
    }
    pub fn get(country: [*c]sys.wifi_country_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_country(country));
    }
    pub fn setCode(country: [*:0]const u8, ieee80211d_enabled: bool) !void {
        return try errors.espCheckError(sys.esp_wifi_set_country_code(country, ieee80211d_enabled));
    }
    pub fn getCode(country: [*:0]u8) !void {
        return try errors.espCheckError(sys.esp_wifi_get_country_code(country));
    }
};
pub const MAC = struct {
    pub fn set(ifx: wifi_interface_t, mac: [*:0]const u8) !void {
        return try errors.espCheckError(sys.esp_wifi_set_mac(ifx, mac));
    }
    pub fn get(ifx: wifi_interface_t, mac: [*:0]u8) !void {
        return try errors.espCheckError(sys.esp_wifi_get_mac(ifx, mac));
    }
};
pub const Promiscuous = struct {
    pub const promiscuous_callback_type = sys.wifi_promiscuous_cb_t;
    pub fn setRXCallback(cb: sys.wifi_promiscuous_cb_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_promiscuous_rx_cb(cb));
    }
    pub fn set(en: bool) !void {
        return try errors.espCheckError(sys.esp_wifi_set_promiscuous(en));
    }
    pub fn get(en: [*c]bool) !void {
        return try errors.espCheckError(sys.esp_wifi_get_promiscuous(en));
    }
    pub fn setFilter(filter: [*c]const sys.wifi_promiscuous_filter_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_promiscuous_filter(filter));
    }
    pub fn getFilter(filter: [*c]sys.wifi_promiscuous_filter_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_promiscuous_filter(filter));
    }
    pub fn setCtrlFilter(filter: [*c]const sys.wifi_promiscuous_filter_t) !void {
        return try errors.espCheckError(sys.esp_wifi_set_promiscuous_ctrl_filter(filter));
    }
    pub fn getCtrlFilter(filter: [*c]sys.wifi_promiscuous_filter_t) !void {
        return try errors.espCheckError(sys.esp_wifi_get_promiscuous_ctrl_filter(filter));
    }
};
pub const wifiConfig = sys.wifi_config_t;
pub fn setConfig(interface: wifi_interface_t, conf: ?*sys.wifi_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_set_config(@intFromEnum(interface), conf));
}
pub fn getConfig(interface: wifi_interface_t, conf: ?*sys.wifi_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_get_config(interface, conf));
}
pub fn setStorage(storage: sys.wifi_storage_t) !void {
    return try errors.espCheckError(sys.esp_wifi_set_storage(storage));
}
pub const Vendor = struct {
    pub const vendor_ie_callback_id_type = sys.wifi_vendor_ie_id_t;
    pub fn setIE(enable: bool, @"type": sys.wifi_vendor_ie_type_t, idx: sys.wifi_vendor_ie_id_t, vnd_ie: ?*const anyopaque) !void {
        return try errors.espCheckError(sys.esp_wifi_set_vendor_ie(enable, @"type", idx, vnd_ie));
    }
    pub fn setIECallback(callback: sys.esp_vendor_ie_cb_t, ctx: ?*anyopaque) !void {
        return try errors.espCheckError(sys.esp_wifi_set_vendor_ie_cb(callback, ctx));
    }
};
pub fn setMaxTXPower(power: i8) !void {
    return try errors.espCheckError(sys.esp_wifi_set_max_tx_power(power));
}
pub fn getMaxTXPower(power: [*c]i8) !void {
    return try errors.espCheckError(sys.esp_wifi_get_max_tx_power(power));
}
pub fn setEventMask(mask: u32) !void {
    return try errors.espCheckError(sys.esp_wifi_set_event_mask(mask));
}
pub fn getEventMask(mask: [*c]u32) !void {
    return try errors.espCheckError(sys.esp_wifi_get_event_mask(mask));
}
pub fn p80211TX(ifx: wifi_interface_t, buffer: ?*const anyopaque, len: c_int, en_sys_seq: bool) !void {
    return try errors.espCheckError(sys.esp_wifi_80211_tx(ifx, buffer, len, en_sys_seq));
}
pub const csi_callback_type = sys.wifi_csi_cb_t;
pub fn setCsiRXCallback(callback: csi_callback_type, ctx: ?*anyopaque) !void {
    return try errors.espCheckError(sys.esp_wifi_set_csi_rx_cb(callback, ctx));
}
pub fn setCsiConfig(config: ?*const csi_callback_type) !void {
    return try errors.espCheckError(sys.esp_wifi_set_csi_config(config));
}
pub fn setCsi(en: bool) !void {
    return try errors.espCheckError(sys.esp_wifi_set_csi(en));
}
pub fn setAntGPIO(config: [*c]const sys.wifi_ant_gpio_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_set_ant_gpio(config));
}
pub fn getAntGPIO(config: [*c]sys.wifi_ant_gpio_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_get_ant_gpio(config));
}
pub fn setAnt(config: ?*const sys.wifi_ant_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_set_ant(config));
}
pub fn getAnt(config: ?*sys.wifi_ant_config_t) !void {
    return try errors.espCheckError(sys.esp_wifi_get_ant(config));
}
pub fn getTsfTime(interface: wifi_interface_t) i64 {
    return sys.esp_wifi_get_tsf_time(interface);
}
pub fn setInactiveTime(ifx: wifi_interface_t, sec: u16) !void {
    return try errors.espCheckError(sys.esp_wifi_set_inactive_time(ifx, sec));
}
pub fn getInactiveTime(ifx: wifi_interface_t, sec: [*c]u16) !void {
    return try errors.espCheckError(sys.esp_wifi_get_inactive_time(ifx, sec));
}
pub fn statisDump(modules: u32) !void {
    return try errors.espCheckError(sys.esp_wifi_statis_dump(modules));
}
pub fn setRssiThreshold(rssi: i32) !void {
    return try errors.espCheckError(sys.esp_wifi_set_rssi_threshold(rssi));
}
pub const FTM = struct {
    pub fn initiateSession(cfg: [*c]sys.wifi_ftm_initiator_cfg_t) !void {
        return try errors.espCheckError(sys.esp_wifi_ftm_initiate_session(cfg));
    }
    pub fn endSession() !void {
        return try errors.espCheckError(sys.esp_wifi_ftm_end_session());
    }
    pub fn respSetOffset(offset_cm: i16) !void {
        return try errors.espCheckError(sys.esp_wifi_ftm_resp_set_offset(offset_cm));
    }
};
pub fn config11bRate(ifx: wifi_interface_t, disable: bool) !void {
    return try errors.espCheckError(sys.esp_wifi_config_11b_rate(ifx, disable));
}
pub fn connectionlessModuleSetWakeInterval(wake_interval: u16) !void {
    return try errors.espCheckError(sys.esp_wifi_connectionless_module_set_wake_interval(wake_interval));
}
pub fn forceWakeupAcquire() !void {
    return try errors.espCheckError(sys.esp_wifi_force_wakeup_acquire());
}
pub fn forceWakeupRelease() !void {
    return try errors.espCheckError(sys.esp_wifi_force_wakeup_release());
}
pub fn config80211TXRate(ifx: wifi_interface_t, rate: sys.wifi_phy_rate_t) !void {
    return try errors.espCheckError(sys.esp_wifi_config_80211_tx_rate(ifx, rate));
}
pub fn disablePMFConfig(ifx: wifi_interface_t) !void {
    return try errors.espCheckError(sys.esp_wifi_disable_pmf_config(ifx));
}
pub fn setDynCS(enabled: bool) !void {
    return try errors.espCheckError(sys.esp_wifi_set_dynamic_cs(enabled));
}
pub const Station = struct {
    pub fn getAPInfo(ap_info: ?*sys.wifi_ap_record_t) !void {
        return try errors.espCheckError(sys.esp_wifi_sta_get_ap_info(ap_info));
    }
    pub fn getRssi(rssi: [*c]c_int) !void {
        return try errors.espCheckError(sys.esp_wifi_sta_get_rssi(rssi));
    }
    pub fn getAid(aid: [*c]u16) !void {
        return try errors.espCheckError(sys.esp_wifi_sta_get_aid(aid));
    }
    pub fn getNegotiatedPHYMode(phymode: [*c]sys.wifi_phy_mode_t) !void {
        return try errors.espCheckError(sys.esp_wifi_sta_get_negotiated_phymode(phymode));
    }
    pub fn deauth(aid: u16) !void {
        return try errors.espCheckError(sys.esp_wifi_deauth_sta(aid));
    }
    pub const AP = struct {
        pub fn getList(sta: ?*sys.wifi_sta_list_t) !void {
            return try errors.espCheckError(sys.esp_wifi_ap_get_sta_list(sta));
        }
        pub fn getAid(mac: [*:0]const u8, aid: [*c]u16) !void {
            return try errors.espCheckError(sys.esp_wifi_ap_get_sta_aid(mac, aid));
        }
        pub fn clearList() !void {
            return try errors.espCheckError(sys.esp_wifi_clear_ap_list());
        }
    };
};

pub const PowerDomain = struct {
    pub fn On() void {
        sys.esp_wifi_power_domain_on();
    }
    pub fn Off() void {
        sys.esp_wifi_power_domain_off();
    }
};

pub const Enterprise = struct {
    pub const Station = struct {
        pub fn enable() !void {
            return try errors.espCheckError(sys.esp_wifi_sta_enterprise_enable());
        }
        pub fn disable() !void {
            return try errors.espCheckError(sys.esp_wifi_sta_enterprise_disable());
        }
    };
    pub const Client = struct {
        pub fn setIdentity(identity: [*:0]const u8, len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_identity(identity, len));
        }
        pub const clearIdentity = sys.esp_eap_client_clear_identity;
        pub fn setUsername(username: [*:0]const u8, len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_username(username, len));
        }
        pub const clearUsername = sys.esp_eap_client_clear_username;
        pub fn setPassword(password: [*:0]const u8, len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_password(password, len));
        }
        pub const clearPassword = sys.esp_eap_client_clear_new_password;
        pub fn setNewPassword(new_password: [*:0]const u8, len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_new_password(new_password, len));
        }
        pub const clearNewPassword = sys.esp_eap_client_clear_new_password;
        pub fn setCACertificate(ca_cert: [*:0]const u8, ca_cert_len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_ca_cert(ca_cert, ca_cert_len));
        }
        pub const clearCACertificate = sys.esp_eap_client_clear_ca_cert;
        pub fn setCertificateKey(client_cert: [*:0]const u8, client_cert_len: c_int, private_key: [*:0]const u8, private_key_len: c_int, private_key_password: [*:0]const u8, private_key_passwd_len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_certificate_and_key(client_cert, client_cert_len, private_key, private_key_len, private_key_password, private_key_passwd_len));
        }
        pub const clearCertificateKey = sys.esp_eap_client_clear_certificate_and_key;
        pub fn setDisableTimeCheck(disable: bool) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_disable_time_check(disable));
        }
        pub fn getDisableTimeCheck(disable: [*c]bool) !void {
            return try errors.espCheckError(sys.esp_eap_client_get_disable_time_check(disable));
        }
        pub fn setTTLSPhase2Method(@"type": sys.esp_eap_ttls_phase2_types) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_ttls_phase2_method(@"type"));
        }
        pub fn setSuiteb192bitCertification(enable: bool) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_suiteb_192bit_certification(enable));
        }
        pub fn setPACFile(pac_file: [*:0]const u8, pac_file_len: c_int) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_pac_file(pac_file, pac_file_len));
        }
        pub fn setFastParams(config: sys.esp_eap_fast_config) !void {
            return try errors.espCheckError(sys.esp_eap_client_set_fast_params(config));
        }
        pub fn useDefaultCertificateBundle(use_default_bundle: bool) !void {
            return try errors.espCheckError(sys.esp_eap_client_use_default_cert_bundle(use_default_bundle));
        }
    };
};

pub const Internal = struct {
    // STUBS
    pub fn setStationIp() !void {
        return try errors.espCheckError(sys.esp_wifi_internal_set_sta_ip());
    }
    pub fn registryNetstackBufCallback(ref: sys.wifi_netstack_buf_ref_cb_t, free: sys.wifi_netstack_buf_free_cb_t) !void {
        return try errors.espCheckError(sys.esp_wifi_internal_reg_netstack_buf_cb(ref, free));
    }
    pub fn freeRXBuffer(buffer: ?*anyopaque) !void {
        if (buffer) |b|
            return try errors.espCheckError(sys.esp_wifi_internal_free_rx_buffer(b));
    }
    pub fn txBuffer(ifx: wifi_interface_t, buffer: ?*anyopaque, len: u16) !void {
        return try errors.espCheckError(sys.esp_wifi_internal_tx(ifx, buffer, len));
    }
    pub fn registryTXCallBack(ifx: wifi_interface_t, @"fn": sys.wifi_rxcb_t) !void {
        return try errors.espCheckError(sys.esp_wifi_internal_reg_rxcb(ifx, @"fn"));
    }
};

pub fn init_config_default() sys.wifi_init_config_t {
    return sys.wifi_init_config_t{
        .osi_funcs = &sys.g_wifi_osi_funcs,
        .wpa_crypto_funcs = sys.g_wifi_default_wpa_crypto_funcs,
        .static_rx_buf_num = sys.CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM,
        .dynamic_rx_buf_num = sys.CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM,
        .tx_buf_type = sys.CONFIG_ESP_WIFI_TX_BUFFER_TYPE,
        .static_tx_buf_num = sys.WIFI_STATIC_TX_BUFFER_NUM,
        .dynamic_tx_buf_num = sys.WIFI_DYNAMIC_TX_BUFFER_NUM,
        .rx_mgmt_buf_type = sys.CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF,
        .rx_mgmt_buf_num = sys.WIFI_RX_MGMT_BUF_NUM_DEF,
        .cache_tx_buf_num = sys.WIFI_CACHE_TX_BUFFER_NUM,
        .csi_enable = sys.WIFI_CSI_ENABLED,
        .ampdu_rx_enable = sys.WIFI_AMPDU_RX_ENABLED,
        .ampdu_tx_enable = sys.WIFI_AMPDU_TX_ENABLED,
        .amsdu_tx_enable = sys.WIFI_AMSDU_TX_ENABLED,
        .nvs_enable = sys.WIFI_NVS_ENABLED,
        .nano_enable = sys.WIFI_NANO_FORMAT_ENABLED,
        .rx_ba_win = sys.WIFI_DEFAULT_RX_BA_WIN,
        .wifi_task_core_id = sys.WIFI_TASK_CORE_ID,
        .beacon_max_len = sys.WIFI_SOFTAP_BEACON_MAX_LEN,
        .mgmt_sbuf_num = sys.WIFI_MGMT_SBUF_NUM,
        .feature_caps = sys.WIFI_FEATURE_CAPS,
        .sta_disconnected_pm = sys.WIFI_STA_DISCONNECTED_PM_ENABLED != 0,
        .espnow_max_encrypt_num = sys.CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM,
        .tx_hetb_queue_num = sys.WIFI_TX_HETB_QUEUE_NUM,
        .dump_hesigb_enable = sys.WIFI_DUMP_HESIGB_ENABLED != 0,
        .magic = sys.WIFI_INIT_CONFIG_MAGIC,
    };
}