// 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::protocol::{FidlCompatible, FromFidlExt, IntoFidlExt};
use anyhow::Context;
use serde::{Deserialize, Serialize};
use serde_json;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::fs;
use std::io;
use std::net::Ipv4Addr;
use thiserror::Error;

/// Attempts to load a `ServerParameters` from the json file at the provided path.
pub fn load_server_params_from_file(path: &str) -> Result<ServerParameters, ConfigError> {
    let json = fs::read_to_string(path)?;
    let config = serde_json::from_str(&json)?;
    Ok(config)
}

/// A collection of the basic configuration parameters needed by the server.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServerParameters {
    /// The IPv4 addresses of the host running the server.
    pub server_ips: Vec<Ipv4Addr>,
    /// The duration for which leases should be assigned to clients
    pub lease_length: LeaseLength,
    /// The IPv4 addresses which the server is responsible for managing and leasing to
    /// clients.
    pub managed_addrs: ManagedAddresses,
    /// A list of MAC addresses which are permitted to request a lease. If empty, any MAC address
    /// may request a lease.
    pub permitted_macs: PermittedMacs,
    /// A collection of static address assignments. Any client whose MAC address has a static
    /// assignment will be offered the assigned IP address.
    pub static_assignments: StaticAssignments,
    /// Enables server behavior where the server ARPs an IP address prior to issuing
    /// it in a lease.
    pub arp_probe: bool,
    /// The interface names to which the server's UDP sockets are bound. If
    /// this vector is empty, the server will not bind to a specific interface
    /// and will process incoming DHCP messages regardless of the interface on
    /// which they arrive.
    pub bound_device_names: Vec<String>,
}

/// Parameters controlling lease duration allocation. Per,
/// https://tools.ietf.org/html/rfc2131#section-3.3, times are represented as relative times.
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub struct LeaseLength {
    /// The default lease duration assigned by the server.
    pub default_seconds: u32,
    /// The maximum allowable lease duration which a client can request.
    pub max_seconds: u32,
}

impl FidlCompatible<fidl_fuchsia_net_dhcp::LeaseLength> for LeaseLength {
    type FromError = anyhow::Error;
    type IntoError = never::Never;

    fn try_from_fidl(fidl: fidl_fuchsia_net_dhcp::LeaseLength) -> Result<Self, Self::FromError> {
        if let fidl_fuchsia_net_dhcp::LeaseLength { default: Some(default_seconds), max } = fidl {
            Ok(LeaseLength {
                default_seconds,
                // Per fuchsia.net.dhcp, if omitted, max defaults to the value of default.
                max_seconds: max.unwrap_or(default_seconds),
            })
        } else {
            Err(anyhow::format_err!(
                "fuchsia.net.dhcp.LeaseLength missing required field: {:?}",
                fidl
            ))
        }
    }

    fn try_into_fidl(self) -> Result<fidl_fuchsia_net_dhcp::LeaseLength, Self::IntoError> {
        let LeaseLength { default_seconds, max_seconds } = self;
        Ok(fidl_fuchsia_net_dhcp::LeaseLength {
            default: Some(default_seconds),
            max: Some(max_seconds),
        })
    }
}

/// The IP addresses which the server will manage and lease to clients.
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub struct ManagedAddresses {
    /// The network id of the subnet for which the server will manage addresses.
    pub network_id: Ipv4Addr,
    /// The broadcast id of the subnet for which the server will manage addresses.
    pub broadcast: Ipv4Addr,
    /// The subnet mask of the subnet for which the server will manage addresses.
    pub mask: SubnetMask,
    /// The inclusive starting address of the range of managed addresses.
    pub pool_range_start: Ipv4Addr,
    /// The exclusive stopping address of the range of managed addresses.
    pub pool_range_stop: Ipv4Addr,
}

impl ManagedAddresses {
    /// Returns an iterator of the `Ipv4Addr`s from `pool_range_start`, inclusive, to
    /// `pool_range_stop`, exclusive.
    pub fn pool_range(&self) -> impl Iterator<Item = Ipv4Addr> {
        let start: u32 = self.pool_range_start.into();
        let stop: u32 = self.pool_range_stop.into();
        (start..stop).map(|addr| addr.into())
    }
}

impl FidlCompatible<fidl_fuchsia_net_dhcp::AddressPool> for ManagedAddresses {
    type FromError = anyhow::Error;
    type IntoError = never::Never;

    fn try_from_fidl(fidl: fidl_fuchsia_net_dhcp::AddressPool) -> Result<Self, Self::FromError> {
        if let fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(network_id),
            broadcast: Some(broadcast),
            mask: Some(mask),
            pool_range_start: Some(pool_range_start),
            pool_range_stop: Some(pool_range_stop),
        } = fidl
        {
            let mask = SubnetMask::try_from_fidl(mask)
                .context("fuchsia.net.dhcp.AddressPool contained invalid mask")?;
            let network_id = Ipv4Addr::from_fidl(network_id);
            let broadcast = Ipv4Addr::from_fidl(broadcast);
            let pool_range_start = Ipv4Addr::from_fidl(pool_range_start);
            let pool_range_stop = Ipv4Addr::from_fidl(pool_range_stop);
            if mask.apply_to(network_id) != network_id {
                Err(anyhow::format_err!(
                    "fuchsia.net.dhcp.AddressPool contained wrong mask (/{}) for network_id ({})",
                    mask.ones(),
                    network_id
                ))
            } else if mask.apply_to(broadcast) != network_id {
                Err(anyhow::format_err!("fuchsia.net.dhcp.AddressPool contained broadcast ({}) outside of network_id ({})", broadcast, network_id))
            } else if mask.apply_to(pool_range_start) != network_id {
                Err(anyhow::format_err!("fuchsia.net.dhcp.AddressPool contained pool_range_start ({}) outside of network_id ({})", pool_range_start, network_id))
            } else if mask.apply_to(pool_range_stop) != network_id {
                Err(anyhow::format_err!("fuchsia.net.dhcp.AddressPool contained pool_range_stop ({}) outside of network_id ({})", pool_range_stop, network_id))
            } else if pool_range_start > pool_range_stop {
                Err(anyhow::format_err!("fuchsia.net.dhpc.AddressPool contained pool_range_start ({}) > pool_range_stop ({})", pool_range_start, pool_range_stop))
            } else {
                Ok(Self { network_id, broadcast, mask, pool_range_start, pool_range_stop })
            }
        } else {
            Err(anyhow::format_err!("fuchsia.net.dhcp.AddressPool missing fields: {:?}", fidl))
        }
    }

    fn try_into_fidl(self) -> Result<fidl_fuchsia_net_dhcp::AddressPool, Self::IntoError> {
        let ManagedAddresses { network_id, broadcast, mask, pool_range_start, pool_range_stop } =
            self;
        Ok(fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(network_id.into_fidl()),
            broadcast: Some(broadcast.into_fidl()),
            mask: Some(mask.into_fidl()),
            pool_range_start: Some(pool_range_start.into_fidl()),
            pool_range_stop: Some(pool_range_stop.into_fidl()),
        })
    }
}

/// A list of MAC addresses which are permitted to request a lease.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PermittedMacs(pub Vec<fidl_fuchsia_net_ext::MacAddress>);

impl FidlCompatible<Vec<fidl_fuchsia_net::MacAddress>> for PermittedMacs {
    type FromError = never::Never;
    type IntoError = never::Never;

    fn try_from_fidl(fidl: Vec<fidl_fuchsia_net::MacAddress>) -> Result<Self, Self::FromError> {
        Ok(PermittedMacs(fidl.into_iter().map(|mac| mac.into()).collect()))
    }

    fn try_into_fidl(self) -> Result<Vec<fidl_fuchsia_net::MacAddress>, Self::IntoError> {
        Ok(self.0.into_iter().map(|mac| mac.into()).collect())
    }
}

/// A collection of static address assignments. Any client whose MAC address has a static
/// assignment will be offered the assigned IP address.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StaticAssignments(pub HashMap<fidl_fuchsia_net_ext::MacAddress, Ipv4Addr>);

impl FidlCompatible<Vec<fidl_fuchsia_net_dhcp::StaticAssignment>> for StaticAssignments {
    type FromError = anyhow::Error;
    type IntoError = never::Never;

    fn try_from_fidl(
        fidl: Vec<fidl_fuchsia_net_dhcp::StaticAssignment>,
    ) -> Result<Self, Self::FromError> {
        match fidl.into_iter().try_fold(HashMap::new(), |mut acc, assignment| {
            if let (Some(host), Some(assigned_addr)) = (assignment.host, assignment.assigned_addr) {
                let mac = fidl_fuchsia_net_ext::MacAddress::from(host);
                match acc.insert(mac, Ipv4Addr::from_fidl(assigned_addr)) {
                    Some(_ip) => Err(anyhow::format_err!(
                        "fuchsia.net.dhcp.StaticAssignment contained multiple entries for {}",
                        mac
                    )),
                    None => Ok(acc),
                }
            } else {
                Err(anyhow::format_err!(
                    "fuchsia.net.dhcp.StaticAssignment contained entry with missing fields: {:?}",
                    assignment
                ))
            }
        }) {
            Ok(static_assignments) => Ok(StaticAssignments(static_assignments)),
            Err(e) => Err(e),
        }
    }

    fn try_into_fidl(
        self,
    ) -> Result<Vec<fidl_fuchsia_net_dhcp::StaticAssignment>, Self::IntoError> {
        Ok(self
            .0
            .into_iter()
            .map(|(host, assigned_addr)| fidl_fuchsia_net_dhcp::StaticAssignment {
                host: Some(host.into()),
                assigned_addr: Some(assigned_addr.into_fidl()),
            })
            .collect())
    }
}

/// A wrapper around the error types which can be returned when loading a
/// `ServerConfig` from file with `load_server_config_from_file()`.
#[derive(Debug, Error)]
pub enum ConfigError {
    #[error("io error: {}", _0)]
    IoError(io::Error),
    #[error("json deserialization error: {}", _0)]
    JsonError(serde_json::Error),
}

impl From<io::Error> for ConfigError {
    fn from(e: io::Error) -> Self {
        ConfigError::IoError(e)
    }
}

impl From<serde_json::Error> for ConfigError {
    fn from(e: serde_json::Error) -> Self {
        ConfigError::JsonError(e)
    }
}

const U32_BITS: u8 = (std::mem::size_of::<u32>() * 8) as u8;

/// A bitmask which represents the boundary between the Network part and Host part of an IPv4
/// address.
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubnetMask {
    /// The set high-order bits of the mask.
    ones: u8,
}

impl SubnetMask {
    /// Returns a byte-array representation of the `SubnetMask` in Network (Big-Endian) byte-order.
    pub fn octets(&self) -> [u8; 4] {
        self.to_u32().to_be_bytes()
    }

    fn to_u32(&self) -> u32 {
        let n = u32::max_value();
        // overflowing_shl() will not shift arguments >= the bit length of the calling value, so we
        // must special case a mask with 0 ones.
        if self.ones == 0 {
            0
        } else {
            // overflowing_shl() must be used here for panic safety.
            let (n, _overflow) = n.overflowing_shl((U32_BITS - self.ones) as u32);
            n
        }
    }

    /// Returns the count of the set high-order bits of the `SubnetMask`.
    pub fn ones(&self) -> u8 {
        self.ones
    }

    /// Returns the Network address resulting from masking `target` with the `SubnetMask`.
    pub fn apply_to(&self, target: Ipv4Addr) -> Ipv4Addr {
        let subnet_mask_bits = self.to_u32();
        let target_bits = u32::from_be_bytes(target.octets());
        Ipv4Addr::from(target_bits & subnet_mask_bits)
    }
}

impl TryFrom<u8> for SubnetMask {
    type Error = anyhow::Error;

    /// Returns a `Ok(SubnetMask)` with the `ones` high-order bits set if `ones` < 32, else `Err`.
    fn try_from(ones: u8) -> Result<Self, Self::Error> {
        if ones >= U32_BITS {
            Err(anyhow::format_err!(
                "failed precondition: argument must be < 32 (bit length of an IPv4 address)",
            ))
        } else {
            Ok(SubnetMask { ones })
        }
    }
}

impl TryFrom<Ipv4Addr> for SubnetMask {
    type Error = anyhow::Error;

    fn try_from(mask: Ipv4Addr) -> Result<Self, Self::Error> {
        let mask: u32 = mask.into();
        let ones = mask.count_ones();
        if ones + mask.trailing_zeros() != 32 {
            Err(anyhow::format_err!("mask did not have consecutive ones {:b}", mask))
        } else {
            Ok(SubnetMask { ones: ones as u8 })
        }
    }
}

impl FidlCompatible<fidl_fuchsia_net::Ipv4Address> for SubnetMask {
    type FromError = anyhow::Error;
    type IntoError = never::Never;

    fn try_from_fidl(fidl: fidl_fuchsia_net::Ipv4Address) -> Result<Self, Self::FromError> {
        let addr = Ipv4Addr::from_fidl(fidl);
        SubnetMask::try_from(addr)
    }

    fn try_into_fidl(self) -> Result<fidl_fuchsia_net::Ipv4Address, Self::IntoError> {
        let addr = Ipv4Addr::from(self.to_u32());
        Ok(addr.into_fidl())
    }
}

impl Into<Ipv4Addr> for SubnetMask {
    fn into(self) -> Ipv4Addr {
        Ipv4Addr::from(self.to_u32())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::server::tests::{random_ipv4_generator, random_mac_generator};

    #[test]
    fn test_try_from_ipv4addr_with_consecutive_ones_returns_mask() -> Result<(), anyhow::Error> {
        assert_eq!(SubnetMask::try_from(Ipv4Addr::new(255, 255, 255, 0))?, SubnetMask { ones: 24 });
        Ok(())
    }

    #[test]
    fn test_try_from_ipv4addr_with_nonconsecutive_ones_returns_err() -> Result<(), anyhow::Error> {
        assert!(SubnetMask::try_from(Ipv4Addr::new(255, 255, 255, 1)).is_err());
        Ok(())
    }

    #[test]
    fn test_into_ipv4addr_returns_ipv4addr() -> Result<(), anyhow::Error> {
        let v1: Ipv4Addr = SubnetMask { ones: 24 }.into();
        let v2: Ipv4Addr = SubnetMask { ones: 0 }.into();
        let v3: Ipv4Addr = SubnetMask { ones: 32 }.into();
        assert_eq!(v1, Ipv4Addr::new(255, 255, 255, 0));
        assert_eq!(v2, Ipv4Addr::new(0, 0, 0, 0));
        assert_eq!(v3, Ipv4Addr::new(255, 255, 255, 255));
        Ok(())
    }

    #[test]
    fn test_lease_length_try_from_fidl() {
        let both = fidl_fuchsia_net_dhcp::LeaseLength { default: Some(42), max: Some(42) };
        let with_default = fidl_fuchsia_net_dhcp::LeaseLength { default: Some(42), max: None };
        let with_max = fidl_fuchsia_net_dhcp::LeaseLength { default: None, max: Some(42) };
        let neither = fidl_fuchsia_net_dhcp::LeaseLength { default: None, max: None };

        assert_eq!(
            LeaseLength::try_from_fidl(both).unwrap(),
            LeaseLength { default_seconds: 42, max_seconds: 42 }
        );
        assert_eq!(
            LeaseLength::try_from_fidl(with_default).unwrap(),
            LeaseLength { default_seconds: 42, max_seconds: 42 }
        );
        assert!(LeaseLength::try_from_fidl(with_max).is_err());
        assert!(LeaseLength::try_from_fidl(neither).is_err());
    }

    #[test]
    fn test_managed_addresses_try_from_fidl() -> Result<(), anyhow::Error> {
        let good_mask = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let bad_mask = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 0, 255] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let missing_fields = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: None,
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: None,
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let invalid_network_id = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 128] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let invalid_broadcast = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 1, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let invalid_pool_range_start = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 1, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 254] }),
        };
        let invalid_pool_range_stop = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 2] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 1, 254] }),
        };
        let start_after_stop = fidl_fuchsia_net_dhcp::AddressPool {
            network_id: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 0] }),
            broadcast: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 255] }),
            mask: Some(fidl_fuchsia_net::Ipv4Address { addr: [255, 255, 255, 0] }),
            pool_range_start: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 20] }),
            pool_range_stop: Some(fidl_fuchsia_net::Ipv4Address { addr: [192, 168, 0, 10] }),
        };

        assert_eq!(
            ManagedAddresses::try_from_fidl(good_mask).unwrap(),
            ManagedAddresses {
                network_id: Ipv4Addr::from([192, 168, 0, 0]),
                broadcast: Ipv4Addr::from([192, 168, 0, 255]),
                mask: SubnetMask::try_from(24)?,
                pool_range_start: Ipv4Addr::from([192, 168, 0, 2]),
                pool_range_stop: Ipv4Addr::from([192, 168, 0, 254]),
            }
        );
        assert!(ManagedAddresses::try_from_fidl(bad_mask).is_err());
        assert!(ManagedAddresses::try_from_fidl(missing_fields).is_err());
        assert!(ManagedAddresses::try_from_fidl(invalid_network_id).is_err());
        assert!(ManagedAddresses::try_from_fidl(invalid_broadcast).is_err());
        assert!(ManagedAddresses::try_from_fidl(invalid_pool_range_start).is_err());
        assert!(ManagedAddresses::try_from_fidl(invalid_pool_range_stop).is_err());
        assert!(ManagedAddresses::try_from_fidl(start_after_stop).is_err());

        Ok(())
    }

    #[test]
    fn test_static_assignments_try_from_fidl() -> Result<(), anyhow::Error> {
        use std::iter::FromIterator;

        let fidl_fuchsia_hardware_ethernet_ext::MacAddress { octets: mac } = random_mac_generator();
        let ip = random_ipv4_generator();
        let fields_present = vec![fidl_fuchsia_net_dhcp::StaticAssignment {
            host: Some(fidl_fuchsia_net::MacAddress { octets: mac.clone() }),
            assigned_addr: Some(ip.into_fidl()),
        }];
        let multiple_entries = vec![
            fidl_fuchsia_net_dhcp::StaticAssignment {
                host: Some(fidl_fuchsia_net::MacAddress { octets: mac.clone() }),
                assigned_addr: Some(ip.into_fidl()),
            },
            fidl_fuchsia_net_dhcp::StaticAssignment {
                host: Some(fidl_fuchsia_net::MacAddress { octets: mac.clone() }),
                assigned_addr: Some(random_ipv4_generator().into_fidl()),
            },
        ];
        let fields_missing =
            vec![fidl_fuchsia_net_dhcp::StaticAssignment { host: None, assigned_addr: None }];

        assert_eq!(
            StaticAssignments::try_from_fidl(fields_present).unwrap(),
            StaticAssignments(HashMap::from_iter(
                vec![(fidl_fuchsia_net_ext::MacAddress { octets: mac }, ip)].into_iter()
            ))
        );
        assert!(StaticAssignments::try_from_fidl(multiple_entries).is_err());
        assert!(StaticAssignments::try_from_fidl(fields_missing).is_err());
        Ok(())
    }
}