// 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 failure::Fail;
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,
}

// A wrapper around the error types which can be returned
// by DHCP Server in response to client requests
#[derive(Debug, Fail, PartialEq)]
pub enum ServerError {
    #[fail(display = "Received Client Message Type is invalid : {:?}", _0)]
    InvalidClientMessage(MessageType),

    #[fail(display = "Requested Ipv4 Address by client is invalid : {}", _0)]
    BadRequestedIpv4Addr(String),

    #[fail(display = "Server encountered error in local address pool manipulation : {}", _0)]
    ServerAddressPoolFailure(AddressPoolError),

    #[fail(display = "Server is not the intended target for this client request.")]
    UnwantedDHCPServer,

    #[fail(display = "Unable to assign the requested ipv4 address to client : {}", _0)]
    RequestedAddrAssignmentFailure(String),

    #[fail(display = "Requested Ipv4Addr not found")]
    RequestedIpv4AddrNotFound,

    #[fail(display = "Client Mac address could not be identified")]
    UnknownClientMac,

    #[fail(display = "Client State could not be identified during Init Reboot")]
    UnknownClientStatAtReboot,

    #[fail(display = "The declined Ipv4 address by client not found in server pool")]
    DeclinedIpv4AddrNotFound,

    #[fail(display = "Client declined offered Ipv4 address : {}", _0)]
    ClientDeclinedOfferedAddr(Ipv4Addr),

    #[fail(display = "Client released Ipv4 address : {}", _0)]
    ClientReleasedIpv4Addr(Ipv4Addr),

    #[fail(display = "Unable to identify Client Request Type")]
    UnknownClientRequest
}

impl From<AddressPoolError> for ServerError {
    fn from(e: AddressPoolError) -> Self {
        ServerError::ServerAddressPoolFailure(e)
    }
}

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 Ok(Message) in the 'Result'. If the incoming message is invalid,
    /// or the server is unable to serve the request, or the processing of the client's request
    /// resulted in an error, then `dispatch()` will return `Err(ServerError)` as the 'Result'.
    /// with the necessary information about the error
    pub fn dispatch(&mut self, msg: Message) -> Result<Message, ServerError> {
        match msg.get_dhcp_type() {
            Some(MessageType::DHCPDISCOVER) => self.handle_discover(msg),
            Some(MessageType::DHCPOFFER) => Err(ServerError::InvalidClientMessage(MessageType::DHCPOFFER)),
            Some(MessageType::DHCPREQUEST) => self.handle_request(msg),
            Some(MessageType::DHCPDECLINE) => self.handle_decline(msg),
            Some(MessageType::DHCPACK) => Err(ServerError::InvalidClientMessage(MessageType::DHCPACK)),
            Some(MessageType::DHCPNAK) => Err(ServerError::InvalidClientMessage(MessageType::DHCPNAK)),
            Some(MessageType::DHCPRELEASE) => self.handle_release(msg),
            Some(MessageType::DHCPINFORM) => self.handle_inform(msg),
            None => Err(ServerError::UnknownClientRequest),
        }
    }

    fn handle_discover(&mut self, disc: Message) -> Result<Message, ServerError> {
        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;
        let () = self.update_server_cache(
            Ipv4Addr::from(offer.yiaddr),
            offer.chaddr,
            vec![],
            &client_config,
        )?;

        Ok(offer)
    }

    fn get_addr(&mut self, client: &Message) -> Result<Ipv4Addr, ServerError> {
        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.
                let () = self.pool.free_addr(config.client_addr)?;
                return Ok(config.client_addr);
            } else if self.pool.addr_is_available(config.client_addr) {
                return Ok(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)
                    .ok_or_else(|| ServerError::BadRequestedIpv4Addr("out of range indexing on opt.value".to_owned()))?;
                if self.pool.addr_is_available(requested_addr) {
                    return Ok(requested_addr);
                }
            }
        }
        let addr = self.pool.get_next_available_addr()?;
        Ok(addr)
    }

    fn update_server_cache(
        &mut self,
        client_addr: Ipv4Addr,
        client_mac: MacAddr,
        client_opts: Vec<ConfigOption>,
        client_config: &ClientConfig,
    ) -> Result<(), ServerError> {
        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);
        let () = self.pool.allocate_addr(client_addr)?;
        Ok(())
    }

    fn handle_request(&mut self, req: Message) -> Result<Message, ServerError> {
        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 => Err(ServerError::UnknownClientStatAtReboot),
        }
    }

    fn handle_request_selecting(&mut self, req: Message) -> Result<Message, ServerError> {
        let requested_ip = req.ciaddr;
        if !is_recipient(self.config.server_ip, &req) {
            Err(ServerError::UnwantedDHCPServer)
        } else {
            let () = self.check_ip_allocation(&req, requested_ip)?;
            Ok(build_ack(req, requested_ip, &self.config))
        }
        /*
          let requested_ip = req.ciaddr;
        if !is_recipient(self.config.server_ip, &req) || !self.is_assigned(&req, requested_ip) {
            return Err(ServerError::IncorrectDHCP);
        }
        Some(build_ack(req, requested_ip, &self.config))

        */
    }

    fn check_ip_allocation(&self, req: &Message, requested_ip: Ipv4Addr) -> Result<(), ServerError> {
        if let Some(client_config) = self.cache.get(&req.chaddr) {
            if client_config.client_addr != requested_ip {
                Err(ServerError::RequestedAddrAssignmentFailure("Requested Ipv4 \
                address does not match initial address requested in discovery".to_owned()))
            } else if client_config.expired((self.time_provider)()) {
                Err(ServerError::RequestedAddrAssignmentFailure("Client Config has expired".to_owned()))
            } else if !self.pool.addr_is_allocated(requested_ip) {
                Err(ServerError::RequestedAddrAssignmentFailure("Server failed to reserve requested Ipv4 adddress".to_owned()))
            } else {
                Ok(())
            }
        } else {
            Err(ServerError::RequestedAddrAssignmentFailure("Could not retrieve client config".to_owned()))
        }
/*        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) -> Result<Message, ServerError> {
        let requested_ip = get_requested_ip_addr(&req).ok_or_else(|| ServerError::RequestedIpv4AddrNotFound)?;
        if !is_in_subnet(requested_ip, &self.config) {
            //return Ok(build_nak(req, &self.config))
            let msg = build_nak(req, &self.config);
/*            let s = String::from("hello world");
            add_request_nak_message(&mut msg, s);*/
            return Ok(msg)
        }
        if !is_client_mac_known(req.chaddr, &self.cache) {
            return Err(ServerError::UnknownClientMac)
        }
        if self.check_ip_allocation(&req, requested_ip).is_err() {
            return Ok(build_nak(req, &self.config))
        }
        Ok(build_ack(req, requested_ip, &self.config))
    }

    fn handle_request_renewing(&mut self, req: Message) -> Result<Message, ServerError> {
        let client_ip = req.ciaddr;
        let () = self.check_ip_allocation(&req, client_ip)?;
/*        if !self.is_assigned(&req, client_ip) {
            return None;
        }*/
        Ok(build_ack(req, client_ip, &self.config))
    }

    fn handle_decline(&mut self, dec: Message) -> Result<Message, ServerError> {
        let declined_ip = get_requested_ip_addr(&dec).ok_or_else(|| ServerError::DeclinedIpv4AddrNotFound)?;
        if is_recipient(self.config.server_ip, &dec) && self.check_ip_allocation(&dec, declined_ip).is_err() {
            let () = self.pool.allocate_addr(declined_ip)?;
        }
        self.cache.remove(&dec.chaddr);
        Err(ServerError::ClientDeclinedOfferedAddr(declined_ip))
/*        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) -> Result<Message, ServerError> {
        if self.cache.contains_key(&rel.chaddr) {
            let () = self.pool.free_addr(rel.ciaddr)?;
        }
        Err(ServerError::ClientReleasedIpv4Addr(rel.ciaddr))
    }

    fn handle_inform(&mut self, inf: Message) -> Result<Message, ServerError> {
        // 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);
        Ok(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)| {
            let _ = 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>,
}

//This is a wrapper around different errors that could be returned by
// the DHCP server address pool during address allocation/de-allocation
#[derive(Debug, Fail, PartialEq)]
pub enum AddressPoolError {

    #[fail(display = "Address Pool does not have any more available Ipv4 addresses")]
    Ipv4AddrExhaustion,

    #[fail(display = "Invalid Server State: attempted to allocate unavailable address : {}", _0)]
    UnavailableIpv4AddrAllocation(Ipv4Addr),

    #[fail(display = "Invalid Server State: attempted to free unallocated address : {}", _0)]
    UnallocatedIpv4AddrRelease(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);
            }
        }
    }

    //TODO(sshrivy): Should the address be chosen as per the client subnet
    //
    //RFC2131#section-4.3.1
    //
    //A new address allocated from the server's pool of available
    //addresses; the address is selected based on the subnet from which
    //the message was received (if 'giaddr' is 0) or on the address of
    //the relay agent that forwarded the message ('giaddr' when not 0)
    fn get_next_available_addr(&self) -> Result<Ipv4Addr, AddressPoolError> {
        let mut iter = self.available_addrs.iter();
        match iter.next() {
            Some(addr) => Ok(*addr),
            None => Err(AddressPoolError::Ipv4AddrExhaustion),
        }
    }

    fn allocate_addr(&mut self, addr: Ipv4Addr) -> Result<(), AddressPoolError>  {
        if self.available_addrs.remove(&addr) {
            self.allocated_addrs.insert(addr);
            Ok(())
        } else {
            Err(AddressPoolError::UnavailableIpv4AddrAllocation(addr))
        }
    }

    fn free_addr(&mut self, addr: Ipv4Addr) -> Result<(), AddressPoolError> {
        if self.allocated_addrs.remove(&addr) {
            self.available_addrs.insert(addr);
            Ok(())
        } else {
            Err(AddressPoolError::UnallocatedIpv4AddrRelease(addr))
        }
    }

    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::SubnetMask,
        value: config.subnet_mask.octets().to_vec(),
    });
    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 {
    config.subnet_mask.apply_to(ip) == config.subnet_mask.apply_to(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 add_request_nak_message(nak: &mut Message, msg: String) {
    nak.options.push(ConfigOption {
        code: OptionCode::Message,
        value: msg.into_bytes(),
    });
}*/

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))
}

#[cfg(test)]
mod tests {

    use super::*;
    use crate::configuration::SubnetMask;
    use crate::protocol::{ConfigOption, Message, MessageType, OpCode, OptionCode};
    use std::convert::TryFrom;
    use std::net::Ipv4Addr;
    //use std::str::from_utf8;

    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_client_offer() -> Message {
        let mut client_offer = Message::new();
        client_offer.op = OpCode::BOOTREQUEST;
        client_offer.xid = 42;
        client_offer.chaddr = MacAddr { octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF] };
        client_offer.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPOFFER.into()],
        });
        // Skipping other settings as they are not needed
        client_offer
    }

    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::SubnetMask,
            value: SubnetMask::try_from(24).unwrap().octets().to_vec(),
        });
        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_request_with_no_requested_address() -> 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::DhcpMessageType,
            value: vec![MessageType::DHCPREQUEST.into()],
        });
        req.options.push(ConfigOption { code: OptionCode::ServerId, value: vec![192, 168, 1, 1] });
        req
    }
*/


    fn new_test_client_ack() -> Message {
        let mut client_ack = Message::new();
        client_ack.op = OpCode::BOOTREQUEST;
        client_ack.xid = 42;
        client_ack.chaddr = MacAddr { octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF] };
        client_ack.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPACK.into()],
        });
        client_ack
        // Skipping other option settings as they are not needed
    }

   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::SubnetMask,
           value: SubnetMask::try_from(24).unwrap().octets().to_vec(),
       });
       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_client_nak() -> Message {
        let mut client_nak = Message::new();
        client_nak.op = OpCode::BOOTREQUEST;
        client_nak.xid = 42;
        client_nak.chaddr = MacAddr { octets: [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF] };
        client_nak.options.push(ConfigOption {
            code: OptionCode::DhcpMessageType,
            value: vec![MessageType::DHCPNAK.into()],
        });
        client_nak
    }

   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]
    //TODO: Done
    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]
    //TODO: Done
    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]
    //TODO: Done
    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]
    //TODO: Done
    fn test_dispatch_with_discover_client_binding_returns_error_when_addr_previously_not_bound() {
        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.cache.insert(disc.chaddr, client_config);

        let got = server.dispatch(disc);

        let want = Err(ServerError::ServerAddressPoolFailure(AddressPoolError::UnallocatedIpv4AddrRelease(client_addr)));

        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    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]
    //TODO: Done
    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]
    //TODO: Done
    fn test_dispatch_with_discover_expired_client_binding_returns_available_requested_addr() {
        let mut disc = new_test_discover();
        disc.options
            .push(ConfigOption { code: OptionCode::RequestedIpAddr, value: vec![192, 168, 1, 2] });
        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);

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

        let want = new_test_offer();

        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_discover_expired_client_binding_returns_next_addr_for_unavailable_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);
        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);

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

        let want = new_test_offer();

        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_discover_expired_client_binding_returns_next_addr_for_bad_requested_addr() {
        let mut disc = new_test_discover();
        disc.options
            .push(ConfigOption { code: OptionCode::RequestedIpAddr, value: vec![192, 168, 1] });
        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);

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

        let want = new_test_offer();

        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    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]
    //TODO: Done
    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]
    //TODO: Done
    fn test_dispatch_with_discover_unavailable_requested_addr_no_available_addr_returns_error() {
        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.clear();
        server.pool.allocated_addrs.insert(Ipv4Addr::new(192, 168, 1, 42));
        let got = server.dispatch(disc);

        let want : Result<Message, ServerError> = Err(ServerError::ServerAddressPoolFailure(AddressPoolError::Ipv4AddrExhaustion));
        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_discover_no_requested_addr_no_available_addr_returns_error() {
        let disc = new_test_discover();
        let mut server = new_test_server(|| 42);

        server.pool.available_addrs.clear();
        let got = server.dispatch(disc);

        let want : Result<Message, ServerError> = Err(ServerError::ServerAddressPoolFailure(AddressPoolError::Ipv4AddrExhaustion));
        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_client_offer_message_returns_error() {
        let client_offer = new_test_client_offer();

        let mut server = new_test_server(|| 42);

        let got = server.dispatch(client_offer);

        let want : Result<Message, ServerError> = Err(ServerError::InvalidClientMessage(MessageType::DHCPOFFER));
        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_client_ack_message_returns_error() {
        let client_ack = new_test_client_ack();

        let mut server = new_test_server(|| 42);

        let got = server.dispatch(client_ack);

        let want : Result<Message, ServerError> = Err(ServerError::InvalidClientMessage(MessageType::DHCPACK));
        assert_eq!(got, want);
    }

    #[test]
    //TODO: Done
    fn test_dispatch_with_client_nak_message_returns_error() {
        let client_nak = new_test_client_nak();

        let mut server = new_test_server(|| 42);

        let got = server.dispatch(client_nak);

        let want : Result<Message, ServerError> = Err(ServerError::InvalidClientMessage(MessageType::DHCPNAK));

        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,
            },
        );

        let _ = 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_wrong_server_id_returns_error() {
        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,
            },
        );
        let _ = server.pool.allocate_addr(requested_ip_addr);

        server.config.server_ip = Ipv4Addr::new(1, 2, 3, 4);
        let got = server.dispatch(req);

        let want = Err(ServerError::UnwantedDHCPServer);
        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_mismatched_requested_addr_returns_error() {
        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 requested_ip_addr = Ipv4Addr::new(192, 168, 1, 3);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );

        let _ = server.pool.allocate_addr(requested_ip_addr);

        let got = server.dispatch(req);

        let want = Err(ServerError::RequestedAddrAssignmentFailure("Requested Ipv4 address does not match initial address requested in discovery".to_owned()));

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_expired_config_returns_error() {
        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 requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: 0,
            },
        );

        let _ = server.pool.allocate_addr(requested_ip_addr);

        let got = server.dispatch(req);

        let want = Err(ServerError::RequestedAddrAssignmentFailure("Client Config has expired".to_owned()));

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_failed_addr_allocation_returns_error() {
        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 requested_ip_addr = Ipv4Addr::new(192, 168, 1, 2);
        server.cache.insert(
            req.chaddr,
            CachedConfig {
                client_addr: requested_ip_addr,
                options: vec![],
                expiration: std::i64::MAX,
            },
        );

        let got = server.dispatch(req);

        let want = Err(ServerError::RequestedAddrAssignmentFailure("Server failed to reserve requested Ipv4 adddress".to_owned()));

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_selecting_request_no_client_config_returns_error() {
        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);

        let want = Err(ServerError::RequestedAddrAssignmentFailure("Could not retrieve client config".to_owned()));

        assert_eq!(got, want);
    }

    #[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,
            },
        );
        let _ = 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,
            },
        );
        let _ = 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 },
        );
        let _ = 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_error() {
        let mut req = new_test_request();
        req.options.remove(2);

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

        let want = Err(ServerError::UnknownClientMac);

        assert_eq!(got, want);
    }

    #[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 },
        );
        let _ = 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_error() {
        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);

        let want = Err(ServerError::RequestedAddrAssignmentFailure("Could not retrieve client config".to_owned()));

        assert_eq!(got, want);
    }

    #[test]
    fn test_dispatch_with_unknown_client_state_returns_error() {
        let mut req = new_test_request();
        req.options.remove(0);
        req.options.remove(1);

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

        let want = Err(ServerError::UnknownClientStatAtReboot);

        assert_eq!(got, want);
    }

    #[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_dispatch_with_unknown_client_msg_returns_error() {
        let mut msg = new_test_request();
        msg.options.clear();

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

        let want = Err(ServerError::UnknownClientRequest);

        assert_eq!(got, want);
    }

    #[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);
        let _ = 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_err(), "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);
        let _ = 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_err(), "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_err(), "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);
    }

/*    #[test]
    fn test_add_msg_nak() {
        let mut nak = new_test_nak();
        let s = String::from("hello world");
        add_request_nak_message(&mut nak, s);
        println!("This is NAK - {:?}", nak);
        let v = nak.get_config_option(OptionCode::Message).unwrap();
        let s2 = v.to_owned().value;
        let str = from_utf8(&s2);
        println!("This is the text - {:?}", str)


    }*/
}