// Copyright 2020 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::{Address, Properties, PropertiesAndState, Update, UpdateResult, WatcherOperationError};

use fidl_fuchsia_net as fnet;
use fidl_fuchsia_net_interfaces as fnet_interfaces;
use futures::{Stream, TryStreamExt};
use net_types::{LinkLocalAddress as _, ScopeableAddress as _};
use std::collections::{HashMap, HashSet};
use thiserror::Error;

/// Returns true iff the supplied [`Properties`] (expected to be fully populated)
/// appears to provide network connectivity, i.e. is not loopback, is online, and has a default
/// route and a globally routable address for either IPv4 or IPv6. An IPv4 address is assumed to be
/// globally routable if it's not link-local. An IPv6 address is assumed to be globally routable if
/// it has global scope.
pub fn is_globally_routable(
    &Properties {
        ref device_class,
        online,
        ref addresses,
        has_default_ipv4_route,
        has_default_ipv6_route,
        ..
    }: &Properties,
) -> bool {
    match device_class {
        fnet_interfaces::DeviceClass::Loopback(fnet_interfaces::Empty {}) => {
            return false;
        }
        fnet_interfaces::DeviceClass::Device(device) => match device {
            fidl_fuchsia_hardware_network::DeviceClass::Virtual
            | fidl_fuchsia_hardware_network::DeviceClass::Ethernet
            | fidl_fuchsia_hardware_network::DeviceClass::Wlan
            | fidl_fuchsia_hardware_network::DeviceClass::WlanAp
            | fidl_fuchsia_hardware_network::DeviceClass::Ppp
            | fidl_fuchsia_hardware_network::DeviceClass::Bridge => {}
        },
    }
    if !online {
        return false;
    }
    if !has_default_ipv4_route && !has_default_ipv6_route {
        return false;
    }
    addresses.iter().any(
        |Address {
             addr: fnet::Subnet { addr, prefix_len: _ },
             valid_until: _,
             assignment_state,
         }| {
            let assigned = match assignment_state {
                fnet_interfaces::AddressAssignmentState::Assigned => true,
                fnet_interfaces::AddressAssignmentState::Tentative
                | fnet_interfaces::AddressAssignmentState::Unavailable => false,
            };
            assigned
                && match addr {
                    fnet::IpAddress::Ipv4(fnet::Ipv4Address { addr }) => {
                        has_default_ipv4_route
                            && !net_types::ip::Ipv4Addr::new(*addr).is_link_local()
                    }
                    fnet::IpAddress::Ipv6(fnet::Ipv6Address { addr }) => {
                        has_default_ipv6_route
                            && net_types::ip::Ipv6Addr::from_bytes(*addr).scope()
                                == net_types::ip::Ipv6Scope::Global
                    }
                }
        },
    )
}

/// Wraps `event_stream` and returns a stream which yields the reachability status as a bool (true
/// iff there exists an interface with properties that satisfy [`is_globally_routable`]) whenever
/// it changes. The first item the returned stream yields is the reachability status of the first
/// interface discovered through an `Added` or `Existing` event on `event_stream`.
///
/// Note that `event_stream` must be created from a watcher with interest in all
/// fields, such as one created from [`crate::event_stream_from_state`].
pub fn to_reachability_stream(
    event_stream: impl Stream<Item = Result<fnet_interfaces::Event, fidl::Error>>,
) -> impl Stream<Item = Result<bool, WatcherOperationError<(), HashMap<u64, PropertiesAndState<()>>>>>
{
    let mut if_map = HashMap::<u64, _>::new();
    let mut reachable = None;
    let mut reachable_ids = HashSet::new();
    event_stream.map_err(WatcherOperationError::EventStream).try_filter_map(move |event| {
        futures::future::ready(if_map.update(event).map_err(WatcherOperationError::Update).map(
            |changed: UpdateResult<'_, ()>| {
                let reachable_ids_changed = match changed {
                    UpdateResult::Existing { properties, state: _ }
                    | UpdateResult::Added { properties, state: _ }
                    | UpdateResult::Changed { previous: _, current: properties, state: _ }
                        if is_globally_routable(properties) =>
                    {
                        reachable_ids.insert(properties.id)
                    }
                    UpdateResult::Existing { .. } | UpdateResult::Added { .. } => false,
                    UpdateResult::Changed { previous: _, current: properties, state: _ } => {
                        reachable_ids.remove(&properties.id)
                    }
                    UpdateResult::Removed(PropertiesAndState { properties, state: _ }) => {
                        reachable_ids.remove(&properties.id)
                    }
                    UpdateResult::NoChange => return None,
                };
                // If the stream hasn't yielded anything yet, do so even if the set of reachable
                // interfaces hasn't changed.
                if reachable.is_none() {
                    reachable = Some(!reachable_ids.is_empty());
                    return reachable;
                } else if reachable_ids_changed {
                    let new_reachable = Some(!reachable_ids.is_empty());
                    if reachable != new_reachable {
                        reachable = new_reachable;
                        return reachable;
                    }
                }
                None
            },
        ))
    })
}

/// Reachability status stream operational errors.
#[derive(Error, Debug)]
pub enum OperationError<S: std::fmt::Debug, B: Update<S> + std::fmt::Debug> {
    #[error("watcher operation error: {0}")]
    Watcher(WatcherOperationError<S, B>),
    #[error("reachability status stream ended unexpectedly")]
    UnexpectedEnd,
}

/// Returns a future which resolves when any network interface observed through `event_stream`
/// has properties which satisfy [`is_globally_routable`].
pub async fn wait_for_reachability(
    event_stream: impl Stream<Item = Result<fnet_interfaces::Event, fidl::Error>>,
) -> Result<(), OperationError<(), HashMap<u64, PropertiesAndState<()>>>> {
    futures::pin_mut!(event_stream);
    let rtn = to_reachability_stream(event_stream)
        .map_err(OperationError::Watcher)
        .try_filter_map(|reachable| futures::future::ok(if reachable { Some(()) } else { None }))
        .try_next()
        .await
        .and_then(|item| item.ok_or_else(|| OperationError::UnexpectedEnd));
    rtn
}

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

    use anyhow::Context as _;
    use fidl_fuchsia_hardware_network as fnetwork;
    use fuchsia_zircon_types as zx;
    use futures::FutureExt as _;
    use net_declare::fidl_subnet;
    use std::convert::TryInto as _;

    const IPV4_LINK_LOCAL: fnet::Subnet = fidl_subnet!("169.254.0.1/16");
    const IPV6_LINK_LOCAL: fnet::Subnet = fidl_subnet!("fe80::1/64");
    const IPV4_GLOBAL: fnet::Subnet = fidl_subnet!("192.168.0.1/16");
    const IPV6_GLOBAL: fnet::Subnet = fidl_subnet!("100::1/64");

    fn valid_interface(id: u64) -> fnet_interfaces::Properties {
        fnet_interfaces::Properties {
            id: Some(id),
            name: Some("test1".to_string()),
            device_class: Some(fnet_interfaces::DeviceClass::Device(
                fnetwork::DeviceClass::Ethernet,
            )),
            online: Some(true),
            addresses: Some(vec![
                fnet_interfaces::Address {
                    addr: Some(IPV4_GLOBAL),
                    valid_until: Some(zx::ZX_TIME_INFINITE),
                    assignment_state: Some(fnet_interfaces::AddressAssignmentState::Assigned),
                    ..Default::default()
                },
                fnet_interfaces::Address {
                    addr: Some(IPV4_LINK_LOCAL),
                    valid_until: Some(zx::ZX_TIME_INFINITE),
                    assignment_state: Some(fnet_interfaces::AddressAssignmentState::Assigned),
                    ..Default::default()
                },
                fnet_interfaces::Address {
                    addr: Some(IPV6_GLOBAL),
                    valid_until: Some(zx::ZX_TIME_INFINITE),
                    assignment_state: Some(fnet_interfaces::AddressAssignmentState::Assigned),
                    ..Default::default()
                },
                fnet_interfaces::Address {
                    addr: Some(IPV6_LINK_LOCAL),
                    valid_until: Some(zx::ZX_TIME_INFINITE),
                    assignment_state: Some(fnet_interfaces::AddressAssignmentState::Assigned),
                    ..Default::default()
                },
            ]),
            has_default_ipv4_route: Some(true),
            has_default_ipv6_route: Some(true),
            ..Default::default()
        }
    }

    #[test]
    fn test_is_globally_routable() -> Result<(), anyhow::Error> {
        const ID: u64 = 1;
        // These combinations are not globally routable.
        assert!(!is_globally_routable(&Properties {
            device_class: fnet_interfaces::DeviceClass::Loopback(fnet_interfaces::Empty {}),
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            online: false,
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            addresses: vec![],
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            has_default_ipv4_route: false,
            has_default_ipv6_route: false,
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV4_GLOBAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv4_route: false,
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV6_GLOBAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv6_route: false,
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV6_LINK_LOCAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv6_route: true,
            ..valid_interface(ID).try_into()?
        }));
        assert!(!is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV4_LINK_LOCAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv4_route: true,
            ..valid_interface(ID).try_into()?
        }));

        // These combinations are globally routable.
        assert!(is_globally_routable(&valid_interface(ID).try_into()?));
        assert!(is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV4_GLOBAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv4_route: true,
            has_default_ipv6_route: false,
            ..valid_interface(ID).try_into()?
        }));
        assert!(is_globally_routable(&Properties {
            addresses: vec![Address {
                addr: IPV6_GLOBAL,
                valid_until: zx::ZX_TIME_INFINITE,
                assignment_state: fnet_interfaces::AddressAssignmentState::Assigned,
            }],
            has_default_ipv4_route: false,
            has_default_ipv6_route: true,
            ..valid_interface(ID).try_into()?
        }));
        Ok(())
    }

    #[test]
    fn test_to_reachability_stream() -> Result<(), anyhow::Error> {
        let (sender, receiver) = futures::channel::mpsc::unbounded();
        let mut reachability_stream = to_reachability_stream(receiver);
        for (event, want) in vec![
            (fnet_interfaces::Event::Idle(fnet_interfaces::Empty {}), None),
            // Added events
            (
                fnet_interfaces::Event::Added(fnet_interfaces::Properties {
                    online: Some(false),
                    ..valid_interface(1)
                }),
                Some(false),
            ),
            (fnet_interfaces::Event::Added(valid_interface(2)), Some(true)),
            (
                fnet_interfaces::Event::Added(fnet_interfaces::Properties {
                    online: Some(false),
                    ..valid_interface(3)
                }),
                None,
            ),
            // Changed events
            (
                fnet_interfaces::Event::Changed(fnet_interfaces::Properties {
                    id: Some(2),
                    online: Some(false),
                    ..Default::default()
                }),
                Some(false),
            ),
            (
                fnet_interfaces::Event::Changed(fnet_interfaces::Properties {
                    id: Some(1),
                    online: Some(true),
                    ..Default::default()
                }),
                Some(true),
            ),
            (
                fnet_interfaces::Event::Changed(fnet_interfaces::Properties {
                    id: Some(3),
                    online: Some(true),
                    ..Default::default()
                }),
                None,
            ),
            // Removed events
            (fnet_interfaces::Event::Removed(1), None),
            (fnet_interfaces::Event::Removed(3), Some(false)),
            (fnet_interfaces::Event::Removed(2), None),
        ] {
            let () = sender.unbounded_send(Ok(event.clone())).context("failed to send event")?;
            let got = reachability_stream.try_next().now_or_never();
            if let Some(want_reachable) = want {
                let r = got.ok_or_else(|| {
                    anyhow::anyhow!("reachability status stream unexpectedly yielded nothing")
                })?;
                let item = r.context("reachability status stream error")?;
                let got_reachable = item.ok_or_else(|| {
                    anyhow::anyhow!("reachability status stream ended unexpectedly")
                })?;
                assert_eq!(got_reachable, want_reachable);
            } else {
                if got.is_some() {
                    panic!("got {:?} from reachability stream after event {:?}, want None as reachability status should not have changed", got, event);
                }
            }
        }
        Ok(())
    }
}