// Copyright 2021 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.

//! Rather than reuse existing _ext types, we define intermediary types for
//! JSON serialization to avoid coupling too closely to particular FIDL
//! protocols.

use fidl_fuchsia_net_routes_ext as froutes_ext;
use net_types::{ip::IpAddress as _, Witness as _};
use thiserror::Error;

#[derive(serde::Serialize, Ord, PartialOrd, Eq, PartialEq)]
pub(crate) struct Subnet<T> {
    pub(crate) addr: T,
    pub(crate) prefix_len: u8,
}

impl From<fidl_fuchsia_net_ext::Subnet> for Subnet<std::net::IpAddr> {
    fn from(ext: fidl_fuchsia_net_ext::Subnet) -> Subnet<std::net::IpAddr> {
        let fidl_fuchsia_net_ext::Subnet {
            addr: fidl_fuchsia_net_ext::IpAddress(addr),
            prefix_len,
        } = ext;
        Subnet { addr, prefix_len }
    }
}

impl<A: net_types::ip::IpAddress> From<net_types::ip::Subnet<A>> for Subnet<std::net::IpAddr> {
    fn from(sub: net_types::ip::Subnet<A>) -> Subnet<std::net::IpAddr> {
        let addr = sub.network().to_ip_addr().into();
        let prefix_len = sub.prefix();
        Subnet { addr, prefix_len }
    }
}

#[derive(serde::Serialize, Ord, PartialOrd, Eq, PartialEq)]
pub(crate) enum AddressAssignmentState {
    Tentative,
    Assigned,
    Unavailable,
}

impl From<fidl_fuchsia_net_interfaces::AddressAssignmentState> for AddressAssignmentState {
    fn from(value: fidl_fuchsia_net_interfaces::AddressAssignmentState) -> Self {
        match value {
            fidl_fuchsia_net_interfaces::AddressAssignmentState::Tentative => Self::Tentative,
            fidl_fuchsia_net_interfaces::AddressAssignmentState::Assigned => Self::Assigned,
            fidl_fuchsia_net_interfaces::AddressAssignmentState::Unavailable => Self::Unavailable,
        }
    }
}

#[derive(serde::Serialize, Ord, PartialOrd, Eq, PartialEq)]
pub(crate) struct Address<I> {
    #[serde(flatten)]
    pub(crate) subnet: Subnet<I>,
    pub(crate) valid_until: Option<i64>,
    pub(crate) assignment_state: AddressAssignmentState,
}

impl<I> Address<I> {
    fn map<I2, F: Fn(I) -> I2>(self, f: F) -> Address<I2> {
        let Self { subnet: Subnet { addr, prefix_len }, valid_until, assignment_state } = self;
        Address { subnet: Subnet { addr: f(addr), prefix_len }, valid_until, assignment_state }
    }
}

#[derive(serde::Serialize)]
pub(crate) struct Addresses {
    pub(crate) ipv4: Vec<Address<std::net::Ipv4Addr>>,
    pub(crate) ipv6: Vec<Address<std::net::Ipv6Addr>>,
}

impl Addresses {
    pub(crate) fn all_addresses(self) -> impl Iterator<Item = Address<std::net::IpAddr>> {
        let Self { ipv4, ipv6 } = self;
        ipv4.into_iter()
            .map(|a| a.map(Into::into))
            .chain(ipv6.into_iter().map(|a| a.map(Into::into)))
    }
}

impl<I: Iterator<Item = fidl_fuchsia_net_interfaces_ext::Address>> From<I> for Addresses {
    fn from(addresses: I) -> Addresses {
        use itertools::Itertools as _;

        let (mut ipv4, mut ipv6): (Vec<_>, Vec<_>) = addresses.into_iter().partition_map(
            |fidl_fuchsia_net_interfaces_ext::Address { addr, valid_until, assignment_state }| {
                let fidl_fuchsia_net_ext::Subnet {
                    addr: fidl_fuchsia_net_ext::IpAddress(addr),
                    prefix_len,
                } = addr.into();
                let assignment_state = assignment_state.into();

                fn new_address<I>(
                    addr: I,
                    prefix_len: u8,
                    valid_until: i64,
                    assignment_state: AddressAssignmentState,
                ) -> Address<I> {
                    let valid_until = (valid_until != i64::MAX).then_some(valid_until);
                    Address { subnet: Subnet { addr, prefix_len }, valid_until, assignment_state }
                }
                match addr {
                    std::net::IpAddr::V4(addr) => itertools::Either::Left(new_address(
                        addr,
                        prefix_len,
                        valid_until,
                        assignment_state,
                    )),
                    std::net::IpAddr::V6(addr) => itertools::Either::Right(new_address(
                        addr,
                        prefix_len,
                        valid_until,
                        assignment_state,
                    )),
                }
            },
        );
        ipv4.sort();
        ipv6.sort();
        Addresses { ipv4, ipv6 }
    }
}

#[derive(serde::Serialize)]
pub(crate) enum DeviceClass {
    Loopback,
    Virtual,
    Ethernet,
    Wlan,
    Ppp,
    Bridge,
    WlanAp,
}

impl From<fidl_fuchsia_net_interfaces::DeviceClass> for DeviceClass {
    fn from(device_class: fidl_fuchsia_net_interfaces::DeviceClass) -> Self {
        match device_class {
            fidl_fuchsia_net_interfaces::DeviceClass::Loopback(
                fidl_fuchsia_net_interfaces::Empty,
            ) => Self::Loopback,
            fidl_fuchsia_net_interfaces::DeviceClass::Device(device_class) => match device_class {
                fidl_fuchsia_hardware_network::DeviceClass::Virtual => Self::Virtual,
                fidl_fuchsia_hardware_network::DeviceClass::Ethernet => Self::Ethernet,
                fidl_fuchsia_hardware_network::DeviceClass::Wlan => Self::Wlan,
                fidl_fuchsia_hardware_network::DeviceClass::Ppp => Self::Ppp,
                fidl_fuchsia_hardware_network::DeviceClass::Bridge => Self::Bridge,
                fidl_fuchsia_hardware_network::DeviceClass::WlanAp => Self::WlanAp,
            },
        }
    }
}

#[derive(serde::Serialize)]
/// Intermediary struct for serializing interface properties into JSON.
pub(crate) struct InterfaceView {
    pub(crate) nicid: u64,
    pub(crate) name: String,
    pub(crate) device_class: DeviceClass,
    pub(crate) online: bool,
    pub(crate) addresses: Addresses,
    pub(crate) has_default_ipv4_route: bool,
    pub(crate) has_default_ipv6_route: bool,
    pub(crate) mac: Option<fidl_fuchsia_net_ext::MacAddress>,
}

impl From<(fidl_fuchsia_net_interfaces_ext::Properties, Option<fidl_fuchsia_net::MacAddress>)>
    for InterfaceView
{
    fn from(
        t: (fidl_fuchsia_net_interfaces_ext::Properties, Option<fidl_fuchsia_net::MacAddress>),
    ) -> InterfaceView {
        let (
            fidl_fuchsia_net_interfaces_ext::Properties {
                id,
                name,
                device_class,
                online,
                addresses,
                has_default_ipv4_route,
                has_default_ipv6_route,
            },
            mac,
        ) = t;
        InterfaceView {
            nicid: id.get(),
            name,
            device_class: device_class.into(),
            online,
            addresses: addresses.into_iter().into(),
            has_default_ipv4_route,
            has_default_ipv6_route,
            mac: mac.map(Into::into),
        }
    }
}

#[derive(serde::Serialize, Ord, PartialOrd, Eq, PartialEq)]
/// Intermediary struct for serializing IP forwarding table entries into JSON.
pub struct ForwardingEntry {
    #[serde(rename = "destination")]
    subnet: Subnet<std::net::IpAddr>,
    #[serde(rename = "nicid")]
    device_id: u64,
    #[serde(rename = "gateway")]
    next_hop: Option<std::net::IpAddr>,
    metric: u32,
}

/// Errors returned when converting from [`froutes_ext::InstalledRoute`]
/// to [`ForwardingEntry`].
#[derive(Debug, Error)]
pub enum ForwardingEntryConversionError {
    #[error("the route's action was unknown")]
    UnknownRouteAction,
}

impl<I: net_types::ip::Ip> TryFrom<froutes_ext::InstalledRoute<I>> for ForwardingEntry {
    type Error = ForwardingEntryConversionError;
    fn try_from(route: froutes_ext::InstalledRoute<I>) -> Result<Self, Self::Error> {
        let froutes_ext::InstalledRoute {
            route: froutes_ext::Route { destination, action, properties: _ },
            effective_properties: froutes_ext::EffectiveRouteProperties { metric },
        } = route;
        let (device_id, next_hop) = match action {
            froutes_ext::RouteAction::Forward(froutes_ext::RouteTarget {
                outbound_interface,
                next_hop,
            }) => (outbound_interface, next_hop),
            froutes_ext::RouteAction::Unknown => {
                return Err(ForwardingEntryConversionError::UnknownRouteAction)
            }
        };
        let subnet = destination.into();
        let next_hop = next_hop.map(|next_hop| next_hop.get().to_ip_addr().into());
        Ok(Self { subnet, device_id, next_hop, metric })
    }
}

pub struct NeighborTableEntryIteratorItemVariants<T> {
    existing: T,
    added: T,
    changed: T,
    removed: T,
    idle: T,
}

impl<T> NeighborTableEntryIteratorItemVariants<T> {
    pub fn select(self, item: &fidl_fuchsia_net_neighbor::EntryIteratorItem) -> T {
        use fidl_fuchsia_net_neighbor::EntryIteratorItem;
        let Self { existing, added, changed, removed, idle } = self;
        match item {
            EntryIteratorItem::Existing(_) => existing,
            EntryIteratorItem::Added(_) => added,
            EntryIteratorItem::Changed(_) => changed,
            EntryIteratorItem::Removed(_) => removed,
            EntryIteratorItem::Idle(_) => idle,
        }
    }
}

impl<T> IntoIterator for NeighborTableEntryIteratorItemVariants<T> {
    type Item = T;
    type IntoIter = <[T; 5] as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        let Self { existing, added, changed, removed, idle } = self;
        [existing, added, changed, removed, idle].into_iter()
    }
}

pub const DISPLAYED_NEIGH_ENTRY_VARIANTS: NeighborTableEntryIteratorItemVariants<&'static str> =
    NeighborTableEntryIteratorItemVariants {
        existing: "EXISTING",
        added: "ADDED",
        changed: "CHANGED",
        removed: "REMOVED",
        idle: "IDLE",
    };

/// Intermediary type for serializing Entry (e.g. into JSON).
#[derive(serde::Serialize)]
pub struct NeighborTableEntry {
    interface: u64,
    neighbor: std::net::IpAddr,
    state: &'static str,
    mac: Option<fidl_fuchsia_net_ext::MacAddress>,
}

impl From<fidl_fuchsia_net_neighbor_ext::Entry> for NeighborTableEntry {
    fn from(
        fidl_fuchsia_net_neighbor_ext::Entry {
            interface,
            neighbor,
            state,
            mac,
            // Ignored since the tabular format ignores this field.
            updated_at: _,
        }: fidl_fuchsia_net_neighbor_ext::Entry,
    ) -> NeighborTableEntry {
        let fidl_fuchsia_net_ext::IpAddress(neighbor) = neighbor.into();
        NeighborTableEntry {
            interface,
            neighbor,
            state: fidl_fuchsia_net_neighbor_ext::display_entry_state(&state),
            mac: mac.map(|mac| mac.into()),
        }
    }
}