// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use crate::error;
use crate::lifmgr;
use serde_derive::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashSet;
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};
use valico::json_schema::{self, schema};

/// Interface types defined by the OpenConfig interfaces model.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields, rename_all = "SCREAMING_SNAKE_CASE")]
pub enum InterfaceType {
    IfEthernet,
    IfAggregate,
    IfLoopback,
    IfRoutedVlan,
    IfSonet,
    IfTunnelGre4,
    IfTunnelGre6,
    IfUplink,
}

/// The possible interface operational states from RFC2863 "Standard Interfaces MIB".
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields, rename_all = "SCREAMING_SNAKE_CASE")]
pub enum OperState {
    Up,
    Down,
    Unknown,
    Testing,
    NotPresent,
    LowerLayerDown,
}

/// The possible interface admin states from RFC2863 "Standard Interfaces MIB".
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields, rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AdminState {
    Up,
    Down,
    Testing,
}

/// When `auto-negotiate` is true, this optionally sets the duplex mode that will be advertised to
/// the peer. If unspecified, the interface should negotiate the duplex mode directly (typically
/// full-duplex). When auto-negotiate is false, this sets the duplex mode on the interface directly.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields, rename_all = "SCREAMING_SNAKE_CASE")]
pub enum DuplexMode {
    Full,
    Half,
}

/// Defines VLAN interface types.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields, rename_all = "SCREAMING_SNAKE_CASE")]
pub enum InterfaceMode {
    Access,
    Trunk,
}

/// When `auto-negotiate` is true, this optionally sets the port-speed mode that will be advertised
/// to the peer for negotiation. If unspecified, it is expected that the interface will select the
/// highest speed available based on negotiation. When auto-negotiate is set to false, sets the
/// link speed to a fixed value.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(deny_unknown_fields)]
pub enum PortSpeed {
    #[serde(alias = "SPEED_10MB")]
    Speed10mb,
    #[serde(alias = "SPEED_100MB")]
    Speed100mb,
    #[serde(alias = "SPEED_1G")]
    Speed1g,
    #[serde(alias = "SPEED_2500MB")]
    Speed2500mb,
    #[serde(alias = "SPEED_5G")]
    Speed5g,
    #[serde(alias = "SPEED_10G")]
    Speed10g,
    #[serde(alias = "SPEED_UNKNOWN")]
    SpeedUnknown,
}

// TODO(cgibson): VLANs.
// TODO(cgibson): ACLs.
// TODO(cgibson): WLAN.
// TODO(cgibson): Need to figure out versioning. Having "unknown" fields and "flatten"'ing them
// into an `extras` field might be an interesting experiment.
#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct DeviceConfig {
    pub device: Device,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Device {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interfaces: Option<Vec<Interfaces>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub acls: Option<Acls>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub services: Option<Services>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Interfaces {
    pub interface: Interface,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Interface {
    // Certain types of interface (e.g. RoutedVlan) do not have a device_id.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_id: Option<String>,
    // Every Interface must have a config definition.
    pub config: InterfaceConfig,
    // If oper_state is omitted, then the default is `OperState::Up`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oper_state: Option<OperState>,
    // An interface must contain exactly one: 'subinterfaces', 'switched_vlan', or 'routed_vlan'.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subinterfaces: Option<Vec<Subinterface>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub switched_vlan: Option<SwitchedVlan>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routed_vlan: Option<RoutedVlan>,
    // ethernet can be omitted and defaults will be applied.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ethernet: Option<Ethernet>,
    // tcp_offload can be omitted and the default will be applied.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tcp_offload: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct InterfaceConfig {
    pub name: String,
    #[serde(rename = "type")]
    pub interface_type: InterfaceType,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Subinterface {
    // If admin_state is omitted, then the default is AdminState::Up.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub admin_state: Option<AdminState>,
    // A subinterface must have at least one IP address configuration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv4: Option<IpAddressConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv6: Option<IpAddressConfig>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct IpAddressConfig {
    pub addresses: Vec<IpAddress>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct IpAddress {
    // If omitted, the default is to enable a DHCP client on this interface.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dhcp_client: Option<bool>,
    // If an IP address is provided, it must be paired with a prefix length.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<std::net::IpAddr>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prefix_length: Option<u8>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct SwitchedVlan {
    pub interface_mode: InterfaceMode,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_vlan: Option<u16>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trunk_vlans: Option<Vec<u16>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct RoutedVlan {
    pub vlan_id: u16,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv4: Option<IpAddressConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv6: Option<IpAddressConfig>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Ethernet {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config: Option<EthernetConfig>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct EthernetConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_negotiate: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duplex_mode: Option<DuplexMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_flow_control: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mac_address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mtu: Option<u16>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub port_speed: Option<PortSpeed>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Acls {}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Services {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dhcp_server: Option<DhcpServer>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_forwarding: Option<IpForwarding>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct DhcpServer {
    pub enabled: bool,
    pub dhcp_pool: DhcpPool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub static_ip_allocations: Option<Vec<StaticIpAllocations>>,
    pub interfaces: String,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct DhcpPool {
    pub start: String,
    pub end: String,
    pub lease_time: String,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct StaticIpAllocations {
    pub device_name: String,
    pub mac_address: String,
    pub ip_address: String,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct IpForwarding {
    pub enabled: bool,
}

#[derive(Debug, PartialEq)]
struct DeviceConfigPaths {
    user_config_path: PathBuf,
    factory_config_path: PathBuf,
    device_schema_path: PathBuf,
}

#[derive(Debug, PartialEq)]
pub struct Config {
    device_config: Option<DeviceConfig>,
    startup_path: Option<PathBuf>,
    paths: DeviceConfigPaths,
}

const UNNAMED_BRIDGE: &str = "unnamed_bridge";

/// Converts a Valico JSON SchemaError to a `String`.
fn schema_error(error: schema::SchemaError) -> String {
    match error {
        schema::SchemaError::WrongId => String::from("Wrong Id"),
        schema::SchemaError::IdConflicts => String::from("Id conflicts"),
        schema::SchemaError::NotAnObject => String::from("Not an object"),
        schema::SchemaError::UrlParseError(p) => String::from(format!("Url parse error: {}", p)),
        schema::SchemaError::UnknownKey(key) => String::from(format!("Unknown key: {}", key)),
        schema::SchemaError::Malformed { path, detail } => {
            String::from(format!("Malformed: {}, {}", path, detail))
        }
    }
}

impl Config {
    /// Creates a new Config object with the given user, factory, and device schema paths.
    pub fn new<P: Into<PathBuf>>(user_path: P, factory_path: P, device_schema: P) -> Config {
        Config {
            device_config: None,
            startup_path: None,
            paths: DeviceConfigPaths {
                user_config_path: user_path.into(),
                factory_config_path: factory_path.into(),
                device_schema_path: device_schema.into(),
            },
        }
    }

    /// Returns the user config path.
    pub fn user_config_path(&self) -> &Path {
        self.paths.user_config_path.as_path()
    }

    /// Returns the factory config path.
    pub fn factory_config_path(&self) -> &Path {
        self.paths.factory_config_path.as_path()
    }

    /// Returns the device schema path.
    pub fn device_schema_path(&self) -> &Path {
        self.paths.device_schema_path.as_path()
    }

    /// Returns the path of the config that was read at startup
    ///
    /// If no configuration file has been read yet, then returns an empty path.
    pub fn startup_path(&self) -> &Path {
        if let Some(p) = &self.startup_path {
            p.as_path()
        } else {
            Path::new("")
        }
    }

    /// Loads the relevant configuration file.
    ///
    /// This method tries to load the user configuration file. If the user configuration file does
    /// not exist (e.g. first boot after OOBE, FDR, etc), then fallback to loading the factory
    /// configuration file.
    ///
    /// If this method returns successfully, there will be a newly loaded and properly validated
    /// deserialized configuration available.
    pub async fn load_config(&mut self) -> error::Result<()> {
        let loaded_config;
        let loaded_path;
        match self.try_load_config(&self.user_config_path()).await {
            Ok(c) => {
                loaded_config = c;
                loaded_path = self.paths.user_config_path.to_path_buf();
            }
            Err(e) => {
                warn!("Failed to load user config: {}", e);
                loaded_config = self.try_load_config(&self.factory_config_path()).await?;
                loaded_path = self.paths.factory_config_path.to_path_buf();
            }
        }
        match self.validate_with_schema(&loaded_config).await {
            Ok(_) => {
                self.device_config = Some(serde_json::from_value(loaded_config).map_err(|e| {
                    error::NetworkManager::CONFIG(error::Config::FailedToDeserializeConfig {
                        path: String::from(loaded_path.to_string_lossy()),
                        error: e.to_string(),
                    })
                })?);
                self.startup_path = Some(loaded_path);
                return self.final_validation().await;
            }
            Err(e) => Err(e),
        }
    }

    /// Attempts to load a given configuration file.
    ///
    /// Returns the [`serde_json::Value`] of the loaded configuration file. It is important to note
    /// that if the config fails further validation then it will not be used.
    ///
    /// # Errors
    ///
    /// If the config file does not exist, cannot be read, or is not a file, then an error result
    /// of `ConfigNotLoaded` will be returned.
    ///
    /// If the loaded configuration fails to deserialize, then an error result of
    /// `FailedToDeserializeConfig` will be returned.
    async fn try_load_config(&self, config_path: &Path) -> error::Result<Value> {
        info!("Trying to load from: {}", String::from(config_path.to_string_lossy()));
        if config_path.is_file() {
            let mut contents = String::new();
            let mut f = File::open(config_path).map_err(|e| {
                error::NetworkManager::CONFIG(error::Config::ConfigNotLoaded {
                    path: String::from(config_path.to_string_lossy()),
                    error: e.to_string(),
                })
            })?;
            f.read_to_string(&mut contents).map_err(|e| {
                error::NetworkManager::CONFIG(error::Config::ConfigNotLoaded {
                    path: String::from(config_path.to_string_lossy()),
                    error: e.to_string(),
                })
            })?;
            // Note that counter to intuition it is faster to read the full configuration file
            // into memory and deserialize it using serde_json::from_str(), than using
            // serde_json::from_reader(), see: https://github.com/serde-rs/json/issues/160.
            let json: Value = serde_json::from_str(&contents).map_err(|e| {
                error::NetworkManager::CONFIG(error::Config::FailedToDeserializeConfig {
                    path: String::from(config_path.to_string_lossy()),
                    error: e.to_string(),
                })
            })?;
            return Ok(json);
        }
        Err(error::NetworkManager::CONFIG(error::Config::ConfigNotFound {
            path: String::from(config_path.to_string_lossy()),
        }))
    }

    /// Ensure that the configuration validates against the device schema.
    ///
    /// # Errors
    ///
    /// If the actual device schema fails to load, then Valico will emit an appropriate error
    /// message that can be used to fix device schema errors.
    ///
    /// If the config does not validate against the device schema, then an error result
    /// `FailedToValidateConfig` will be returned providing information with what went wrong.
    async fn validate_with_schema(&self, config: &Value) -> error::Result<()> {
        info!("Validating config against the device schema");
        let device_schema = self.try_load_config(&self.device_schema_path()).await?;
        let mut scope = json_schema::Scope::new();
        let schema = scope.compile_and_return(device_schema, false).map_err(|e| {
            error!("Failed to validate schema: {:?}", e);
            error::NetworkManager::CONFIG(error::Config::FailedToValidateConfig {
                path: String::from(self.device_schema_path().to_string_lossy()),
                error: schema_error(e),
            })
        })?;
        // Use the JSON Schema to give the JSON config some formal structure, but we need to
        // do most of the validation ourselves.
        let result = schema.validate(config);
        if !result.is_strictly_valid() {
            let mut err_msgs = Vec::new();
            for e in &result.errors {
                err_msgs.push(format!("{} at {}", e.get_title(), e.get_path()).into_boxed_str());
            }
            for u in &result.missing {
                err_msgs.push(format!("Device Config missing: {}", u).into_boxed_str());
            }
            // The ordering in which valico emits these errors is unstable. Sort error messages so
            // that the resulting message is predictable.
            err_msgs.sort_unstable();
            return Err(error::NetworkManager::CONFIG(error::Config::FailedToValidateConfig {
                path: String::from(self.startup_path().to_string_lossy()),
                error: err_msgs.join(", "),
            }));
        }
        Ok(())
    }

    /// Validates an [`config::Interface`]'s configuration.
    ///
    /// An Interface definition is valid if it has exactly one configuration type (e.g.
    /// subinterface, switched_vlan, or routed_vlan).
    fn validate_interface_config(&self, intf: &Interface) -> error::Result<()> {
        // TODO(cgibson): Try using serde's 'externally tagged' enum representation to remove
        // this validation step: https://serde.rs/enum-representations.html
        if intf.subinterfaces.is_some()
            && intf.switched_vlan.is_none()
            && intf.routed_vlan.is_none()
        {
            return Ok(());
        } else if intf.switched_vlan.is_some()
            && intf.subinterfaces.is_none()
            && intf.routed_vlan.is_none()
        {
            return Ok(());
        } else if intf.routed_vlan.is_some()
            && intf.subinterfaces.is_none()
            && intf.switched_vlan.is_none()
        {
            return Ok(());
        }
        Err(error::NetworkManager::CONFIG(error::Config::FailedToValidateConfig {
            path: String::from(self.startup_path().to_string_lossy()),
            error: concat!(
                "Interface must be exactly one of either: ",
                "'subinterfaces', 'routed_vlan', or 'switched_vlan'"
            )
            .to_string(),
        }))
    }

    /// Validates a [`config::InterfaceType`].
    ///
    /// If an Interface's type is [`InterfaceType::IfUplink`], then the Interface must have a
    /// [`Interface::Subinterfaces`] definition.
    fn validate_interface_types(&self, intf: &Interface) -> error::Result<()> {
        match intf.config.interface_type {
            InterfaceType::IfUplink => {
                if intf.subinterfaces.is_none() {
                    return Err(error::NetworkManager::CONFIG(
                        error::Config::FailedToValidateConfig {
                            path: String::from(self.startup_path().to_string_lossy()),
                            error:
                                "Interface type is 'IF_UPLINK' but does not define a 'subinterface'"
                                    .to_string(),
                        },
                    ));
                }
                if let Some(subifs) = intf.subinterfaces.as_ref() {
                    self.validate_subinterfaces(subifs)?;
                }
            }
            InterfaceType::IfRoutedVlan => {
                if intf.routed_vlan.is_none() {
                    return Err(error::NetworkManager::CONFIG(
                        error::Config::FailedToValidateConfig {
                            path: String::from(self.startup_path().to_string_lossy()),
                            error: concat!(
                                "Interface type is 'IF_ROUTED_VLAN' but does ",
                                "not define a 'routed_vlan'"
                            )
                            .to_string(),
                        },
                    ));
                }
            }
            // Add additional type validation here.
            _ => return Ok(()),
        }
        Ok(())
    }

    /// Validates an [`config::IpAddress`].
    fn validate_ip_address(&self, addr: &IpAddress) -> error::Result<()> {
        let has_static = addr.ip.is_some() || addr.prefix_length.is_some();
        let valid_static = !(addr.ip.is_some() ^ addr.prefix_length.is_some());
        let dhcp = addr.dhcp_client.unwrap_or(false);
        let valid_xor = dhcp ^ has_static;
        if valid_xor && valid_static {
            Ok(())
        } else {
            Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                msg: format!("Invalid IpAddress configuration: {:?}", addr),
            }))
        }
    }

    /// Validates each [`config::Subinterface`].
    fn validate_subinterfaces(&self, subinterfaces: &Vec<Subinterface>) -> error::Result<()> {
        for subif in subinterfaces.into_iter() {
            if let Some(v4addr) = &subif.ipv4 {
                for a in v4addr.addresses.iter() {
                    self.validate_ip_address(&a)?;
                }
            }
            if let Some(v6addr) = &subif.ipv6 {
                for a in v6addr.addresses.iter() {
                    self.validate_ip_address(&a)?;
                }
            }
        }
        Ok(())
    }

    /// Validates an [`config::Interface`] configuration.
    fn validate_interface(&self, intf: &Interface) -> error::Result<()> {
        self.validate_interface_config(&intf)?;
        self.validate_interface_types(&intf)?;
        Ok(())
    }

    /// Performs an additional layer of validation checks that cannot be expressed in JSON Schema.
    async fn final_validation(&self) -> error::Result<()> {
        let mut intf_names = HashSet::new();
        let intfs = match self.interfaces() {
            Some(intfs) => intfs,
            None => {
                return Err(error::NetworkManager::CONFIG(error::Config::NotFound {
                    msg: format!("Config contains no interfaces"),
                }));
            }
        };
        for intfs in intfs.iter() {
            self.validate_interface(&intfs.interface)?;

            // Interface names must be unique.
            if intf_names.contains(&intfs.interface.config.name) {
                return Err(error::NetworkManager::CONFIG(error::Config::FailedToValidateConfig {
                    path: String::from(self.startup_path().to_string_lossy()),
                    error: format!(
                        "Duplicate interface names detected: '{}'",
                        intfs.interface.config.name
                    ),
                }));
            }
            intf_names.insert(intfs.interface.config.name.clone());
        }
        Ok(())
    }

    /// Returns [`config::Device`] from the config.
    pub fn device(&self) -> error::Result<&Device> {
        self.device_config.as_ref().map(|c| &c.device).ok_or_else(|| {
            error::NetworkManager::CONFIG(error::Config::NotFound {
                msg: format!("Device was not found yet. Is the config loaded?"),
            })
        })
    }

    /// Returns all the configured [`config::Interfaces`].
    pub fn interfaces(&self) -> Option<&Vec<Interfaces>> {
        self.device().ok().and_then(|x| x.interfaces.as_ref())
    }

    /// Returns the [`config::Interface`] that matches the device_id contained in `topo_path`.
    pub fn get_interface_by_device_id(&self, topo_path: &str) -> Option<&Interface> {
        if let Some(ifs) = self.interfaces() {
            for intfs in ifs.iter() {
                if let Some(d) = &intfs.interface.device_id {
                    if topo_path.contains(d.as_str()) {
                        return Some(&intfs.interface);
                    }
                }
            }
        }
        None
    }

    /// Returns `true` if the device id from the `topo_path` is an uplink.
    ///
    /// An "uplink" is defined by having an [`InterfaceType::IfUplink`] and having a "subinterface"
    /// definition.
    pub fn device_id_is_a_wan_uplink(&self, topo_path: &str) -> bool {
        self.get_interface_by_device_id(topo_path)
            .map(|intf| match intf.config.interface_type {
                InterfaceType::IfUplink => return intf.subinterfaces.is_some(),
                _ => return false,
            })
            .unwrap_or(false)
    }

    /// Returns the name of the WAN interface.
    pub fn get_wan_interface_name(&self, topo_path: &str) -> error::Result<String> {
        if self.device_id_is_a_wan_uplink(topo_path) {
            if let Some(intf) = self.get_interface_by_device_id(topo_path) {
                return Ok(intf.config.name.clone());
            }
        }
        Err(error::NetworkManager::CONFIG(error::Config::NotFound {
            msg: format!("Getting WAN interface name for {} failed.", topo_path),
        }))
    }

    /// Returns a tuple of IPv4 and IPv6 [`config::IpAddress`]'s for this interface.
    ///
    /// The 'switched_vlan' configuration does not support IP addressing, so any `Interface` that
    /// has a 'switched_vlan' configuration will return `None`.
    pub fn get_ip_address<'a>(
        &self,
        intf: &'a Interface,
    ) -> error::Result<(Option<&'a IpAddress>, Option<&'a IpAddress>)> {
        if let Some(subifs) = &intf.subinterfaces {
            if subifs.is_empty() {
                return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                    msg: format!("Interface must have at least one 'subinterface' definition"),
                }));
            }
            // TODO(cgibson): LIFProperties doesn't support vectors of IP addresses yet. fxb/42315.
            if subifs.len() != 1 {
                warn!("LIFProperties does not support multiple addresses yet.")
            }
            let subif = &subifs[0];
            let v4addr = subif.ipv4.as_ref().and_then(|c| c.addresses.iter().next());
            let v6addr = subif.ipv6.as_ref().and_then(|c| c.addresses.iter().next());
            return Ok((v4addr, v6addr));
        }
        Err(error::NetworkManager::CONFIG(error::Config::NotFound {
            msg: format!(
                "Could not find an IP config defined on the provided interface: {:?}",
                intf
            ),
        }))
    }

    /// Updates [`lifmgr::LIFProperties`] with the given IP address configuration.
    ///
    /// In an IPv4-only network, with DHCP client disabled, and no static IP address configuration,
    /// then there will be no address configured for this interface.
    ///
    /// In an IPv6-only network, we currently have no plans to support DHCPv6 and there is no
    /// static IPv6 address configuration, we will rely on SLAAC to get a V6 address.
    ///
    /// Blended V4/V6 networks with IPv4 DHCP client disabled and no static IP address will rely on
    /// SLAAC to get an IPv6 address.
    ///
    /// If `ipconfig` is `None` then it is the same as an IPv6-only network, we rely on SLAAC to get
    /// an address.
    fn set_ip_address_config(
        &self,
        properties: &mut lifmgr::LIFProperties,
        ipconfig: Option<&IpAddress>,
    ) {
        if let Some(c) = ipconfig {
            if let Some(dhcp_client) = c.dhcp_client {
                properties.dhcp = dhcp_client;
            }
            // TODO(42315): LIFProperties doesn't support IPv6 addresses yet.
            match (c.ip, c.prefix_length) {
                (Some(address), Some(prefix)) => {
                    properties.address = Some(lifmgr::LifIpAddr { address, prefix });
                }
                _ => {}
            }
        }

        // TODO(42315): LIF manager throws an error if both a DHCP client and a static IP address
        // configuration are set. We don't want to be generating invalid LIFProperties, so favor
        // the static IP configuration and turn off DHCP.
        if properties.dhcp && properties.address.is_some() {
            warn!("DHCP client and static IP cannot be configured at once: Disabling DHCP.");
            properties.dhcp = false;
        }
    }

    /// Returns a WAN-specific [`lifmgr::LIFProperties`] based on the running configuration.
    ///
    /// Configures the WAN uplink's LIFProperties, initially discovers the interface that contains
    /// matches the device ID from the topological path. Then sets the LIFProperties for the admin
    /// state of the interface as well as configures the IP address.
    pub fn create_wan_properties(&self, topo_path: &str) -> error::Result<lifmgr::LIFProperties> {
        let mut properties =
            crate::lifmgr::LIFProperties { enabled: true, dhcp: false, address: None };
        let intf = match self.get_interface_by_device_id(topo_path) {
            Some(x) => x,
            None => {
                return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                    msg: format!(
                        "Cannot find an Interface matching `device_id` from topo path: {}",
                        topo_path
                    ),
                }));
            }
        };
        let subifs = match &intf.subinterfaces {
            Some(subif) => subif,
            None => {
                return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                    msg: format!("An uplink must have a 'subinterface' configuration"),
                }));
            }
        };

        // TODO(42315): LIFProperties does not support multiple addresses yet.
        if subifs.len() != 1 {
            return Err(error::NetworkManager::CONFIG(error::Config::NotSupported {
                msg: format!("Multiple subinterfaces on a single interface are not supported"),
            }));
        }

        if let Some(subif) = subifs.get(0) {
            match subif.admin_state {
                Some(AdminState::Up) => {
                    properties.enabled = true;
                }
                Some(AdminState::Down) => {
                    warn!("WAN subinterface is admin down by config");
                    properties.enabled = false;
                }
                Some(AdminState::Testing) => {
                    warn!("Admin state 'TESTING' is not supported; defaulting to 'Up'");
                    properties.enabled = true;
                }
                _ => {
                    // Subinterface's are enabled by default.
                    properties.enabled = true;
                }
            }
        }

        let (v4addr, v6addr) = self.get_ip_address(intf)?;
        // TODO(42316): LIFProperties doesn't support IPv6 addresses yet.
        if v6addr.is_some() {
            warn!("Setting IPv6 addresses is not supported yet");
        }
        self.set_ip_address_config(&mut properties, v4addr);
        Ok(properties)
    }

    /// Returns a vector of [`config::Interface`]'s that contain a [`config::RoutedVlan`].
    ///
    /// If no `Interface`'s are defined as being a `RoutedVlan`, then this method will return an
    /// empty Iterator.
    ///
    /// If there are no interfaces configured, then this method returns `None`.
    pub fn get_routed_vlan_interfaces(&self) -> Option<impl Iterator<Item = &Interface>> {
        self.interfaces().map(|ifs| {
            ifs.iter().filter_map(|intfs| {
                if intfs.interface.routed_vlan.is_some() {
                    Some(&intfs.interface)
                } else {
                    None
                }
            })
        })
    }

    /// Returns the [`SwitchedVlan`] that matches the device id contained in `topo_path`.
    pub fn get_switched_vlan_by_device_id(&self, topo_path: &str) -> error::Result<&SwitchedVlan> {
        self.get_interface_by_device_id(topo_path)
            .and_then(|intf| intf.switched_vlan.as_ref())
            .ok_or_else(|| {
                error::NetworkManager::CONFIG(error::Config::NotFound {
                    msg: format!("Failed to find interface matching: {}", topo_path),
                })
            })
    }

    /// Returns `true` if `topo_path` resolves to a [`config::SwitchedVlan`].
    pub fn device_id_is_a_switched_vlan(&self, topo_path: &str) -> bool {
        self.get_switched_vlan_by_device_id(topo_path).is_ok()
    }

    /// Resolves a [`config::SwitchedVlan`] to it's [`config::RoutedVlan`] configuration.
    ///
    /// # Errors
    ///
    /// If the switched VLAN does not resolve to a routed VLAN, then a `NotFound` error will be
    /// returned.
    ///
    /// If the switched VLAN port does not have the correct configuration based on its interface
    /// mode, then a `Malformed` error will be returned.
    pub fn resolve_to_routed_vlans(
        &self,
        switched_vlan: &SwitchedVlan,
    ) -> error::Result<&RoutedVlan> {
        let mut switched_vlan_ids = Vec::new();
        match switched_vlan.interface_mode {
            InterfaceMode::Access => match switched_vlan.access_vlan {
                Some(vid) => switched_vlan_ids.push(vid),
                None => {
                    return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                        msg: format!(
                            "Expecting access port to have 'access_vlan': {:?}",
                            switched_vlan
                        ),
                    }));
                }
            },
            // TODO(cgibson): Implement trunk VLANs when netstack supports it.
            InterfaceMode::Trunk => {
                return Err(error::NetworkManager::CONFIG(error::Config::NotSupported {
                    msg: format!("Trunk VLANs are not supported yet."),
                }));
            }
        }
        if let Some(it) = self.get_routed_vlan_interfaces() {
            for intf in it {
                // Safe to unwrap() here because `get_routed_vlan_interfaces()` checked for us
                // already.
                let routed_vlan = intf.routed_vlan.as_ref().unwrap();
                if switched_vlan_ids.contains(&routed_vlan.vlan_id) {
                    return Ok(&routed_vlan);
                }
            }
        }
        Err(error::NetworkManager::CONFIG(error::Config::NotFound {
            msg: format!(
                "Switched VLAN port does not resolve to a routed VLAN: {:?}",
                switched_vlan
            ),
        }))
    }

    /// Checks that all `ports` resolve to a single [`config::RoutedVlan`].
    pub fn all_ports_have_same_bridge<'a>(
        &'a self,
        ports: impl Iterator<Item = error::Result<&'a SwitchedVlan>>,
    ) -> error::Result<&'a RoutedVlan> {
        let mut ports = ports.peekable();
        if ports.peek().is_none() {
            warn!("Provided list of ports was empty?");
            return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                msg: format!("Provided list of ports was empty?"),
            }));
        }
        let mut routed_vlan = None;
        for p in ports {
            let r = self.resolve_to_routed_vlans(p?)?;
            routed_vlan = match routed_vlan {
                None => Some(r),
                Some(v) => {
                    if v == r {
                        Some(r)
                    } else {
                        return Err(error::NetworkManager::CONFIG(error::Config::Malformed {
                            msg: format!(
                                "switched_vlan ports do not resolve to the same RoutedVlan"
                            ),
                        }));
                    }
                }
            }
        }
        routed_vlan.ok_or_else(|| {
            error::NetworkManager::CONFIG(error::Config::Malformed {
                msg: format!("switched_vlan ports do not resolve to the same RoutedVlan"),
            })
        })
    }

    /// Returns the name of the bridge.
    pub fn get_bridge_name(&self, target: &RoutedVlan) -> &str {
        self.get_routed_vlan_interfaces()
            .and_then(|mut vlan_ifs| {
                vlan_ifs.find_map(|intf| {
                    intf.routed_vlan.as_ref().and_then(|vlan| {
                        if vlan.vlan_id == target.vlan_id {
                            Some(intf.config.name.as_str())
                        } else {
                            None
                        }
                    })
                })
            })
            .unwrap_or(UNNAMED_BRIDGE)
    }

    /// Creates a new [`lifmgr::LIFProperties`] for the provided `RoutedVlan`.
    pub fn create_routed_vlan_properties(
        &self,
        bridge: &RoutedVlan,
    ) -> error::Result<lifmgr::LIFProperties> {
        let mut properties =
            crate::lifmgr::LIFProperties { enabled: true, dhcp: false, address: None };

        // TODO(42316): LIFProperties doesn't support IPv6 addresses yet.
        if bridge.ipv6.is_some() {
            warn!("Setting IPv6 addresses is not supported yet.");
        }
        bridge.ipv4.as_ref().and_then(|c| {
            if c.addresses.len() > 1 {
                warn!("Configuring multiple IPv4 addresses is not supported yet");
            }
            Some(())
        });
        let v4addr = bridge.ipv4.as_ref().and_then(|c| c.addresses.iter().next());
        self.set_ip_address_config(&mut properties, v4addr);

        // TODO(42316): Until LIFProperties supports IPv6 addresses, we have the possibility of
        // generating properties that do not have an IP configuration. Make sure that we have
        // at least DHCP client enabled.
        if !properties.dhcp && properties.address.is_none() {
            properties.dhcp = true;
        }
        Ok(properties)
    }

    /// Returns configured VLAN IDs for the given device that matches `topo_path`.
    ///
    /// If the interface is a `SwitchedVlan` then the VLAN IDs will be depend on if the interface
    /// mode is either a `trunk` or `access` port.
    ///
    /// If the interface is a `RoutedVlan` then the VLAN ID will be a vector of a single element
    /// containing the `routed_vlan`'s VLAN ID.
    ///
    /// If the interface is a `subinterface` then the vector will be empty.
    pub fn get_vlans(&self, topo_path: &str) -> Vec<u16> {
        let mut vids = Vec::new();
        if let Some(intf) = self.get_interface_by_device_id(topo_path) {
            match &intf.routed_vlan {
                Some(r) => {
                    // routed_vlan's have a single VLAN ID only.
                    return vec![r.vlan_id];
                }
                None => {}
            }

            match &intf.switched_vlan {
                Some(switched_vlan) => match switched_vlan.interface_mode {
                    InterfaceMode::Access => {
                        if let Some(access_vlan) =
                            intf.switched_vlan.as_ref().and_then(|x| x.access_vlan)
                        {
                            vids.push(access_vlan);
                        }
                    }
                    InterfaceMode::Trunk => {
                        if let Some(trunk_vlans) =
                            intf.switched_vlan.as_ref().and_then(|x| x.trunk_vlans.as_ref())
                        {
                            vids.extend(trunk_vlans.iter().cloned());
                        }
                    }
                },
                None => (),
            }
        }
        vids
    }

    /// Returns the [`config::Services`] definition.
    ///
    /// # Errors
    ///
    /// If there is no "services" definition in the configuration, returns a
    /// [`error::Config::NotFound`] error.
    fn get_services(&self) -> error::Result<&Services> {
        self.device()?.services.as_ref().ok_or(error::NetworkManager::CONFIG(
            error::Config::NotFound { msg: format!("'services' definition was not found") },
        ))
    }

    /// Returns the IP forwarding configuration.
    ///
    /// If IP forwarding is enabled in the config, then this method will return true.
    pub fn get_ip_forwarding_state(&self) -> bool {
        self.get_services()
            .ok()
            .and_then(|x| x.ip_forwarding.as_ref())
            .map(|i| i.enabled)
            .unwrap_or(false)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::error::NetworkManager::CONFIG;
    use fuchsia_async as fasync;
    use std::fs;

    fn create_test_config_no_paths() -> Config {
        Config::new("/user", "/factory", "/device_schema")
    }

    fn create_test_config(user_cfg: &str, factory_cfg: &str, device_schema: &str) -> Config {
        Config::new(user_cfg, factory_cfg, device_schema)
    }

    fn create_test_interface() -> Interface {
        Interface {
            config: InterfaceConfig {
                name: "test_eth".to_string(),
                interface_type: InterfaceType::IfEthernet,
            },
            ethernet: None,
            tcp_offload: None,
            device_id: Some("device_id".to_string()),
            oper_state: Some(OperState::Up),
            subinterfaces: Some(vec![Subinterface {
                admin_state: Some(AdminState::Up),
                ipv4: Some(IpAddressConfig {
                    addresses: vec![IpAddress {
                        dhcp_client: Some(true),
                        ip: None,
                        prefix_length: None,
                    }],
                }),
                ipv6: None,
            }]),
            switched_vlan: None,
            routed_vlan: None,
        }
    }

    fn build_full_config() -> DeviceConfig {
        DeviceConfig {
            device: Device {
                acls: None,
                interfaces: Some(vec![
                    Interfaces {
                        interface: Interface {
                            config: InterfaceConfig {
                                name: "wan".to_string(),
                                interface_type: InterfaceType::IfUplink,
                            },
                            oper_state: None,
                            device_id: Some("test_device_id".to_string()),
                            ethernet: None,
                            tcp_offload: None,
                            routed_vlan: None,
                            switched_vlan: None,
                            subinterfaces: Some(vec![Subinterface {
                                admin_state: Some(AdminState::Up),
                                ipv4: Some(IpAddressConfig {
                                    addresses: vec![IpAddress {
                                        dhcp_client: Some(false),
                                        ip: Some("127.0.0.1".parse().unwrap()),
                                        prefix_length: Some(32),
                                    }],
                                }),
                                ipv6: None,
                            }]),
                        },
                    },
                    Interfaces {
                        interface: Interface {
                            config: InterfaceConfig {
                                name: "bridge".to_string(),
                                interface_type: InterfaceType::IfRoutedVlan,
                            },
                            oper_state: None,
                            device_id: Some("routed_vlan".to_string()),
                            ethernet: None,
                            tcp_offload: None,
                            subinterfaces: None,
                            switched_vlan: None,
                            routed_vlan: Some(RoutedVlan {
                                vlan_id: 2,
                                ipv4: Some(IpAddressConfig {
                                    addresses: vec![IpAddress {
                                        dhcp_client: Some(false),
                                        ip: Some("192.168.0.1".parse().unwrap()),
                                        prefix_length: Some(32),
                                    }],
                                }),
                                ipv6: None,
                            }),
                        },
                    },
                    Interfaces {
                        interface: Interface {
                            config: InterfaceConfig {
                                name: "test_eth".to_string(),
                                interface_type: InterfaceType::IfEthernet,
                            },
                            oper_state: None,
                            device_id: Some("switched_vlan".to_string()),
                            ethernet: None,
                            tcp_offload: None,
                            subinterfaces: None,
                            switched_vlan: Some(SwitchedVlan {
                                interface_mode: InterfaceMode::Access,
                                access_vlan: Some(2),
                                trunk_vlans: None,
                            }),
                            routed_vlan: None,
                        },
                    },
                ]),
                services: Some(Services {
                    dhcp_server: None,
                    ip_forwarding: Some(IpForwarding { enabled: true }),
                }),
            },
        }
    }

    #[test]
    fn test_new() {
        let user_cfg = "/data/my/user.cfg";
        let factory_cfg = "/data/my/factory.cfg";
        let device_schema = "/data/my/device_schema.cfg";
        let test_config = create_test_config(user_cfg, factory_cfg, device_schema);

        assert_eq!(test_config.device_config.is_none(), true);
        assert_eq!(test_config.paths.user_config_path, Path::new(user_cfg).to_path_buf());
        assert_eq!(test_config.paths.factory_config_path, Path::new(factory_cfg).to_path_buf());
        assert_eq!(test_config.paths.device_schema_path, Path::new(device_schema).to_path_buf());
    }

    #[test]
    fn test_get_paths() {
        let user_cfg = "/data/my/user.cfg";
        let factory_cfg = "/data/my/factory.cfg";
        let device_schema = "/data/my/device_schema.cfg";
        let test_config = create_test_config(user_cfg, factory_cfg, device_schema);

        assert_eq!(test_config.device_config.is_none(), true);
        assert_eq!(test_config.user_config_path(), Path::new(user_cfg));
        assert_eq!(test_config.factory_config_path(), Path::new(factory_cfg));
        assert_eq!(test_config.device_schema_path(), Path::new(device_schema));
        assert_eq!(test_config.startup_path(), Path::new(""));
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_load_config_file() {
        let test_config = create_test_config_no_paths();

        // Missing config should raise an `error::Config::ConfigNotFound`.
        let doesntexist = String::from("/doesntexist");
        match test_config.try_load_config(Path::new(&doesntexist)).await {
            Err(CONFIG(error::Config::ConfigNotFound { path })) => {
                assert_eq!(doesntexist, path);
            }
            Ok(r) => panic!("Got unexpected 'Ok' result: {}", r),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // An invalid config should fail to deserialize.
        let invalid_empty = String::from("/pkg/data/invalid_empty.json");
        match test_config.try_load_config(Path::new(&invalid_empty)).await {
            Err(CONFIG(error::Config::FailedToDeserializeConfig { path, error: _ })) => {
                assert_eq!(invalid_empty, path);
            }
            Ok(r) => panic!("Got unexpected 'Ok' result: {}", r),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // A valid config should deserialize successfully.
        let valid_empty = String::from("/pkg/data/valid_empty.json");
        let contents = fs::read_to_string(&valid_empty)
            .expect(format!("Failed to open testdata file: {}", valid_empty).as_str());

        // The expected configuration should deserialize successfully.
        let expected_config: Value;
        match serde_json::from_str(&contents) {
            Ok(j) => expected_config = j,
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // The serde_json::Value's should match.
        match test_config.try_load_config(Path::new(&valid_empty)).await {
            Ok(j) => {
                assert_eq!(expected_config, j);
            }
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_validate_schema() {
        let test_config =
            create_test_config("/doesntmatter", "/doesntmatter", "/pkg/data/device_schema.json");

        let valid_config = r#"{
          "device": {
            "interfaces": [
              {
                "interface": {
                  "config": {
                    "name": "wan",
                    "type": "IF_UPLINK"
                  },
                  "subinterfaces": [
                      {
                        "ipv4": {
                          "addresses": [
                            {
                              "dhcp_client": false,
                              "ip": "1.1.1.1",
                              "prefix_length": 32
                            }
                          ]
                        }
                      }
                  ],
                  "device_id": "my_test_device"
                }
              }
            ]
          }
        }"#;
        let expected_config: Value;
        match serde_json::from_str(&valid_config) {
            Ok(j) => expected_config = j,
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // Make sure that the configuration actually validates.
        match test_config.validate_with_schema(&expected_config).await {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
    }

    #[test]
    fn verify_toulouse_factory_config() {
        let config_path = "/pkg/data/toulouse_factory_config.json";
        let mut contents = String::new();
        let mut f = File::open(config_path).unwrap();
        f.read_to_string(&mut contents).unwrap();
        let _deserialized_config: DeviceConfig = serde_json::from_str(&contents)
            .expect(format!("Failed to deserialized {}", config_path).as_ref());
    }

    #[test]
    fn verify_default_factory_config() {
        let config_path = "/pkg/data/default_factory_config.json";
        let mut contents = String::new();
        let mut f = File::open(config_path).unwrap();
        f.read_to_string(&mut contents).unwrap();
        let _deserialized_config: DeviceConfig = serde_json::from_str(&contents)
            .expect(format!("Failed to deserialized {}", config_path).as_ref());
    }

    #[test]
    fn test_validate_interface_types() {
        let test_config = create_test_config_no_paths();
        let mut intf = create_test_interface();

        // If the Interface type is `InterfaceType::IfUplink`, then there must be a 'subinterface'
        // defined.
        intf.config =
            InterfaceConfig { name: "test".to_string(), interface_type: InterfaceType::IfUplink };
        match test_config.validate_interface_types(&intf) {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {:?}", e),
        }

        // If the Interface type is `InterfaceType::IfRoutedVlan`, then there must be a
        // 'routed_vlan' defined. Anything else should fail.
        intf.config = InterfaceConfig {
            name: "test".to_string(),
            interface_type: InterfaceType::IfRoutedVlan,
        };
        match test_config.validate_interface_types(&intf) {
            Ok(_) => panic!("Got unexpected 'ok' result"),
            Err(_) => (),
        }
    }

    #[test]
    fn test_validate_interface_config() {
        let fake_factory_path = "/fake_factory_path";
        let test_config = create_test_config("/doesntmatter", fake_factory_path, "/doesntmatter");
        let mut intf = create_test_interface();

        // Should pass because an interface must have exactly one configuration.
        match test_config.validate_interface_config(&intf) {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {:?}", e),
        }

        // The following should all fail for the same reason as above, exactly one configuration
        // per interface.
        let routed_vlan = Some(RoutedVlan { vlan_id: 1, ipv4: None, ipv6: None });
        let switched_vlan = Some(SwitchedVlan {
            interface_mode: InterfaceMode::Access,
            access_vlan: None,
            trunk_vlans: None,
        });
        let subinterfaces = Subinterface { admin_state: None, ipv4: None, ipv6: None };

        intf.routed_vlan = routed_vlan.clone();
        intf.subinterfaces = Some(vec![subinterfaces.clone()]);
        intf.switched_vlan = switched_vlan.clone();
        let r = test_config.validate_interface_config(&intf);
        assert_eq!(true, r.is_err());

        intf.routed_vlan = None;
        intf.subinterfaces = Some(vec![subinterfaces.clone()]);
        intf.switched_vlan = switched_vlan.clone();
        let r = test_config.validate_interface_config(&intf);
        assert_eq!(true, r.is_err());

        intf.routed_vlan = routed_vlan.clone();
        intf.subinterfaces = None;
        intf.switched_vlan = switched_vlan.clone();
        let r = test_config.validate_interface_config(&intf);
        assert_eq!(true, r.is_err());

        intf.routed_vlan = routed_vlan.clone();
        intf.subinterfaces = Some(vec![subinterfaces.clone()]);
        intf.switched_vlan = None;
        let r = test_config.validate_interface_config(&intf);
        assert_eq!(true, r.is_err());

        intf.routed_vlan = None;
        intf.subinterfaces = None;
        intf.switched_vlan = None;
        let r = test_config.validate_interface_config(&intf);
        assert_eq!(true, r.is_err());
    }

    #[test]
    fn test_validate_subinterfaces() {
        let fake_factory_path = "/fake_factory_path";
        let test_config = create_test_config("/doesntmatter", fake_factory_path, "/doesntmatter");

        // Should not fail because `dhcp_client` is set to true.
        let test_subif = vec![Subinterface {
            admin_state: Some(AdminState::Up),
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress {
                    dhcp_client: Some(true),
                    ip: None,
                    prefix_length: None,
                }],
            }),
            ipv6: None,
        }];
        match test_config.validate_subinterfaces(&test_subif) {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // Should not fail with dhcp_client set to false, ip and prefix set to valid values.
        let test_subif = vec![Subinterface {
            admin_state: Some(AdminState::Up),
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress {
                    dhcp_client: Some(false),
                    ip: Some("127.0.0.1".parse().unwrap()),
                    prefix_length: Some(32),
                }],
            }),
            ipv6: None,
        }];
        match test_config.validate_subinterfaces(&test_subif) {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // Should fail with dhcp_client set to false, ip and prefix set to None.
        let test_subif = vec![Subinterface {
            admin_state: Some(AdminState::Up),
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress {
                    dhcp_client: Some(false),
                    ip: None,
                    prefix_length: None,
                }],
            }),
            ipv6: None,
        }];
        match test_config.validate_subinterfaces(&test_subif) {
            Err(CONFIG(error::Config::Malformed { msg: _ })) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
            Ok(_) => panic!("Got unexpected 'Ok' result!"),
        }

        // Should not fail with dhcp client set to None, ip, and prefx set to valid values.
        let test_subif = vec![Subinterface {
            admin_state: Some(AdminState::Up),
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress {
                    dhcp_client: None,
                    ip: Some("127.0.0.1".parse().unwrap()),
                    prefix_length: Some(32),
                }],
            }),
            ipv6: None,
        }];
        match test_config.validate_subinterfaces(&test_subif) {
            Ok(_) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }

        // Should fail because both dhcp_client and ip/prefix_len are None.
        let test_subif = vec![Subinterface {
            admin_state: Some(AdminState::Up),
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress { dhcp_client: None, ip: None, prefix_length: None }],
            }),
            ipv6: None,
        }];
        match test_config.validate_subinterfaces(&test_subif) {
            Err(CONFIG(error::Config::Malformed { msg: _ })) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
            Ok(_) => panic!("Got unexpected 'Ok' result!"),
        }
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_final_validation() {
        let mut test_config =
            create_test_config("/user", "/factory", "/pkg/data/device_schema.json");

        let valid_config = r#"{
          "device": {
            "interfaces": [
              {
                "interface": {
                  "config": {
                    "name": "wan",
                    "type": "IF_UPLINK"
                  },
                  "subinterfaces": [
                    {
                      "ipv4": {
                        "addresses": [
                          {
                            "dhcp_client": false,
                            "ip": "1.1.1.1",
                            "prefix_length": 32
                          }
                        ]
                      }
                    }
                  ],
                  "device_id": "my_test_device"
                }
              }
            ]
          }
        }"#;
        match serde_json::from_str(&valid_config) {
            Ok(j) => test_config.device_config = j,
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
        match test_config.final_validation().await {
            Ok(()) => (),
            Err(e) => panic!("Got unexpected error result: {:?}", e),
        }

        let invalid_config = r#"{
          "device": {
            "interfaces": [
              {
                "interface": {
                  "config": {
                    "name": "wan",
                    "type": "IF_UPLINK"
                  },
                  "subinterfaces": [
                    {
                      "ipv4": {
                        "addresses": [
                          {
                            "dhcp_client": false,
                            "ip": "1.1.1.1",
                            "prefix_length": 32
                          }
                        ]
                      }
                    }
                  ],
                  "device_id": "my_test_device"
                }
              },
              {
                "interface": {
                  "config": {
                    "name": "wan",
                    "type": "IF_UPLINK"
                  },
                  "routed_vlan": {
                    "vlan_id": 1
                  },
                  "subinterfaces": [
                    {
                      "ipv4": {
                        "addresses": [
                          {
                            "dhcp_client": false,
                            "ip": "1.1.1.1",
                            "prefix_length": 32
                          }
                        ]
                      }
                    }
                  ],
                  "device_id": "my_test_device"
                }
              }
            ]
          }
        }"#;
        match serde_json::from_str(&invalid_config) {
            Ok(j) => test_config.device_config = j,
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
        match test_config.final_validation().await {
            Ok(_) => panic!("Got unexpected 'ok' result"),
            Err(CONFIG(error::Config::FailedToValidateConfig { path: _, error: _ })) => (),
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
    }

    #[test]
    fn test_get_device() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.device() {
            Ok(d) => {
                assert_eq!(*d, build_full_config().device);
            }
            Err(e) => panic!("Got unexpected error result: {}", e),
        }
    }

    #[test]
    fn test_get_interfaces() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.interfaces() {
            Some(i) => {
                assert_eq!(*i, build_full_config().device.interfaces.unwrap());
            }
            None => panic!("Got unexpected 'None' option"),
        }
    }

    #[test]
    fn test_get_interface_by_device_id() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.get_interface_by_device_id("/dev/sys/pci/test_device_id/ethernet") {
            Some(i) => {
                let intfs = &build_full_config().device.interfaces.unwrap()[0];
                assert_eq!(*i, intfs.interface);
            }
            None => panic!("Got unexpected 'None' option"),
        }

        match test_config.get_interface_by_device_id("does_not_exist") {
            Some(_) => panic!("Got unexpected 'None' option"),
            None => (),
        }
    }

    #[test]
    fn test_device_id_is_a_wan_uplink() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.device_id_is_a_wan_uplink("/dev/sys/pci/test_device_id/ethernet") {
            true => (),
            false => panic!("Got unexpected 'false' value"),
        }

        match test_config.device_id_is_a_wan_uplink("does_not_exist") {
            true => panic!("Got unexpected 'false' value"),
            false => (),
        }
    }

    #[test]
    fn test_get_vlans() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let v = test_config.get_vlans("routed_vlan");
        assert_eq!(v, vec![2]);

        let v = test_config.get_vlans("test_device_id");
        let empty_vec: Vec<u16> = Vec::new();
        assert_eq!(v, empty_vec);
    }

    #[test]
    fn test_get_services() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let services = test_config.get_services();
        assert_eq!(*services.unwrap(), build_full_config().device.services.unwrap());
    }

    #[test]
    fn test_get_ip_forwarding() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        assert_eq!(test_config.get_ip_forwarding_state(), true);

        // removing the ip forwarding config should still return the default of false.
        test_config.device_config =
            Some(DeviceConfig { device: Device { acls: None, interfaces: None, services: None } });
        assert_eq!(test_config.get_ip_forwarding_state(), false);
    }

    #[test]
    fn test_set_ip_address_config() {
        let test_config = create_test_config_no_paths();
        let ipconfig = IpAddress {
            dhcp_client: Some(false),
            ip: Some("127.0.0.1".parse().unwrap()),
            prefix_length: Some(32),
        };
        let mut properties: lifmgr::LIFProperties =
            lifmgr::LIFProperties { enabled: false, dhcp: false, address: None };
        test_config.set_ip_address_config(&mut properties, Some(&ipconfig));
        // The set_ip_address_config() function should not decide if the LIFProperties are enabled
        // or not, that should come from the AdminState in the config. So we shouldn't alter the
        // `enabled` field.
        assert_eq!(properties.enabled, false);
        assert_eq!(properties.dhcp, false);
        assert_eq!(
            properties.address,
            Some(lifmgr::LifIpAddr { address: "127.0.0.1".parse().unwrap(), prefix: 32 })
        );

        // Make sure DHCP client can be enabled when no static IP configuration is present.
        let ipconfig = IpAddress { dhcp_client: Some(true), ip: None, prefix_length: None };
        let mut properties: lifmgr::LIFProperties =
            lifmgr::LIFProperties { enabled: true, dhcp: false, address: None };
        test_config.set_ip_address_config(&mut properties, Some(&ipconfig));
        assert_eq!(properties.enabled, true);
        assert_eq!(properties.dhcp, true);
        assert_eq!(properties.address, None);

        // Both DHCP client and static IP cannot be set simultaneously, make sure that DHCP client
        // is turned off when both are set.
        let ipconfig = IpAddress {
            dhcp_client: Some(true),
            ip: Some("127.0.0.1".parse().unwrap()),
            prefix_length: Some(32),
        };
        let mut properties: lifmgr::LIFProperties =
            lifmgr::LIFProperties { enabled: true, dhcp: false, address: None };
        test_config.set_ip_address_config(&mut properties, Some(&ipconfig));
        assert_eq!(properties.enabled, true);
        assert_eq!(properties.dhcp, false);
        assert_eq!(
            properties.address,
            Some(lifmgr::LifIpAddr { address: "127.0.0.1".parse().unwrap(), prefix: 32 })
        );
    }

    #[test]
    fn test_get_ip_address() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let intfs = build_full_config().device.interfaces.unwrap();
        let subif = &intfs[0].interface.subinterfaces.as_ref().unwrap()[0];
        let expected_addr = &subif.ipv4.as_ref().unwrap().addresses[0];
        match test_config.get_ip_address(&intfs[0].interface) {
            Ok((Some(v4addr), None)) => {
                assert_eq!(*v4addr, *expected_addr);
            }
            Ok(e) => panic!("Got unexpected result pair: {:?}", e),
            Err(e) => panic!("Got unexpected result pair: {:?}", e),
        }
    }

    #[test]
    fn test_create_wan_properties() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.create_wan_properties("test_device_id") {
            Ok(p) => {
                assert_eq!(p.enabled, true);
                assert_eq!(p.dhcp, false);
                assert_eq!(
                    p.address,
                    Some(lifmgr::LifIpAddr { address: "127.0.0.1".parse().unwrap(), prefix: 32 })
                );
            }
            Err(e) => panic!("Got unexpected result: {:?}", e),
        }
    }

    #[test]
    fn test_get_wan_interface_name() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        match test_config.get_wan_interface_name("") {
            Err(error::NetworkManager::CONFIG(error::Config::NotFound { msg: _ })) => (),
            Err(e) => panic!("Got unexpected 'Err' result: {}", e),
            Ok(r) => panic!("Got unexpected 'Ok' result: {}", r),
        }
        match test_config.get_wan_interface_name("bridge") {
            Ok(r) => panic!("Got unexpected 'Ok' result: {}", r),
            Err(error::NetworkManager::CONFIG(error::Config::NotFound { msg: _ })) => (),
            Err(e) => panic!("Got unexpected 'Err' result: {}", e),
        }
        let expected_name = "wan".to_string();
        match test_config.get_wan_interface_name("test_device_id") {
            Ok(r) => assert_eq!(r, expected_name),
            Err(e) => panic!("Got unexpected 'Err' result: {}", e),
        }
    }

    #[test]
    fn test_get_switched_vlan_by_device_id() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        assert_eq!(
            test_config.device_id_is_a_switched_vlan("/dev/foo/whatever/switched_vlan/test"),
            true
        );
    }

    #[test]
    fn test_get_routed_vlan_interfaces() {
        let mut test_config = create_test_config_no_paths();

        test_config.device_config = Some(build_full_config());
        match test_config.get_routed_vlan_interfaces() {
            Some(it) => {
                // Turn the iterator into a vector.
                let v: Vec<&Interface> = it.collect();
                // Check the length is correct.
                assert_eq!(v.len(), 1);
                // Check that the interface is the correct one.
                assert_eq!(v[0].device_id, Some("routed_vlan".to_string()),);
            }
            None => {
                panic!("Unexpected 'None' result: Expecting interface containing the RoutedVlan")
            }
        }

        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(DeviceConfig {
            device: Device {
                acls: None,
                interfaces: Some(vec![Interfaces {
                    interface: Interface {
                        config: InterfaceConfig {
                            name: "its_a_wan".to_string(),
                            interface_type: InterfaceType::IfUplink,
                        },
                        oper_state: None,
                        device_id: Some("not_a_routed_vlan".to_string()),
                        ethernet: None,
                        tcp_offload: None,
                        routed_vlan: None,
                        switched_vlan: None,
                        subinterfaces: None,
                    },
                }]),
                services: None,
            },
        });
        match test_config.get_routed_vlan_interfaces() {
            // If there is no RoutedVlan configured, then return an empty iterator.
            Some(it) => {
                let v: Vec<&Interface> = it.collect();
                assert_eq!(v.len(), 0);
            }
            None => panic!("Unexpected 'None' result: Was expecting an empty iterator"),
        };

        let mut test_config = create_test_config_no_paths();
        test_config.device_config =
            Some(DeviceConfig { device: Device { acls: None, interfaces: None, services: None } });
        match test_config.get_routed_vlan_interfaces() {
            // If there are no interfaces, then should return 'None'.
            Some(_) => panic!("Got unexpected 'Some' result: Was expecting 'None'"),
            None => (),
        };
    }

    #[test]
    fn test_resolve_to_routed_vlan() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let switched_vlan = SwitchedVlan {
            interface_mode: InterfaceMode::Access,
            access_vlan: Some(2),
            trunk_vlans: None,
        };

        let expected_if = test_config.get_routed_vlan_interfaces().unwrap().nth(0).unwrap();
        match test_config.resolve_to_routed_vlans(&switched_vlan) {
            Ok(r) => assert_eq!(expected_if.routed_vlan.as_ref().unwrap().vlan_id, r.vlan_id),
            Err(e) => panic!("Got unexpected 'Error' result: {}", e),
        }

        let new_sv = SwitchedVlan {
            interface_mode: InterfaceMode::Access,
            access_vlan: Some(4000),
            trunk_vlans: None,
        };
        let new_config = Some(DeviceConfig {
            device: Device {
                interfaces: Some(vec![Interfaces {
                    interface: Interface {
                        device_id: Some("doesntmatter".to_string()),
                        config: InterfaceConfig {
                            name: "doesntmatter".to_string(),
                            interface_type: InterfaceType::IfEthernet,
                        },
                        oper_state: None,
                        subinterfaces: None,
                        switched_vlan: Some(new_sv.clone()),
                        routed_vlan: None,
                        ethernet: None,
                        tcp_offload: None,
                    },
                }]),
                acls: None,
                services: None,
            },
        });
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = new_config;
        // Should fail because VLAN ID 4000 does not match the routed_vlan configuration.
        match test_config.resolve_to_routed_vlans(&new_sv) {
            Err(CONFIG(error::Config::NotFound { msg: _ })) => (),
            Err(e) => panic!("Got unexpected 'Error' result: {}", e),
            Ok(r) => panic!("Got unexpected 'Ok' result: {:?}", r),
        }
    }

    #[test]
    fn test_all_ports_have_same_bridge() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let sv = SwitchedVlan {
            interface_mode: InterfaceMode::Access,
            access_vlan: Some(2),
            trunk_vlans: None,
        };
        let vec_of_switched_vlans = vec![&sv, &sv, &sv];
        let routed_vlan = test_config
            .all_ports_have_same_bridge(vec_of_switched_vlans.into_iter().map(Result::Ok))
            .expect("got error");
        assert_eq!(routed_vlan.vlan_id, 2);
    }

    #[test]
    fn test_get_bridge_name() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let rvi = RoutedVlan { vlan_id: 2, ipv4: None, ipv6: None };
        assert_eq!(test_config.get_bridge_name(&rvi), "bridge".to_string());

        // bridge name should be the unnamed default.
        let rvi = RoutedVlan { vlan_id: 440, ipv4: None, ipv6: None };
        assert_eq!(test_config.get_bridge_name(&rvi), "unnamed_bridge".to_string());
    }

    #[test]
    fn test_create_routed_vlan_properties() {
        let mut test_config = create_test_config_no_paths();
        test_config.device_config = Some(build_full_config());
        let rvi = RoutedVlan {
            vlan_id: 2,
            ipv4: Some(IpAddressConfig {
                addresses: vec![IpAddress {
                    dhcp_client: Some(false),
                    ip: Some("192.168.0.1".parse().unwrap()),
                    prefix_length: Some(32),
                }],
            }),
            ipv6: None,
        };
        match test_config.create_routed_vlan_properties(&rvi) {
            Ok(p) => {
                assert_eq!(p.enabled, true);
                assert_eq!(p.dhcp, false);
                assert_eq!(
                    p.address,
                    Some(lifmgr::LifIpAddr { address: "192.168.0.1".parse().unwrap(), prefix: 32 })
                );
            }
            Err(e) => panic!("Got unexpected result: {:?}", e),
        }
    }
}