// 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::opts::*;
use crate::printer::Printer;
use anyhow::{format_err, Context as _, Error};
use fidl::endpoints::{Proxy, ServiceMarker};
use fidl_fuchsia_net::{Ipv4Address, Ipv6Address, MacAddress};
use fidl_fuchsia_overnet::{Peer, ServiceConsumerMarker, ServiceConsumerProxy};
use fidl_fuchsia_overnet_protocol::NodeId;
use fidl_fuchsia_router_config::{
    Credentials, FilterAction, FilterRule, FlowSelector, Id, L2tp, LanProperties, PortRange, Pppoe,
    Pptp, Protocol, RouterAdminMarker, RouterAdminProxy, RouterStateMarker, RouterStateProxy,
    SecurityFeatures, WanConnection, WanProperties,
};
use fuchsia_async::{self as fasync};
use fuchsia_component::client::connect_to_service;
use fuchsia_syslog as syslog;
use fuchsia_zircon::{self as zx};
use itertools::Itertools;
use std::convert::TryInto;
use std::io::Write;
use std::net::IpAddr;
use std::str;

/// Creates a `router_config::PortRange` from a port range string.
fn make_port_range(input_range: &str) -> Result<PortRange, Error> {
    let port_range = input_range
        .split('-')
        .map(|s| s.parse::<u16>())
        .filter_map(Result::ok)
        .collect::<Vec<u16>>();
    if port_range.len() != 2 {
        return Err(format_err!(
            "Invalid port range! Range is: 1 to 65535, with format: <from>-<to>"
        ));
    }
    if port_range[0] > port_range[1] {
        return Err(format_err!(
            "End of range must be less than or equal to start: {}-{}",
            port_range[0],
            port_range[1]
        ));
    }
    Ok(PortRange { from: port_range[0], to: port_range[1] })
}

/// Takes a string of port ranges as input, and produces a vector of `PortRange`'s as its output.
/// The format of `input_ranges` is: "<from>-<to>,<from>-<to>,...".
fn to_port_ranges(input_ranges: &str) -> Result<Vec<PortRange>, Error> {
    let (oks, fails): (Vec<_>, Vec<_>) =
        input_ranges.split(',').map(|range| make_port_range(range)).partition(Result::is_ok);
    if !fails.is_empty() {
        let errors: Vec<_> = fails.into_iter().map(Result::unwrap_err).collect();
        return Err(format_err!("Invalid port range: {:?}", errors));
    }
    Ok(oks.into_iter().map(Result::unwrap).collect::<Vec<PortRange>>())
}

pub fn connect() -> Result<(RouterAdminProxy, RouterStateProxy), Error> {
    let router_admin = connect_to_service::<RouterAdminMarker>()
        .context("failed to connect to network manager admin interface")?;
    let router_state = connect_to_service::<RouterStateMarker>()
        .context("failed to connect to network manager interface")?;
    Ok((router_admin, router_state))
}

fn connect_overnet_node(
    svc: &ServiceConsumerProxy,
    name: &str,
    node: &mut NodeId,
) -> Result<fasync::Channel, Error> {
    let (ch0, ch1) = zx::Channel::create()?;
    svc.connect_to_service(node, name, ch0)?;
    fasync::Channel::from_channel(ch1).map_err(|e| e.into())
}

fn supports_network_manager(peer: &Peer) -> bool {
    match peer.description.services {
        None => false,
        Some(ref services) => [RouterAdminMarker::NAME, RouterStateMarker::NAME]
            .iter()
            .map(|svc| services.contains(&svc.to_string()))
            .all(|v| v),
    }
}

pub async fn connect_overnet() -> Result<(RouterAdminProxy, RouterStateProxy), Error> {
    let svc = connect_to_service::<ServiceConsumerMarker>()?;
    syslog::fx_log_info!("looking for overnet peers...");
    loop {
        for mut peer in svc.list_peers().await? {
            if !supports_network_manager(&peer) {
                continue;
            }
            match (
                connect_overnet_node(&svc, &RouterAdminMarker::NAME, &mut peer.id),
                connect_overnet_node(&svc, &RouterStateMarker::NAME, &mut peer.id),
            ) {
                (Err(_), _) | (_, Err(_)) => {
                    continue;
                }
                (Ok(router_admin_channel), Ok(router_state_channel)) => {
                    syslog::fx_log_info!("connected to peer {:?}", peer.id.id);
                    return Ok((
                        RouterAdminProxy::from_channel(router_admin_channel),
                        RouterStateProxy::from_channel(router_state_channel),
                    ));
                }
            }
        }
    }
}

pub fn make_cmd(command: &str) -> Result<Command, Error> {
    let mut args = command.split_whitespace().collect::<Vec<&str>>();
    // `from_*` methods silently drop the first element of the vector, since that is /usually/
    // the program name.
    args.insert(0, "cli_test");
    let opts = Opt::from_iter_safe(args.into_iter())?;
    Ok(opts.cmd)
}

pub async fn run_cmd<T: Write>(
    cmd: Command,
    router_admin: RouterAdminProxy,
    router_state: RouterStateProxy,
    printer: &mut Printer<T>,
) -> Result<(), Error> {
    match cmd {
        Command::ADD(cmd) => do_add(cmd, router_admin, printer).await,
        Command::SHOW(cmd) => do_show(cmd, router_state, printer).await,
        Command::SET(cmd) => do_set(cmd, router_admin, printer).await,
        Command::REMOVE(cmd) => do_remove(cmd, router_admin, printer).await,
    }
}

/// do_add function handles subcommands for adding WAN and LAN interfaces
async fn do_add<T: Write>(
    cmd: Add,
    router_admin: RouterAdminProxy,
    printer: &mut Printer<T>,
) -> Result<(), Error> {
    match cmd {
        Add::Wan { name, ports, vlan } => {
            let response = match vlan {
                None => router_admin
                    .create_wan(&name, 0, &ports)
                    .await
                    .context("error getting response")?,
                Some(vlan) => router_admin
                    .create_wan(&name, vlan, &ports)
                    .await
                    .context("error getting response")?,
            };
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Add::Lan { name, vlan, ports } => {
            let response = match vlan {
                None => router_admin
                    .create_lan(&name, 0, &ports)
                    .await
                    .context("error getting response")?,
                Some(vlan) => router_admin
                    .create_lan(&name, vlan, &ports)
                    .await
                    .context("error getting response")?,
            };
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
    }
}

/// do_remove function handles subcommands for removing LAN and WAN interfaces
async fn do_remove<T: Write>(
    cmd: Remove,
    router_admin: RouterAdminProxy,
    printer: &mut Printer<T>,
) -> Result<(), Error> {
    match cmd {
        Remove::Wan { mut wan_id } => {
            let response =
                router_admin.remove_wan(&mut wan_id).await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Remove::Lan { mut lan_id } => {
            let response =
                router_admin.remove_lan(&mut lan_id).await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
    }
}

/// do_show function handles subcommands for getting interfaces, ports and configuration
async fn do_show<T: Write>(
    cmd: Show,
    router_state: RouterStateProxy,
    printer: &mut Printer<T>,
) -> Result<(), Error> {
    match cmd {
        Show::Wan { mut wan_id } => {
            let response =
                router_state.get_wan(&mut wan_id).await.context("error getting response")?;
            printer.println(format!("{:?}", response));
            Ok(())
        }

        Show::Lan { mut lan_id } => {
            let response =
                router_state.get_lan(&mut lan_id).await.context("error getting response")?;
            printer.println(format!("{:?}", response));
            Ok(())
        }

        Show::WanConfig { mut wan_id } => {
            let response = router_state
                .get_wan_properties(&mut wan_id)
                .await
                .context("error getting response")?;
            printer.println(format!("{:?} Response: {:?}", wan_id, response));
            Ok(())
        }

        Show::Port { port } => {
            let response = router_state.get_port(port).await.context("error getting response")?;
            printer.println(format!("{:?} Response: {:?}", port, response));
            Ok(())
        }

        Show::LanConfig { mut lan_id } => {
            let response = router_state
                .get_lan_properties(&mut lan_id)
                .await
                .context("error getting response")?;
            printer.println(format!("{:?} Response: {:?}", lan_id, response));
            Ok(())
        }

        Show::DnsConfig {} => {
            let response =
                router_state.get_dns_resolver().await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Show::DhcpConfig { lan_id } => {
            printer.println(format!("{:?}", lan_id));
            Ok(())
        }

        Show::ForwardState { lan_id } => {
            printer.println(format!("{:?}", lan_id));
            Ok(())
        }

        Show::FilterState {} => {
            let response = router_state.get_filters().await.context("error getting response")?;
            printer.println(format!("{} filters installed", response.len()));
            printer.println(format!("{:?}", response));
            Ok(())
        }

        Show::Wans {} => {
            let response = router_state
                .get_wans()
                .await
                .context("error getting response")?
                .into_iter()
                .map(|mut l| {
                    l.port_ids.as_mut().map(|x| x.sort());
                    l
                })
                .sorted_by_key(|a| a.element.map_or(0, |id| u128::from_ne_bytes(id.uuid)))
                .collect_vec();
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Show::Lans {} => {
            let response = router_state
                .get_lans()
                .await
                .context("error getting response")?
                .into_iter()
                .map(|mut l| {
                    l.port_ids.as_mut().map(|x| x.sort());
                    l
                })
                .sorted_by_key(|a| a.element.map_or(0, |id| u128::from_ne_bytes(id.uuid)))
                .collect_vec();
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Show::WanPorts { mut wan_id } => {
            let mut response =
                router_state.get_wan_ports(&mut wan_id).await.context("error getting response")?;
            response.0.sort();
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Show::LanPorts { mut lan_id } => {
            let mut response =
                router_state.get_lan_ports(&mut lan_id).await.context("error getting response")?;
            response.0.sort();
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        // TODO: Implement pretty_print
        Show::Ports {} => {
            let mut response = router_state.get_ports().await.context("error getting response")?;
            response.sort_by_key(|a| a.path.clone());
            for port in response {
                printer.println(format!("{:?}", port));
            }
            Ok(())
        }

        Show::Routes {} => {
            let response = router_state.get_routes().await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Show::Security {} => {
            let response =
                router_state.get_security_features().await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
    }
}

/// do_set function handles several subcommands that are used for setting wan and lan properties
async fn do_set<T: Write>(
    cmd: Set,
    router_admin: RouterAdminProxy,
    printer: &mut Printer<T>,
) -> Result<(), Error> {
    // wan_properties contains all the wan related configs that are sent to the server
    let mut wan_properties = WanProperties {
        connection_type: None,
        connection_parameters: None,
        address_method: None,
        address_v4: None,
        gateway_v4: None,
        connection_v6_mode: None,
        address_v6: None,
        gateway_v6: None,
        hostname: None,
        clone_mac: None,
        mtu: None,
        enable: None,
        metric: None,
    };
    // lan_properties contains all the lan related configs that are sent to the server
    let mut lan_properties = LanProperties {
        address_v4: None,
        enable_dhcp_server: None,
        dhcp_config: None,
        address_v6: None,
        enable_dns_forwarder: None,
        enable: None,
    };
    // This match statement populates the specified wan_properties field based on the subcommand
    // and calls the appropriate FIDL interface with the requested configuration changes. It then
    // receives the response and prints it for the CLI user
    match cmd {
        // TODO: Do the validation for "state" in opts.rs using enums
        // This subcommand handles state change request for a specific the WAN interface
        Set::WanState { mut wan_id, state } => {
            // Populating the "wan_properties.enable" field based on the user input
            wan_properties.enable = match state.as_ref() {
                "up" => Some(true),
                "down" => Some(false),
                _ => return Err(format_err!("Please provide a valid state: \"up\" or \"down\"")),
            };
            // Sending the request to the FIDL server and receiving the response
            // This can eventually be its own function with a "pretty print" feature
            printer.println(format!("Sending: {:?}", wan_properties));
            let response = router_admin
                .set_wan_properties(&mut wan_id, wan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
        // TODO: Do the validation for "connection" in opts.rs using enums
        // This subcommand sets the connection type for a specific WAN interface
        Set::WanConnection { mut wan_id, connection, username, password, server, metric, mtu } => {
            wan_properties.metric = metric;
            wan_properties.mtu = mtu;
            match connection {
                Some(m) => {
                    // This match statement populates the appropriate fields for wan_properties
                    // based on the requested connection type
                    match m.as_ref() {
                        // Following handles the cases for direct connection configuration
                        "direct" => {
                            wan_properties.connection_type = Some(WanConnection::Direct);
                        }
                        // Handling pppoe connection configuration
                        "pppoe" => {
                            if username.is_none() {
                                return Err(format_err!(
                                    "No username provided for PPPOE connection"
                                ));
                            }
                            if password.is_none() {
                                return Err(format_err!(
                                    "No password provided for PPPOE connection"
                                ));
                            }
                            wan_properties.connection_type = Some(WanConnection::PpPoE);
                            let pppoe_config = Pppoe {
                                credentials: Some(Credentials { user: username, password }),
                            };
                            // Applying the configurations to the wan_properties data structure
                            wan_properties.connection_parameters =
                                Some(fidl_fuchsia_router_config::ConnectionParameters::Pppoe(
                                    pppoe_config,
                                ));
                        }
                        // Handling pptp connection configuration
                        "pptp" => {
                            if username.is_none() {
                                return Err(format_err!(
                                    "No username provided for PPTP connection"
                                ));
                            }
                            if password.is_none() {
                                return Err(format_err!(
                                    "No password provided for PPTP connection"
                                ));
                            }
                            if server.is_none() {
                                return Err(format_err!(
                                    "No server IP provided for PPTP connection"
                                ));
                            }
                            // Configuring connection type
                            wan_properties.connection_type = Some(WanConnection::Pptp);
                            // Wrapping the server ip address in the Ipv4Address structure
                            let server_ipv4 = Ipv4Address { addr: server.unwrap().octets() };
                            // Wrapping username and password in "Credentials" structure and
                            // constructing the Pptp structure
                            let pptp_config = Pptp {
                                credentials: Some(Credentials { user: username, password }),
                                server: Some(fidl_fuchsia_net::IpAddress::Ipv4(server_ipv4)),
                            };
                            wan_properties.connection_parameters = Some(
                                fidl_fuchsia_router_config::ConnectionParameters::Pptp(pptp_config),
                            );
                        }
                        // handling l2tp connection configuration
                        "l2tp" => {
                            if username.is_none() {
                                return Err(format_err!(
                                    "No username provided for L2TP connection"
                                ));
                            }
                            if password.is_none() {
                                return Err(format_err!(
                                    "No password provided for L2TP connection"
                                ));
                            }
                            if server.is_none() {
                                return Err(format_err!(
                                    "No server IP provided for L2TP connection"
                                ));
                            }
                            wan_properties.connection_type = Some(WanConnection::L2Tp);
                            let server_ipv4 = Ipv4Address { addr: server.unwrap().octets() };
                            let l2tp_config = L2tp {
                                credentials: Some(Credentials { user: username, password }),
                                server: Some(fidl_fuchsia_net::IpAddress::Ipv4(server_ipv4)),
                            };
                            wan_properties.connection_parameters = Some(
                                fidl_fuchsia_router_config::ConnectionParameters::L2tp(l2tp_config),
                            );
                        }
                        _ => {
                            return Err(format_err!(
                            "Please provide a valid connection type: direct, pppoe, pptp or l2tp"
                        ))
                        }
                    }
                }
                None => {
                    if metric.is_none() && mtu.is_none() {
                        return Err(format_err!("Please either provide a valid connection type: direct/pppoe/pptp/l2tp or use an optional flag. For help, try \"set wan-connection --help\""));
                    }
                }
            }

            printer.println(format!("Sending: {:?}", wan_properties));
            let response = router_admin
                .set_wan_properties(&mut wan_id, wan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
        // This subcommand sets the IP configuration, dhcp, manual, etc... and sets an optional hostname
        Set::WanIp { mut wan_id, mode, ipv4, gateway, hostname } => {
            match mode {
                Some(m) => {
                    match m.as_ref() {
                        // handling DHCP IP configuration
                        "dhcp" => {
                            if ipv4.is_some() {
                                return Err(format_err!(
                                    "Cannot provide IP address when enabling dhcp"
                                ));
                            }
                            if gateway.is_some() {
                                return Err(format_err!(
                                    "Cannot provide gateway IP aadress when enabling dhcp"
                                ));
                            }
                            // Setting the address_method option of wan_properties to automatic
                            wan_properties.address_method =
                                Some(fidl_fuchsia_router_config::WanAddressMethod::Automatic);
                        }
                        // handling manual IP configuration
                        "manual" => {
                            // The ipv4 field is in CIDR notation form and it has to be split into an IP address and a prefix before being sent to server
                            let (ipv4_address, prefix_length) = match ipv4 {
                                Some(m) => (Ipv4Address { addr: m.address.octets() }, m.prefix),
                                None => {
                                    return Err(format_err!(
                                        "No IP address provided for manual config"
                                    ))
                                }
                            };
                            // Extracting the gateway IP from Ipv4Addr struct
                            let gateway_ipv4 = match gateway {
                                Some(m) => Ipv4Address { addr: m.octets() },
                                None => {
                                    return Err(format_err!(
                                        "No gateway IP address provided for manual config"
                                    ))
                                }
                            };
                            // Setting the address_method option of wan_properties to manual
                            wan_properties.address_method =
                                Some(fidl_fuchsia_router_config::WanAddressMethod::Manual);
                            // Populating "address_v4" using the extracted IP address and the prefix
                            wan_properties.address_v4 =
                                Some(fidl_fuchsia_router_config::CidrAddress {
                                    address: Some(fidl_fuchsia_net::IpAddress::Ipv4(ipv4_address)),
                                    prefix_length: Some(prefix_length),
                                });
                            // gateway_v4 is of type IpAddress::Ipv4, which is constructed using the gateway_ipv4
                            wan_properties.gateway_v4 =
                                Some(fidl_fuchsia_net::IpAddress::Ipv4(gateway_ipv4));
                        }
                        _ => {
                            return Err(format_err!(
                                "Please provide a valid IP configuration: dhcp or manual"
                            ))
                        }
                    }
                }
                None => {
                    if hostname.is_none() {
                        return Err(format_err!("Please either provide a valid connection method: manual/dhcp or use an optional flag"));
                    }
                }
            }
            // Setting the hostname in case this was provided
            wan_properties.hostname = hostname;
            printer.println(format!("Sending: {:?}", wan_properties));
            let response = router_admin
                .set_wan_properties(&mut wan_id, wan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        // This subcommand sets the MAC address for a specific WAN interface
        Set::WanCloneMac { mut wan_id, mac } => {
            wan_properties.clone_mac = Some(MacAddress { octets: mac.to_array() });
            printer.println(format!("Sending: {:?}", wan_properties));
            let response = router_admin
                .set_wan_properties(&mut wan_id, wan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("{:?}", response));
            Ok(())
        }

        // TODO: Do the validation for "state" in opts.rs using enums
        // This subcommand handles state change request for a specific LAN interface
        Set::LanState { mut lan_id, state } => {
            // Populating the "enable" field based on the user input
            match state.as_ref() {
                "up" => {
                    lan_properties.enable = Some(true);
                }
                "down" => {
                    lan_properties.enable = Some(false);
                }
                _ => return Err(format_err!("Please provide a valid state: up or down")),
            }
            printer.println(format!("Sending: {:?} ID: {:?}", lan_properties, lan_id));
            let response = router_admin
                .set_lan_properties(&mut lan_id, lan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Set::LanIp { mut lan_id, ipv4 } => {
            // The ipv4 field is in CIDR notation form and it has to be split into an IP address and a prefix
            let (ipv4_address, prefix_length) = match ipv4 {
                Some(m) => (Ipv4Address { addr: m.address.octets() }, m.prefix),
                None => return Err(format_err!("No IP address provided for manual config")),
            };
            // Populating "address_v4" using the extracted IP address and the prefix
            lan_properties.address_v4 = Some(fidl_fuchsia_router_config::CidrAddress {
                address: Some(fidl_fuchsia_net::IpAddress::Ipv4(ipv4_address)),
                prefix_length: Some(prefix_length),
            });

            printer.println(format!("Sending: {:?} ID: {:?}", lan_properties, lan_id));
            let response = router_admin
                .set_lan_properties(&mut lan_id, lan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        // TODO: Do the validation for "state" in opts.rs using enums
        Set::LanDhcp { mut lan_id, state, lease_time_sec, gateway } => {
            // Populating the "enable_dhcp_server" field based on the user input
            match state.as_ref() {
                "up" => {
                    lan_properties.enable_dhcp_server = Some(true);
                }
                "down" => {
                    lan_properties.enable_dhcp_server = Some(false);
                }
                _ => return Err(format_err!("Please provide a valid state: up or down")),
            }

            // TODO: Populate these fields with the values received from the user
            if lease_time_sec.is_some() {}
            if gateway.is_some() {}

            printer.println(format!("Sending: {:?} ID: {:?}", lan_properties, lan_id));
            let response = router_admin
                .set_lan_properties(&mut lan_id, lan_properties)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Set::DhcpConfig { lan_id, dhcp_config } => {
            printer.println(format!("Not Implemented {:?}, {:?}", lan_id, dhcp_config));
            Ok(())
        }

        Set::DnsConfig { server } => {
            printer.println(format!("Sending: {:?}", server));
            let servers = match server {
                IpAddr::V4(address) => {
                    vec![fidl_fuchsia_net::IpAddress::Ipv4(Ipv4Address { addr: address.octets() })]
                }
                IpAddr::V6(address) => {
                    vec![fidl_fuchsia_net::IpAddress::Ipv6(Ipv6Address { addr: address.octets() })]
                }
            };

            let mut config = fidl_fuchsia_router_config::DnsResolverConfig {
                element: Id { uuid: [0; 16], version: 0 },
                policy: fidl_fuchsia_router_config::DnsPolicy::NotSet,
                search: fidl_fuchsia_router_config::DnsSearch { domain_name: None, servers },
            };
            let response = router_admin.set_dns_resolver(&mut config).await;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Set::DnsForwarder { lan_id, enabled } => {
            printer.println(format!("Not Implemented {:?}, {:?}", lan_id, enabled));
            Ok(())
        }

        Set::Route { route } => {
            printer.println(format!("Not Implemented {:?}", route));
            Ok(())
        }

        Set::SecurityConfig { feature, enabled } => {
            let mut security_features = SecurityFeatures {
                pptp_passthru: None,
                l2_tp_passthru: None,
                ipsec_passthru: None,
                rtsp_passthru: None,
                h323_passthru: None,
                sip_passthru: None,
                allow_multicast: None,
                nat: None,
                firewall: None,
                v6_firewall: None,
                upnp: None,
                drop_icmp_echo: None,
            };
            printer.println(format!(
                "Setting security feature: {:?}, enabled: {:?}",
                feature, enabled
            ));
            match feature {
                SecurityFeature::NAT => security_features.nat = Some(enabled),
                // TODO(cgibson): Support more security features.
            }
            let response = router_admin
                .set_security_features(security_features)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Set::PortForward { rule } => {
            printer.println(format!("Not Implemented {:?}", rule));
            Ok(())
        }

        Set::Filter {
            action,
            src_address,
            src_port_range,
            dst_address,
            dst_port_range,
            protocol,
        } => {
            if src_address.is_none() && dst_address.is_none() {
                return Err(format_err!(
                    "Must provide at least a 'src_address' or a 'dst_address'"
                ));
            }
            let mut filter_rule = FilterRule {
                element: Id { uuid: [0; 16], version: 0 },
                action: match action.as_ref() {
                    "allow" => FilterAction::Allow,
                    "drop" => FilterAction::Drop,
                    _ => {
                        return Err(format_err!("Filter action must be: 'allow' or 'drop'"));
                    }
                },
                selector: FlowSelector {
                    src_address: match src_address {
                        Some(src_addr) => Some(src_addr.try_into()?),
                        None => None,
                    },
                    dst_address: match dst_address {
                        Some(dst_addr) => Some(dst_addr.try_into()?),
                        None => None,
                    },
                    src_ports: match src_port_range {
                        Some(ranges) => Some(to_port_ranges(&ranges)?),
                        None => None,
                    },
                    dst_ports: match dst_port_range {
                        Some(ranges) => Some(to_port_ranges(&ranges)?),
                        None => None,
                    },
                    protocol: match protocol {
                        Some(proto) => match proto.as_ref() {
                            "tcp" => Some(Protocol::Tcp),
                            "udp" => Some(Protocol::Udp),
                            "both" => Some(Protocol::Both),
                            _ => {
                                return Err(format_err!(
                                    "Protocol choices are: 'tcp', 'udp', or 'both'"
                                ))
                            }
                        },
                        None => Some(Protocol::Both),
                    },
                },
            };
            let response = router_admin
                .set_filter(&mut filter_rule)
                .await
                .context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }

        Set::DeleteFilter { mut rule_id } => {
            let response =
                router_admin.delete_filter(&mut rule_id).await.context("error getting response")?;
            printer.println(format!("Response: {:?}", response));
            Ok(())
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_output_to_buffer() {
        let mut printer = Printer::new(Vec::new());
        let msg = "Hello, World!";
        let newline = "\n";
        printer.println("".into());
        printer.println(msg.to_string());
        printer.println(msg.to_string());
        assert_eq!(
            // TODO(cgibson): Figure out a way to add this as a helper method on `Printer`.
            str::from_utf8(&printer.into_inner().unwrap()).unwrap().to_string(),
            format!("{}{}{}{}{}", newline, msg, newline, msg, newline)
        );
    }

    #[test]
    fn test_to_port_ranges() {
        let from = "22";
        let to = "222";
        let port_range = to_port_ranges(format!("{}-{}", from, to).as_ref()).unwrap()[0];
        assert_eq!(port_range.from, from.parse::<u16>().unwrap());
        assert_eq!(port_range.to, to.parse::<u16>().unwrap());

        let from = "22";
        let to = "22";
        let port_range = to_port_ranges(format!("{}-{}", from, to).as_ref()).unwrap()[0];
        assert_eq!(port_range.from, from.parse::<u16>().unwrap());
        assert_eq!(port_range.to, to.parse::<u16>().unwrap());

        let port_ranges = to_port_ranges("20-21,25-25").unwrap();
        let errors = port_ranges.iter().filter(|port_range| {
            if (port_range.from == 20 && port_range.to == 21)
                || (port_range.from == 25 && port_range.to == 25)
            {
                false
            } else {
                true
            }
        });
        assert_eq!(errors.count(), 0);

        let port_range = to_port_ranges("80,");
        assert_eq!(port_range.is_err(), true);

        let port_range = to_port_ranges("-");
        assert_eq!(port_range.is_err(), true);

        let from = "222";
        let to = "22";
        let port_range = to_port_ranges(format!("{}-{}", from, to).as_ref());
        assert_eq!(port_range.is_err(), true);

        let from = "abc";
        let to = "22";
        let port_range = to_port_ranges(format!("{}-{}", from, to).as_ref());
        assert_eq!(port_range.is_err(), true);
    }
}