// Copyright 2018 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::configuration::{ClientConfig, ServerConfig};
use crate::protocol::{self, ConfigOption, Message, MessageType, OpCode, OptionCode};
use byteorder::{BigEndian, ByteOrder};
use fidl_fuchsia_hardware_ethernet_ext::MacAddress as MacAddr;
use std::cmp;
use std::collections::{BTreeSet, HashMap, HashSet};
use std::net::Ipv4Addr;
use std::ops::Fn;

/// A minimal DHCP server.
///
/// This comment will be expanded upon in future CLs as the server design
/// is iterated upon.
pub struct Server<F>
where
    F: Fn() -> i64,
{
    cache: CachedClients,
    pool: AddressPool,
    config: ServerConfig,
    time_provider: F,
}

impl<F> Server<F>
where
    F: Fn() -> i64,
{
    /// Returns an initialized `Server` value.
    pub fn new(time_provider: F) -> Server<F> {
        Server {
            cache: HashMap::new(),
            pool: AddressPool::new(),
            config: ServerConfig::new(),
            time_provider: time_provider,
        }
    }

    /// Instantiates a `Server` value from the provided `ServerConfig`.
    pub fn from_config(config: ServerConfig, time_provider: F) -> Server<F> {
        let mut server = Server {
            cache: HashMap::new(),
            pool: AddressPool::new(),
            config: config,
            time_provider: time_provider,
        };
        server.pool.load_pool(&server.config.managed_addrs);
        server
    }

    /// Dispatches an incoming DHCP message to the appropriate handler for processing.
    ///
    /// If the incoming message is a valid client DHCP message, then the server will attempt to
    /// take appropriate action to serve the client's request, update the internal server state,
    /// and return a response message. If the incoming message is invalid, or the server is
    /// unable to serve the request, then `dispatch()` will return `None`.
    pub fn dispatch(&mut self, msg: Message) -> Option<Message> {
        match msg.get_dhcp_type() {
            Some(MessageType::DHCPDISCOVER) => self.handle_discover(msg),
            Some(MessageType::DHCPOFFER) => None,
            Some(MessageType::DHCPREQUEST) => self.handle_request(msg),
            Some(MessageType::DHCPDECLINE) => self.handle_decline(msg),
            Some(MessageType::DHCPACK) => None,
            Some(MessageType::DHCPNAK) => None,
            Some(MessageType::DHCPRELEASE) => self.handle_release(msg),
            Some(MessageType::DHCPINFORM) => self.handle_inform(msg),
            None => None,
        }
    }

    fn handle_discover(&mut self, disc: Message) -> Option<Message> {
        let client_config = self.client_config(&disc);
        let offered_ip = self.get_addr(&disc)?;
        let mut offer = build_offer(disc, &self.config, &client_config);
        offer.yiaddr = offered_ip;
        self.update_server_cache(
            Ipv4Addr::from(offer.yiaddr),
            offer.chaddr,
            vec![],
            &client_config,
        );

        Some(offer)
    }

    fn get_addr(&mut self, client: &Message) -> Option<Ipv4Addr> {
        if let Some(config) = self.cache.get(&client.chaddr) {
            if !config.expired((self.time_provider)()) {
                // Free cached address so that it can be reallocated to same client.
                self.pool.free_addr(config.client_addr);
                return Some(config.client_addr);
            } else if self.pool.addr_is_available(config.client_addr) {
                return Some(config.client_addr);
            }
        }
        if let Some(opt) = client.get_config_option(OptionCode::RequestedIpAddr) {
            if opt.value.len() >= 4 {
                let requested_addr = protocol::ip_addr_from_buf_at(&opt.value, 0)
                    .expect("out of range indexing on opt.value");
                if self.pool.addr_is_available(requested_addr) {
                    return Some(requested_addr);
                }
            }
        }
        self.pool.get_next_available_addr()
    }

    fn update_server_cache(
        &mut self, client_addr: Ipv4Addr, client_mac: MacAddr, client_opts: Vec<ConfigOption>,
        client_config: &ClientConfig,
    ) {
        let config = CachedConfig {
            client_addr: client_addr,
            options: client_opts,
            expiration: (self.time_provider)() + client_config.lease_time_s as i64,
        };
        self.cache.insert(client_mac, config);
        self.pool.allocate_addr(client_addr);
    }

    fn handle_request(&mut self, req: Message) -> Option<Message> {
        match get_client_state(&req) {
            ClientState::Selecting => self.handle_request_selecting(req),
            ClientState::InitReboot => self.handle_request_init_reboot(req),
            ClientState::Renewing => self.handle_request_renewing(req),
            ClientState::Unknown => None,
        }
    }

    fn handle_request_selecting(&mut self, req: Message) -> Option<Message> {
        let requested_ip = req.ciaddr;
        if !is_recipient(self.config.server_ip, &req) || !self.is_assigned(&req, requested_ip) {
            return None;
        }
        Some(build_ack(req, requested_ip, &self.config))
    }

    fn is_assigned(&self, req: &Message, requested_ip: Ipv4Addr) -> bool {
        if let Some(client_config) = self.cache.get(&req.chaddr) {
            client_config.client_addr == requested_ip
                && !client_config.expired((self.time_provider)())
                && self.pool.addr_is_allocated(requested_ip)
        } else {
            false
        }
    }

    fn handle_request_init_reboot(&mut self, req: Message) -> Option<Message> {
        let requested_ip = get_requested_ip_addr(&req)?;
        if !is_in_subnet(requested_ip, &self.config) {
            return Some(build_nak(req, &self.config));
        }
        if !is_client_mac_known(req.chaddr, &self.cache) {
            return None;
        }
        if !self.is_assigned(&req, requested_ip) {
            return Some(build_nak(req, &self.config));
        }
        Some(build_ack(req, requested_ip, &self.config))
    }

    fn handle_request_renewing(&mut self, req: Message) -> Option<Message> {
        let client_ip = req.ciaddr;
        if !self.is_assigned(&req, client_ip) {
            return None;
        }
        Some(build_ack(req, client_ip, &self.config))
    }

    fn handle_decline(&mut self, dec: Message) -> Option<Message> {
        let declined_ip = get_requested_ip_addr(&dec)?;
        if is_recipient(self.config.server_ip, &dec) && !self.is_assigned(&dec, declined_ip) {
            self.pool.allocate_addr(declined_ip);
        }
        self.cache.remove(&dec.chaddr);
        None
    }

    fn handle_release(&mut self, rel: Message) -> Option<Message> {
        if self.cache.contains_key(&rel.chaddr) {
            self.pool.free_addr(rel.ciaddr);
        }
        None
    }

    fn handle_inform(&mut self, inf: Message) -> Option<Message> {
        // When responding to an INFORM, the server must leave yiaddr zeroed.
        let yiaddr = Ipv4Addr::new(0, 0, 0, 0);
        let mut ack = build_ack(inf, yiaddr, &self.config);
        ack.options.clear();
        add_inform_ack_options(&mut ack, &self.config);
        Some(ack)
    }

    /// Releases all allocated IP addresses whose leases have expired back to
    /// the pool of addresses available for allocation.
    pub fn release_expired_leases(&mut self) {
        let now = (self.time_provider)();
        let expired_clients: Vec<(MacAddr, Ipv4Addr)> = self
            .cache
            .iter()
            .filter(|(_mac, config)| config.expired(now))
            .map(|(mac, config)| (*mac, config.client_addr))
            .collect();
        // Expired client entries must be removed in a separate statement because otherwise we
        // would be attempting to change a cache as we iterate over it.
        expired_clients.iter().for_each(|(mac, ip)| {
            self.pool.free_addr(*ip);
            self.cache.remove(mac);
        });
    }

    pub fn client_config(&self, client_message: &Message) -> ClientConfig {
        let requested_config = client_message.parse_to_config();
        ClientConfig {
            lease_time_s: match requested_config.lease_time_s {
                None => self.config.default_lease_time,
                Some(t) => cmp::min(t, self.config.max_lease_time_s),
            },
        }
    }
}

/// A cache mapping clients to their configuration data.
///
/// The server should store configuration data for all clients
/// to which it has sent a DHCPOFFER message. Entries in the cache
/// will eventually timeout, although such functionality is currently
/// unimplemented.
type CachedClients = HashMap<MacAddr, CachedConfig>;

#[derive(Clone, Debug, PartialEq)]
struct CachedConfig {
    client_addr: Ipv4Addr,
    options: Vec<ConfigOption>,
    expiration: i64,
}

impl Default for CachedConfig {
    fn default() -> Self {
        CachedConfig {
            client_addr: Ipv4Addr::new(0, 0, 0, 0),
            options: vec![],
            expiration: std::i64::MAX,
        }
    }
}

impl CachedConfig {
    fn expired(&self, now: i64) -> bool {
        self.expiration <= now
    }
}

/// The pool of addresses managed by the server.
///
/// Any address managed by the server should be stored in only one
/// of the available/allocated sets at a time. In other words, an
/// address in `available_addrs` must not be in `allocated_addrs` and
/// vice-versa.
#[derive(Debug)]
struct AddressPool {
    // available_addrs uses a BTreeSet so that addresses are allocated
    // in a deterministic order.
    available_addrs: BTreeSet<Ipv4Addr>,
    allocated_addrs: HashSet<Ipv4Addr>,
}

impl AddressPool {
    fn new() -> Self {
        AddressPool {
            available_addrs: BTreeSet::new(),
            allocated_addrs: HashSet::new(),
        }
    }

    fn load_pool(&mut self, addrs: &[Ipv4Addr]) {
        for addr in addrs {
            if !self.allocated_addrs.contains(&addr) {
                self.available_addrs.insert(*addr);
            }
        }
    }

    fn get_next_available_addr(&self) -> Option<Ipv4Addr> {
        let mut iter = self.available_addrs.iter();
        match iter.next() {
            Some(addr) => Some(*addr),
            None => None,
        }
    }

    fn allocate_addr(&mut self, addr: Ipv4Addr) {
        if self.available_addrs.remove(&addr) {
            self.allocated_addrs.insert(addr);
        } else {
            panic!("Invalid Server State: attempted to allocate unavailable address");
        }
    }

    fn free_addr(&mut self, addr: Ipv4Addr) {
        if self.allocated_addrs.remove(&addr) {
            self.available_addrs.insert(addr);
        } else {
            panic!("Invalid Server State: attempted to free unallocated address");
        }
    }

    fn addr_is_available(&self, addr: Ipv4Addr) -> bool {
        self.available_addrs.contains(&addr) && !self.allocated_addrs.contains(&addr)
    }

    fn addr_is_allocated(&self, addr: Ipv4Addr) -> bool {
        !self.available_addrs.contains(&addr) && self.allocated_addrs.contains(&addr)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ClientState {
    Unknown,
    Selecting,
    InitReboot,
    Renewing,
}

fn build_offer(client: Message, config: &ServerConfig, client_config: &ClientConfig) -> Message {
    let mut offer = client;
    offer.op = OpCode::BOOTREPLY;
    offer.secs = 0;
    offer.ciaddr = Ipv4Addr::new(0, 0, 0, 0);
    offer.siaddr = Ipv4Addr::new(0, 0, 0, 0);
    offer.sname = String::new();
    offer.file = String::new();
    add_required_options(&mut offer, config, client_config, MessageType::DHCPOFFER);
    add_recommended_options(&mut offer, config);

    offer
}

fn add_required_options(
    msg: &mut Message, config: &ServerConfig, client_config: &ClientConfig, msg_type: MessageType,
) {
    msg.options.clear();
    let mut lease = vec![0; 4];
    BigEndian::write_u32(&mut lease, client_config.lease_time_s);
    msg.options.push(ConfigOption {
        code: OptionCode::IpAddrLeaseTime,
        value: lease,
    });
    msg.options.push(ConfigOption {
        code: OptionCode::DhcpMessageType,
        value: vec![msg_type.into()],
    });
    msg.options.push(ConfigOption {
        code: OptionCode::ServerId,
        value: config.server_ip.octets().to_vec(),
    });
}

fn add_recommended_options(msg: &mut Message, config: &ServerConfig) {
    msg.options.push(ConfigOption {
        code: OptionCode::Router,
        value: ip_vec_to_bytes(&config.routers),
    });
    msg.options.push(ConfigOption {
        code: OptionCode::NameServer,
        value: ip_vec_to_bytes(&config.name_servers),
    });
    let mut renewal_time = vec![0, 0, 0, 0];
    BigEndian::write_u32(&mut renewal_time, config.default_lease_time / 2);
    msg.options.push(ConfigOption {
        code: OptionCode::RenewalTime,
        value: renewal_time,
    });
    let mut rebinding_time = vec![0, 0, 0, 0];
    BigEndian::write_u32(&mut rebinding_time, config.default_lease_time / 4);
    msg.options.push(ConfigOption {
        code: OptionCode::RebindingTime,
        value: rebinding_time,
    });
}

fn add_inform_ack_options(msg: &mut Message, config: &ServerConfig) {
    msg.options.push(ConfigOption {
        code: OptionCode::DhcpMessageType,
        value: vec![MessageType::DHCPINFORM.into()],
    });
    msg.options.push(ConfigOption {
        code: OptionCode::ServerId,
        value: config.server_ip.octets().to_vec(),
    });
    msg.options.push(ConfigOption {
        code: OptionCode::Router,
        value: ip_vec_to_bytes(&config.routers),
    });
    msg.options.push(ConfigOption {
        code: OptionCode::NameServer,
        value: ip_vec_to_bytes(&config.name_servers),
    });
}

fn ip_vec_to_bytes<'a, T>(ips: T) -> Vec<u8>
where
    T: IntoIterator<Item = &'a Ipv4Addr>,
{
    ips.into_iter()
        .flat_map(|ip| ip.octets().to_vec())
        .collect()
}

fn is_recipient(server_ip: Ipv4Addr, req: &Message) -> bool {
    if let Some(server_id) = get_server_id_from(&req) {
        return server_id == server_ip;
    }
    false
}

fn build_ack(req: Message, requested_ip: Ipv4Addr, config: &ServerConfig) -> Message {
    let mut ack = req;
    ack.op = OpCode::BOOTREPLY;
    ack.secs = 0;
    ack.yiaddr = requested_ip;
    ack.options.clear();
    add_required_options(
        &mut ack,
        config,
        &ClientConfig::new(config.default_lease_time),
        MessageType::DHCPACK,
    );
    add_recommended_options(&mut ack, config);

    ack
}

fn is_in_subnet(ip: Ipv4Addr, config: &ServerConfig) -> bool {
    apply_subnet_mask_to(config.subnet_mask, ip)
        == apply_subnet_mask_to(config.subnet_mask, config.server_ip)
}

fn is_client_mac_known(mac: MacAddr, cache: &CachedClients) -> bool {
    cache.get(&mac).is_some()
}

fn build_nak(req: Message, config: &ServerConfig) -> Message {
    let mut nak = req;
    nak.op = OpCode::BOOTREPLY;
    nak.secs = 0;
    nak.ciaddr = Ipv4Addr::new(0, 0, 0, 0);
    nak.yiaddr = Ipv4Addr::new(0, 0, 0, 0);
    nak.siaddr = Ipv4Addr::new(0, 0, 0, 0);
    nak.options.clear();
    let mut lease = vec![0; 4];
    BigEndian::write_u32(&mut lease, config.default_lease_time);
    nak.options.push(ConfigOption {
        code: OptionCode::DhcpMessageType,
        value: vec![MessageType::DHCPNAK.into()],
    });
    nak.options.push(ConfigOption {
        code: OptionCode::ServerId,
        value: config.server_ip.octets().to_vec(),
    });

    nak
}

fn get_client_state(msg: &Message) -> ClientState {
    let maybe_server_id = get_server_id_from(&msg);
    let maybe_requested_ip = get_requested_ip_addr(&msg);
    let zero_ciaddr = Ipv4Addr::new(0, 0, 0, 0);

    if maybe_server_id.is_some() && maybe_requested_ip.is_none() && msg.ciaddr != zero_ciaddr {
        return ClientState::Selecting;
    } else if maybe_requested_ip.is_some() && msg.ciaddr == zero_ciaddr {
        return ClientState::InitReboot;
    } else if msg.ciaddr != zero_ciaddr {
        return ClientState::Renewing;
    } else {
        return ClientState::Unknown;
    }
}

fn get_requested_ip_addr(req: &Message) -> Option<Ipv4Addr> {
    let req_ip_opt = req
        .options
        .iter()
        .find(|opt| opt.code == OptionCode::RequestedIpAddr)?;
    let raw_ip = BigEndian::read_u32(&req_ip_opt.value);
    Some(Ipv4Addr::from(raw_ip))
}

fn get_server_id_from(req: &Message) -> Option<Ipv4Addr> {
    let server_id_opt = req
        .options
        .iter()
        .find(|opt| opt.code == OptionCode::ServerId)?;
    let raw_server_id = BigEndian::read_u32(&server_id_opt.value);
    Some(Ipv4Addr::from(raw_server_id))
}

fn apply_subnet_mask_to(prefix_len: u8, ip_addr: Ipv4Addr) -> Ipv4Addr {
    assert!(prefix_len < 32);
    let subnet_mask_bits = ::std::u32::MAX << (32 - prefix_len);
    let ip_addr_bits = BigEndian::read_u32(&ip_addr.octets());
    Ipv4Addr::from(ip_addr_bits & subnet_mask_bits)
}

#[cfg(test)]
mod tests {

    use super::*;
    use crate::protocol::{ConfigOption, Message, MessageType, OpCode, OptionCode};
    use std::net::Ipv4Addr;

    fn new_test_server<F>(time_provider: F) -> Server<F>
    where
        F: Fn() -> i64,
    {
        let mut server = Server::new(time_provider);
        server.config.server_ip = Ipv4Addr::new(192, 168, 1, 1);
        server.config.default_lease_time = 100;
        server.config.routers.push(Ipv4Addr::new(192, 168, 1, 1));
        server
            .config
            .name_servers
            .extend_from_slice(&vec![Ipv4Addr::new(8, 8, 8, 8), Ipv4Addr::new(8, 8, 4, 4)]);
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::from([192, 168, 1, 2]));
        server
    }

    fn new_test_discover() -> Message {
        let mut disc = Message::new();
        disc.xid = 42;
        disc.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        disc.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPDISCOVER.into()],
        });
        disc
    }

    fn new_test_offer() -> Message {
        let mut offer = Message::new();
        offer.op = OpCode::BOOTREPLY;
        offer.xid = 42;
        offer.yiaddr = Ipv4Addr::new(192, 168, 1, 2);
        offer.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        offer.options.push(ConfigOption {
            code: OptionCode::IpAddrLeaseTime,
            value: vec![0, 0, 0, 100],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPOFFER.into()],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::Router,
            value: vec![192, 168, 1, 1],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::NameServer,
            value: vec![8, 8, 8, 8, 8, 8, 4, 4],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::RenewalTime,
            value: vec![0, 0, 0, 50],
        });
        offer.options.push(ConfigOption {
            code: OptionCode::RebindingTime,
            value: vec![0, 0, 0, 25],
        });
        offer
    }

    fn new_test_request() -> Message {
        let mut req = Message::new();
        req.xid = 42;
        req.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        req.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![192, 168, 1, 2],
        });
        req.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPREQUEST.into()],
        });
        req.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        req
    }

    fn new_test_ack() -> Message {
        let mut ack = Message::new();
        ack.op = OpCode::BOOTREPLY;
        ack.xid = 42;
        ack.yiaddr = Ipv4Addr::new(192, 168, 1, 2);
        ack.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        ack.options.push(ConfigOption {
            code: OptionCode::IpAddrLeaseTime,
            value: vec![0, 0, 0, 100],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPACK.into()],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::Router,
            value: vec![192, 168, 1, 1],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::NameServer,
            value: vec![8, 8, 8, 8, 8, 8, 4, 4],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::RenewalTime,
            value: vec![0, 0, 0, 50],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::RebindingTime,
            value: vec![0, 0, 0, 25],
        });
        ack
    }

    fn new_test_nak() -> Message {
        let mut nak = Message::new();
        nak.op = OpCode::BOOTREPLY;
        nak.xid = 42;
        nak.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        nak.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPNAK.into()],
        });
        nak.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        nak
    }

    fn new_test_release() -> Message {
        let mut release = Message::new();
        release.xid = 42;
        release.ciaddr = Ipv4Addr::new(192, 168, 1, 2);
        release.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        release.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPRELEASE.into()],
        });
        release
    }

    fn new_test_inform() -> Message {
        let mut inform = Message::new();
        inform.xid = 42;
        inform.ciaddr = Ipv4Addr::new(192, 168, 1, 2);
        inform.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        inform.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPINFORM.into()],
        });
        inform
    }

    fn new_test_inform_ack() -> Message {
        let mut ack = Message::new();
        ack.op = OpCode::BOOTREPLY;
        ack.xid = 42;
        ack.ciaddr = Ipv4Addr::new(192, 168, 1, 2);
        ack.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        ack.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPINFORM.into()],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::Router,
            value: vec![192, 168, 1, 1],
        });
        ack.options.push(ConfigOption {
            code: OptionCode::NameServer,
            value: vec![8, 8, 8, 8, 8, 8, 4, 4],
        });
        ack
    }

    fn new_test_decline() -> Message {
        let mut decline = Message::new();
        decline.xid = 42;
        decline.chaddr = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        decline.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPDECLINE.into()],
        });
        decline.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![192, 168, 1, 2],
        });
        decline.options.push(ConfigOption {
            code: OptionCode::ServerId,
            value: vec![192, 168, 1, 1],
        });
        decline
    }

    #[test]
    fn test_dispatch_with_discover_returns_correct_response() {
        let disc = new_test_discover();

        let mut server = new_test_server(|| 42);
        let got = server.dispatch(disc).unwrap();

        let want = new_test_offer();

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_discover_updates_server_state() {
        let disc = new_test_discover();
        let mac_addr = disc.chaddr;
        let mut server = new_test_server(|| 42);
        let _ = server.dispatch(disc).unwrap();

        assert_eq!(server.pool.available_addrs.len(), 0);
        assert_eq!(server.pool.allocated_addrs.len(), 1);
        assert_eq!(server.cache.len(), 1);
        let want_config = server.cache.get(&mac_addr).unwrap();
        assert_eq!(want_config.client_addr, Ipv4Addr::new(192, 168, 1, 2));
    }

    #[test]
    fn test_dispatch_with_discover_client_binding_returns_bound_addr() {
        let disc = new_test_discover();
        let mut server = new_test_server(|| 42);
        let mut client_config = CachedConfig::default();
        let client_addr = Ipv4Addr::new(192, 168, 1, 42);
        client_config.client_addr = client_addr;
        server.pool.allocated_addrs.insert(client_addr);
        server.cache.insert(disc.chaddr, client_config);

        let got = server.dispatch(disc).unwrap();

        let mut want = new_test_offer();
        want.yiaddr = Ipv4Addr::new(192, 168, 1, 42);

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_discover_expired_client_binding_returns_available_old_addr() {
        let disc = new_test_discover();
        let mut server = new_test_server(|| 42);
        let mut client_config = CachedConfig::default();
        client_config.client_addr = Ipv4Addr::new(192, 168, 1, 42);
        client_config.expiration = 0;
        server.cache.insert(disc.chaddr, client_config);
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 42));

        let got = server.dispatch(disc).unwrap();

        let mut want = new_test_offer();
        want.yiaddr = Ipv4Addr::new(192, 168, 1, 42);

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_discover_unavailable_expired_client_binding_returns_new_addr() {
        let disc = new_test_discover();
        let mut server = new_test_server(|| 42);
        let mut client_config = CachedConfig::default();
        client_config.client_addr = Ipv4Addr::new(192, 168, 1, 42);
        client_config.expiration = 0;
        server.cache.insert(disc.chaddr, client_config);
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 42));

        let got = server.dispatch(disc).unwrap();

        let mut want = new_test_offer();
        want.yiaddr = Ipv4Addr::new(192, 168, 1, 2);

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_discover_available_requested_addr_returns_requested_addr() {
        let mut disc = new_test_discover();
        disc.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![192, 168, 1, 3],
        });

        let mut server = new_test_server(|| 42);
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 3));
        let got = server.dispatch(disc).unwrap();

        let mut want = new_test_offer();
        want.yiaddr = Ipv4Addr::new(192, 168, 1, 3);
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_discover_unavailable_requested_addr_returns_next_addr() {
        let mut disc = new_test_discover();
        disc.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![192, 168, 1, 42],
        });

        let mut server = new_test_server(|| 42);
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server
            .pool
            .available_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 3));
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 42));
        let got = server.dispatch(disc).unwrap();

        let mut want = new_test_offer();
        want.yiaddr = Ipv4Addr::new(192, 168, 1, 2);
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_valid_selecting_request_returns_ack() {
        let mut req = new_test_request();
        let requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        req.ciaddr = requested_ip_addr;
        req.options.remove(0);

        let mut server = new_test_server(|| 42);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(requested_ip_addr);
        let got = server.dispatch(req).unwrap();

        let mut want = new_test_ack();
        want.ciaddr = requested_ip_addr;
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_no_address_allocation_to_client_returns_none() {
        let mut req = new_test_request();
        req.ciaddr = Ipv4Addr::new(192, 168, 1, 2);
        req.options.remove(0);

        let mut server = new_test_server(|| 42);
        let got = server.dispatch(req);

        assert!(got.is_none());
    }

    #[test]
    fn test_dispatch_with_selecting_request_wrong_server_id_returns_none() {
        let mut req = new_test_request();
        let requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        req.ciaddr = requested_ip_addr;
        req.options.remove(0);

        let mut server = new_test_server(|| 42);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(requested_ip_addr);
        server.config.server_ip = Ipv4Addr::new(1, 2, 3, 4);
        let got = server.dispatch(req);

        assert!(got.is_none());
    }

    #[test]
    fn test_dispatch_with_selecting_request_valid_selecting_request_maintains_server_invariants() {
        let requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        let mut req = new_test_request();
        req.ciaddr = requested_ip_addr;
        req.options.remove(0);

        let mut server = new_test_server(|| 42);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(requested_ip_addr);
        let _ = server.dispatch(req.clone()).unwrap();

        assert!(server.cache.contains_key(&req.chaddr));
        assert!(server.pool.addr_is_allocated(requested_ip_addr));
    }

    #[test]
    fn test_dispatch_with_selecting_request_no_address_allocation_maintains_server_invariants() {
        let requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        let mut req = new_test_request();
        req.ciaddr = requested_ip_addr;
        req.options.remove(0);

        let mut server = new_test_server(|| 42);
        let _ = server.dispatch(req.clone());

        assert!(!server.cache.contains_key(&req.chaddr));
        assert!(!server.pool.addr_is_allocated(Ipv4Addr::new(192, 168, 1, 2)));
    }

    #[test]
    fn test_dispatch_with_init_boot_request_correct_address_returns_ack() {
        let mut req = new_test_request();
        req.options.remove(2);
        let requested_ip_addr = get_requested_ip_addr(&req).unwrap();

        let mut server = new_test_server(|| 42);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(requested_ip_addr);
        let got = server.dispatch(req).unwrap();

        let want = new_test_ack();
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_init_boot_request_incorrect_address_returns_nak() {
        let mut req = new_test_request();
        req.options.remove(0);
        req.options.remove(1);
        req.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![192, 168, 1, 42],
        });

        let mut server = new_test_server(|| 42);
        let assigned_ip = Ipv4Addr::new(192, 168, 1, 2);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: assigned_ip,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(assigned_ip);
        let got = server.dispatch(req).unwrap();

        let want = new_test_nak();
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_init_boot_request_unknown_client_returns_none() {
        let mut req = new_test_request();
        req.options.remove(2);

        let mut server = new_test_server(|| 42);
        let got = server.dispatch(req);

        assert!(got.is_none());
    }

    #[test]
    fn test_dispatch_with_init_boot_request_client_on_wrong_subnet_returns_nak() {
        let mut req = new_test_request();
        req.options.remove(0);
        req.options.remove(1);
        req.options.push(ConfigOption {
            code: OptionCode::RequestedIpAddr,
            value: vec![10, 0, 0, 1],
        });

        let mut server = new_test_server(|| 42);
        let got = server.dispatch(req).unwrap();

        let want = new_test_nak();
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_renewing_request_valid_request_returns_ack() {
        let mut req = new_test_request();
        req.options.remove(0);
        req.options.remove(1);
        let client_ip = Ipv4Addr::new(192, 168, 1, 2);
        req.ciaddr = client_ip;

        let mut server = new_test_server(|| 42);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: client_ip,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server.pool.allocate_addr(client_ip);
        let got = server.dispatch(req).unwrap();

        let mut want = new_test_ack();
        want.ciaddr = client_ip;
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_renewing_request_unknown_client_returns_none() {
        let mut req = new_test_request();
        req.options.remove(0);
        req.options.remove(1);
        let client_ip = Ipv4Addr::new(192, 168, 1, 2);
        req.ciaddr = client_ip;

        let mut server = new_test_server(|| 42);
        let got = server.dispatch(req);

        assert!(got.is_none());
    }

    #[test]
    fn test_get_client_state_with_selecting_returns_selecting() {
        let mut msg = new_test_request();
        msg.ciaddr = Ipv4Addr::new(192, 168, 1, 2);
        msg.options.remove(0);

        let got = get_client_state(&msg);

        assert_eq!(got, ClientState::Selecting);
    }

    #[test]
    fn test_get_client_state_with_initreboot_returns_initreboot() {
        let mut msg = new_test_request();
        msg.options.remove(2);

        let got = get_client_state(&msg);

        assert_eq!(got, ClientState::InitReboot);
    }

    #[test]
    fn test_get_client_state_with_renewing_returns_renewing() {
        let mut msg = new_test_request();
        msg.options.remove(0);
        msg.options.remove(1);
        msg.ciaddr = Ipv4Addr::new(1, 2, 3, 4);

        let got = get_client_state(&msg);

        assert_eq!(got, ClientState::Renewing);
    }

    #[test]
    fn test_get_client_state_with_unknown_returns_unknown() {
        let mut msg = new_test_request();
        msg.options.clear();

        let got = get_client_state(&msg);

        assert_eq!(got, ClientState::Unknown);
    }

    #[test]
    fn test_release_expired_leases_with_none_expired_releases_none() {
        let mut server = new_test_server(|| 42);
        server.pool.available_addrs.clear();
        server.cache.insert(
            MacAddr {
                octets: [0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 2),
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server.cache.insert(
            MacAddr {
                octets: [0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 3),
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 3));
        server.cache.insert(
            MacAddr {
                octets: [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 4),
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 4));

        server.release_expired_leases();

        assert_eq!(server.cache.len(), 3);
        assert_eq!(server.pool.available_addrs.len(), 0);
        assert_eq!(server.pool.allocated_addrs.len(), 3);
    }

    #[test]
    fn test_release_expired_leases_with_all_expired_releases_all() {
        let mut server = new_test_server(|| 42);
        server.pool.available_addrs.clear();
        server.cache.insert(
            MacAddr {
                octets: [0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 2),
                options: vec![],
                expiration: 0,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server.cache.insert(
            MacAddr {
                octets: [0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 3),
                options: vec![],
                expiration: 0,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 3));
        server.cache.insert(
            MacAddr {
                octets: [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 4),
                options: vec![],
                expiration: 0,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 4));

        server.release_expired_leases();

        assert_eq!(server.cache.len(), 0);
        assert_eq!(server.pool.available_addrs.len(), 3);
        assert_eq!(server.pool.allocated_addrs.len(), 0);
    }

    #[test]
    fn test_release_expired_leases_with_some_expired_releases_expired() {
        let mut server = new_test_server(|| 42);
        server.pool.available_addrs.clear();
        server.cache.insert(
            MacAddr {
                octets: [0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 2),
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 2));
        server.cache.insert(
            MacAddr {
                octets: [0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 3),
                options: vec![],
                expiration: 0,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 3));
        server.cache.insert(
            MacAddr {
                octets: [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC],
            },
            CachedConfig {
                client_addr: Ipv4Addr::new(192, 168, 1, 4),
                options: vec![],
                expiration: std::i64::MAX,
            },
        );
        server
            .pool
            .allocated_addrs
            .insert(Ipv4Addr::new(192, 168, 1, 4));

        server.release_expired_leases();

        assert_eq!(server.cache.len(), 2);
        assert!(!server.cache.contains_key(&MacAddr {
            octets: [0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB]
        }));
        assert_eq!(server.pool.available_addrs.len(), 1);
        assert_eq!(server.pool.allocated_addrs.len(), 2);
    }

    #[test]
    fn test_dispatch_with_known_release() {
        let release = new_test_release();
        let mut server = new_test_server(|| 42);
        let client_ip = Ipv4Addr::new(192, 168, 1, 2);
        server.pool.allocate_addr(client_ip);
        let client_mac = MacAddr {
            octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
        };
        let client_config = CachedConfig {
            client_addr: client_ip,
            options: vec![],
            expiration: std::i64::MAX,
        };
        server.cache.insert(client_mac, client_config.clone());

        let got = server.dispatch(release);

        assert!(got.is_none(), "server returned a Message value");
        assert!(
            !server.pool.addr_is_allocated(client_ip),
            "server did not free client address"
        );
        assert!(
            server.pool.addr_is_available(client_ip),
            "server did not free client address"
        );
        assert!(
            server.cache.contains_key(&client_mac),
            "server did not retain cached client settings"
        );
        assert_eq!(
            server.cache.get(&client_mac).unwrap(),
            &client_config,
            "server did not retain cached client settings"
        );
    }

    #[test]
    fn test_dispatch_with_unknown_release() {
        let release = new_test_release();
        let mut server = new_test_server(|| 42);
        let client_ip = Ipv4Addr::new(192, 168, 1, 2);
        server.pool.allocate_addr(client_ip);
        let cached_mac = MacAddr {
            octets: [0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA],
        };
        let client_config = CachedConfig {
            client_addr: client_ip,
            options: vec![],
            expiration: std::i64::MAX,
        };
        server.cache.insert(cached_mac, client_config.clone());

        let got = server.dispatch(release);

        assert!(got.is_none(), "server returned a Message value");
        assert!(
            server.pool.addr_is_allocated(client_ip),
            "server did not free client address"
        );
        assert!(
            !server.pool.addr_is_available(client_ip),
            "server did not free client address"
        );
        assert!(
            server.cache.contains_key(&cached_mac),
            "server did not retain cached client settings"
        );
        assert_eq!(
            server.cache.get(&cached_mac).unwrap(),
            &client_config,
            "server did not retain cached client settings"
        );
    }

    #[test]
    fn test_dispatch_with_inform_returns_ack() {
        let inform = new_test_inform();
        let mut server = new_test_server(|| 42);

        let got = server.dispatch(inform).unwrap();

        let want = new_test_inform_ack();

        assert_eq!(got, want, "expected: {:?}\ngot: {:?}", want, got);
    }

    #[test]
    fn test_dispatch_with_decline_marks_addr_allocated() {
        let decline = new_test_decline();
        let mut server = new_test_server(|| 42);
        let already_used_ip = Ipv4Addr::new(192, 168, 1, 2);
        server.config.managed_addrs.push(already_used_ip);
        let client_config = CachedConfig {
            client_addr: already_used_ip,
            options: vec![],
            expiration: std::i64::MAX,
        };
        server.cache.insert(decline.chaddr, client_config);

        let got = server.dispatch(decline);

        assert!(got.is_none(), "server returned a Message value");
        assert!(
            !server.pool.addr_is_available(already_used_ip),
            "addr still marked available"
        );
        assert!(
            server.pool.addr_is_allocated(already_used_ip),
            "addr not marked allocated"
        );
        assert!(
            !server.cache.contains_key(&MacAddr {
                octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF]
            }),
            "client config retained"
        );
    }

    #[test]
    fn test_client_requested_lease_time() {
        let mut disc = new_test_discover();
        disc.options.push(ConfigOption {
            code: OptionCode::IpAddrLeaseTime,
            value: vec![0, 0, 0, 20],
        });

        let mut server = new_test_server(|| 42);
        let result = server.dispatch(disc).unwrap();
        assert_eq!(
            BigEndian::read_u32(
                &result
                    .get_config_option(OptionCode::IpAddrLeaseTime)
                    .unwrap()
                    .value
            ),
            20
        );

        let cached_config = server
            .cache
            .get(&MacAddr {
                octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
            })
            .unwrap();
        assert_eq!(cached_config.expiration, 42 + 20);
    }

    #[test]
    fn test_client_requested_lease_time_greater_than_max() {
        let mut disc = new_test_discover();
        disc.options.push(ConfigOption {
            code: OptionCode::IpAddrLeaseTime,
            value: vec![0, 0, 0, 20],
        });

        let mut server = new_test_server(|| 42);
        server.config.max_lease_time_s = 10;
        let result = server.dispatch(disc).unwrap();
        assert_eq!(
            BigEndian::read_u32(
                &result
                    .get_config_option(OptionCode::IpAddrLeaseTime)
                    .unwrap()
                    .value
            ),
            10
        );

        let cached_config = server
            .cache
            .get(&MacAddr {
                octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF],
            })
            .unwrap();
        assert_eq!(cached_config.expiration, 42 + 10);
    }
}