// 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 super::*;
use crate::prelude::*;
use crate::spinel::*;
use futures::prelude::*;
use mock::*;

use crate::spinel::mock::PROP_DEBUG_LOGGING_TEST;
use fidl_fuchsia_lowpan::{Credential, Identity, ProvisioningParams, NET_TYPE_THREAD_1_X};
use fidl_fuchsia_lowpan_test::NeighborInfo;
use lowpan_driver_common::Driver as _;

impl<DS, NI> SpinelDriver<DS, NI> {
    pub(super) fn get_driver_state_snapshot(&self) -> DriverState {
        self.driver_state.lock().clone()
    }
}

#[fasync::run_until_stalled(test)]
async fn test_spinel_lowpan_driver() {
    let (device_client, device_stream, ncp_task) = new_fake_spinel_pair();
    let network_interface = DummyNetworkInterface::default();
    let driver = SpinelDriver::new(device_client, network_interface);
    let driver_stream = driver.wrap_inbound_stream(device_stream);

    assert_eq!(driver.get_driver_state_snapshot().caps.len(), 0);

    let app_task = async {
        // Wait until we are ready.
        driver.wait_for_state(DriverState::is_initialized).await;

        // Verify that our capabilities have been set by this point.
        assert_eq!(driver.get_driver_state_snapshot().caps.len(), 2);

        let mut device_state_stream = driver.watch_device_state();

        traceln!("app_task: Checking device state... (Should be Inactive)");
        assert_eq!(
            device_state_stream.try_next().await.unwrap().unwrap().connectivity_state.unwrap(),
            ConnectivityState::Inactive
        );

        traceln!("app_task: Making sure it only vends one state when nothing has changed.");
        assert!(device_state_stream.next().now_or_never().is_none());

        for i in 1u8..32 {
            traceln!("app_task: Iteration {}", i);

            let channels = driver.get_supported_channels().await;
            traceln!("app_task: Supported channels: {:?}", channels);
            assert_eq!(channels.map(|_| ()), Ok(()));

            let fact_mac = driver.get_factory_mac_address().await;
            traceln!("app_task: Factory MAC: {:?}", fact_mac);
            assert_eq!(fact_mac.map(|_| ()), Ok(()));

            let curr_mac = driver.get_current_mac_address().await;
            traceln!("app_task: Current MAC: {:?}", curr_mac);
            assert_eq!(curr_mac.map(|_| ()), Ok(()));

            let ncp_ver = driver.get_ncp_version().await;
            traceln!("app_task: NCP Version: {:?}", ncp_ver);
            assert_eq!(ncp_ver.map(|_| ()), Ok(()));

            let network_types = driver.get_supported_network_types().await;
            traceln!("app_task: Supported Network Types: {:?}", network_types);
            assert_eq!(
                network_types,
                Ok(vec![fidl_fuchsia_lowpan::NET_TYPE_THREAD_1_X.to_string()])
            );

            let curr_chan = driver.get_current_channel().await;
            traceln!("app_task: Current Channel: {:?}", curr_chan);
            assert_eq!(curr_chan.map(|_| ()), Ok(()));

            let curr_rssi = driver.get_current_rssi().await;
            traceln!("app_task: Current RSSI: {:?}", curr_rssi);
            assert_eq!(curr_rssi.map(|_| ()), Ok(()));

            let part_id = driver.get_partition_id().await;
            traceln!("app_task: partition id: {:?}", part_id);
            assert_eq!(part_id.map(|_| ()), Ok(()));

            let thread_rloc16 = driver.get_thread_rloc16().await;
            traceln!("app_task: thread_rloc16: {:?}", thread_rloc16);
            assert_eq!(thread_rloc16.map(|_| ()), Ok(()));

            let thread_neighbor_table = driver.get_neighbor_table().await;
            traceln!("app_task: thread_neighbor_table: {:?}", thread_neighbor_table);
            let thread_neighbor_entry_vec = thread_neighbor_table.unwrap();
            assert_eq!(
                thread_neighbor_entry_vec[0],
                NeighborInfo {
                    mac_address: Some([0, 1, 2, 3, 4, 5, 6, 7].to_vec()),
                    short_address: Some(0x123),
                    age: Some(fuchsia_zircon::Duration::from_seconds(11).into_nanos()),
                    is_child: Some(true),
                    link_frame_count: Some(1),
                    mgmt_frame_count: Some(1),
                    last_rssi_in: Some(-20),
                    avg_rssi_in: Some(-20),
                    lqi_in: Some(3),
                    thread_mode: Some(0x0b),
                    ..NeighborInfo::EMPTY
                }
            );
            assert_eq!(
                thread_neighbor_entry_vec[1],
                NeighborInfo {
                    mac_address: Some([1, 2, 3, 4, 5, 6, 7, 8].to_vec()),
                    short_address: Some(0x1234),
                    age: Some(fuchsia_zircon::Duration::from_seconds(22).into_nanos()),
                    is_child: Some(true),
                    link_frame_count: Some(1),
                    mgmt_frame_count: Some(1),
                    last_rssi_in: Some(-30),
                    avg_rssi_in: Some(-30),
                    lqi_in: Some(4),
                    thread_mode: Some(0x0b),
                    ..NeighborInfo::EMPTY
                }
            );

            traceln!("app_task: Attempting a reset...");
            assert_eq!(driver.reset().await, Ok(()));
            traceln!("app_task: Did reset!");

            traceln!("app_task: Checking device state... (Should be Inactive) (1)");
            assert_eq!(
                driver
                    .watch_device_state()
                    .try_next()
                    .await
                    .unwrap()
                    .unwrap()
                    .connectivity_state
                    .unwrap(),
                ConnectivityState::Inactive
            );

            traceln!("app_task: Setting identity...");
            assert_eq!(
                driver
                    .provision_network(ProvisioningParams {
                        identity: Identity {
                            raw_name: Some("MyNetwork".as_bytes().to_vec()),
                            xpanid: Some([0, 1, 2, 3, 4, 5, 6, 7].to_vec()),
                            net_type: Some(NET_TYPE_THREAD_1_X.to_string()),
                            channel: Some(11),
                            panid: Some(0x1234),
                            ..Identity::EMPTY
                        },
                        credential: Some(Box::new(Credential::MasterKey(vec![
                            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
                        ]))),
                    })
                    .await,
                Ok(())
            );
            traceln!("app_task: Did provision!");

            traceln!("app_task: Checking device state... (Should be Ready)");
            assert_eq!(
                driver
                    .watch_device_state()
                    .try_next()
                    .await
                    .unwrap()
                    .unwrap()
                    .connectivity_state
                    .unwrap(),
                ConnectivityState::Ready
            );

            traceln!("app_task: Checking credential...");
            assert_eq!(
                driver.get_credential().await,
                Ok(Some(Credential::MasterKey(vec![
                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
                ])))
            );
            traceln!("app_task: Credential is correct!");

            traceln!("app_task: Leaving network...");
            assert_eq!(driver.leave_network().await, Ok(()));
            traceln!("app_task: Did leave!");

            traceln!("app_task: Setting enabled...");
            assert_eq!(driver.set_active(true).await, Ok(()));
            traceln!("app_task: Did enable!");

            traceln!("app_task: Checking device state... (Should be Offline)");
            assert_eq!(
                device_state_stream.try_next().await.unwrap().unwrap().connectivity_state.unwrap(),
                ConnectivityState::Offline
            );

            traceln!("app_task: Performing energy scan...");
            let energy_scan_stream =
                driver.start_energy_scan(&fidl_fuchsia_lowpan_device::EnergyScanParameters::EMPTY);
            assert_eq!(energy_scan_stream.try_collect::<Vec<_>>().await.unwrap().len(), 3);

            traceln!("app_task: Performing network scan...");
            let network_scan_stream = driver
                .start_network_scan(&fidl_fuchsia_lowpan_device::NetworkScanParameters::EMPTY);
            assert_eq!(network_scan_stream.try_collect::<Vec<_>>().await.unwrap().len(), 3);

            traceln!("app_task: Testing debug logging...");
            driver
                .frame_handler
                .send_request(CmdPropValueSet(PROP_DEBUG_LOGGING_TEST, ()))
                .await
                .unwrap();

            traceln!("app_task: Setting disabled...");
            assert_eq!(driver.set_active(false).await, Ok(()));
            traceln!("app_task: Did disable!");

            traceln!("app_task: Checking device state... (Should be Inactive) (2)");
            assert_eq!(
                device_state_stream.try_next().await.unwrap().unwrap().connectivity_state.unwrap(),
                ConnectivityState::Inactive
            );
        }
    };

    futures::select! {
        ret = driver_stream.try_for_each(|_|futures::future::ready(Ok(()))).fuse()
            => panic!("Driver stream error: {:?}", ret),
        ret = ncp_task.fuse()
            => panic!("NCP task error: {:?}", ret),
        _ = app_task.boxed_local().fuse() => (),
    }
}