dg_network_manager 1.0.0

use std::collections::HashMap;
use zbus::zvariant::OwnedValue;

pub mod access_point;
pub mod active_connection;
pub mod agent_manager;
pub mod checkpoint;
pub mod configs;
pub mod connection;
pub mod devices;
pub mod dns_manager;
pub mod network_manager;
pub mod settings;
pub mod vpn_connection;
pub mod wifi_p2p_peer;

pub enum ActivationStateFlags {
    None = 0,
    IsMaster = 1,
    IsSlave = 2,
    Layer2Ready = 4,
    Ip4Ready = 8,
    Ip6Ready = 16,
    MasterHasSlaves = 32,
    LifetimeBoundToProfileVisibility = 64,
}
impl From<u32> for ActivationStateFlags {
    fn from(value: u32) -> Self {
        match value {
            1 => ActivationStateFlags::IsMaster,
            2 => ActivationStateFlags::IsSlave,
            4 => ActivationStateFlags::Layer2Ready,
            8 => ActivationStateFlags::Ip4Ready,
            16 => ActivationStateFlags::Ip6Ready,
            32 => ActivationStateFlags::MasterHasSlaves,
            64 => ActivationStateFlags::LifetimeBoundToProfileVisibility,
            _ => ActivationStateFlags::None,
        }
    }
}

#[derive(Copy, Clone, PartialEq, Debug)]
pub enum ActiveConnectionState {
    Unknown = 0,
    Activating = 1,
    Activated = 2,
    Deactivating = 3,
    Deactivated = 4,
}
impl From<u32> for ActiveConnectionState {
    fn from(value: u32) -> Self {
        match value {
            1 => ActiveConnectionState::Activating,
            2 => ActiveConnectionState::Activated,
            3 => ActiveConnectionState::Deactivating,
            4 => ActiveConnectionState::Deactivated,
            _ => ActiveConnectionState::Unknown,
        }
    }
}

pub enum Capability {
    Unknown = 0,
    Team = 1,
    Ovs = 2,
}
impl From<u32> for Capability {
    fn from(value: u32) -> Self {
        match value {
            1 => Capability::Team,
            2 => Capability::Ovs,
            _ => Capability::Unknown,
        }
    }
}

pub enum ConnectivityState {
    Unknown = 0,
    None = 1,
    Portal = 2,
    Limited = 3,
    Full = 4,
}
impl From<u32> for ConnectivityState {
    fn from(value: u32) -> Self {
        match value {
            1 => ConnectivityState::None,
            2 => ConnectivityState::Portal,
            3 => ConnectivityState::Limited,
            4 => ConnectivityState::Full,
            _ => ConnectivityState::Unknown,
        }
    }
}

pub enum DeviceInterfaceFlag {
    None = 0,
    Up = 1,
    LowerUp = 2,
    Carrier = 65536,
}
impl From<u32> for DeviceInterfaceFlag {
    fn from(value: u32) -> Self {
        match value {
            1 => DeviceInterfaceFlag::Up,
            2 => DeviceInterfaceFlag::LowerUp,
            3 => DeviceInterfaceFlag::Carrier,
            _ => DeviceInterfaceFlag::None,
        }
    }
}

pub enum DeviceType {
    Unknown = 0,
    Ethernet = 1,
    Wifi = 2,
    Unused1 = 3,
    Unused2 = 4,
    Bluetooth = 5,
    OlpcMesh = 6,
    WiMax = 7,
    Modem = 8,
    Infiniband = 9,
    Bond = 10,
    Vlan = 11,
    Adsl = 12,
    Bridge = 13,
    Generic = 14,
    Team = 15,
    Tun = 16,
    IPTunnel = 17,
    Macvlan = 18,
    Vxlan = 19,
    Veth = 20,
    Macsec = 21,
    Dummy = 22,
    Ppp = 23,
    OvsInterface = 24,
    OvsPort = 25,
    OvsBridge = 26,
    Wpan = 27,
    SixLowpan = 28,
    WireGuard = 29,
    WifiP2P = 30,
    Vrf = 31,
}
impl From<u32> for DeviceType {
    fn from(value: u32) -> Self {
        match value {
            0 => DeviceType::Unknown,
            1 => DeviceType::Ethernet,
            2 => DeviceType::Wifi,
            3 => DeviceType::Unused1,
            4 => DeviceType::Unused2,
            5 => DeviceType::Bluetooth,
            6 => DeviceType::OlpcMesh,
            7 => DeviceType::WiMax,
            8 => DeviceType::Modem,
            9 => DeviceType::Infiniband,
            10 => DeviceType::Bond,
            11 => DeviceType::Vlan,
            12 => DeviceType::Adsl,
            13 => DeviceType::Bridge,
            14 => DeviceType::Generic,
            15 => DeviceType::Team,
            16 => DeviceType::Tun,
            17 => DeviceType::IPTunnel,
            18 => DeviceType::Macvlan,
            19 => DeviceType::Vxlan,
            20 => DeviceType::Veth,
            21 => DeviceType::Macsec,
            22 => DeviceType::Dummy,
            23 => DeviceType::Ppp,
            24 => DeviceType::OvsInterface,
            25 => DeviceType::OvsPort,
            26 => DeviceType::OvsBridge,
            27 => DeviceType::Wpan,
            28 => DeviceType::SixLowpan,
            29 => DeviceType::WireGuard,
            30 => DeviceType::WifiP2P,
            31 => DeviceType::Vrf,
            _ => DeviceType::Unknown, // Fallback for any unmatched value
        }
    }
}

pub enum NM80211ApFlags {
    None = 0,
    Privacy = 1,
    Wps = 2,
    WpsPbc = 4,
    WpsPin = 8,
}
impl From<u32> for NM80211ApFlags {
    fn from(value: u32) -> Self {
        match value {
            1 => NM80211ApFlags::Privacy,
            2 => NM80211ApFlags::Wps,
            4 => NM80211ApFlags::WpsPbc,
            8 => NM80211ApFlags::WpsPin,
            _ => NM80211ApFlags::None,
        }
    }
}

pub enum NM80211ApSecurityFlags {
    None = 0,
    PairWep40 = 1,
    PairWep104 = 2,
    PairTkip = 4,
    PairCcmp = 8,
    GroupWep40 = 10,
    GroupWep104 = 20,
    GroupTkip = 40,
    GroupCcmp = 80,
    KeyMgmtPsk = 100,
    KeyMgmt802_1x = 200,
    KeyMgmtSae = 400,
    KeyMgmtOwe = 800,
    KeyMgmtOwdTm = 1000,
    KeyMgmtEapSuiteB192 = 2000,
}

pub enum ReloadFlag {
    None = 0,
    Conf = 1,
    DnsRc = 2,
    DnsFull = 4,
    All = 7,
}

pub type Address = Vec<u32>;
pub type Route = Vec<u32>;
pub type Prefix = u32;

pub type IPv6Address = Vec<u8>;
pub type Gateway = Vec<u8>;
pub type AddressArray = Vec<(IPv6Address, Prefix, Gateway)>;

pub type IPv6Route = Vec<u8>;
pub type NextHop = Vec<u8>;
pub type Metric = u32;
pub type RouteArray = Vec<(IPv6Route, Prefix, NextHop, Metric)>;
pub type AddressData = Vec<HashMap<String, OwnedValue>>;
pub type RouteData = AddressData;
pub type NameServerData = AddressData;
pub type LldpNeighbors = AddressData;
pub type DnsConfiguration = AddressData;

pub type NameServer = Vec<u32>;
pub type IPv6NameServer = Vec<u8>;

pub type Options = HashMap<String, OwnedValue>;
pub type NMConnection = HashMap<String, Options>;
pub type NMConnectionSettings = NMConnection;