// Copyright 2019 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 {
    anyhow::{Context as _, Error},
    fidl_fuchsia_telephony_ril::{RadioInterfaceLayerMarker, SetupMarker},
    fuchsia_component::{
        client::{launch, launcher},
        fuchsia_single_component_package_url,
    },
    fuchsia_syslog::{self as syslog, macros::*},
    futures::future::{join_all, Future},
    futures::lock::Mutex,
    qmi as tel_ctl, //Todo: rename qmi module
    std::pin::Pin,
    std::sync::Arc,
    tel_dev::component_test::*,
};

// Send this command to attempt to make a call on the test driver and fail.
const AT_CMD_REQ_ATD_STR: &str = "ATD\r";
const AT_CMD_RESP_NO_CARRIER_STR: &str = "NO CARRIER\r";

// Send this string to request the test driver sends back an invalid text string.
const AT_CMD_REQ_INVALID_UNICODE_STR: &str = "INVALID UNICODE";

const RIL_URL: &str = fuchsia_single_component_package_url!("ril-at");

// TODO(kehrt) Split this into multiple tests.  Unfortunately, test setup and teardown multiple
// times causes a variety of errors I don't understand yet.
#[fuchsia_async::run_singlethreaded(test)]
async fn at_one_query_test() -> Result<(), Error> {
    syslog::init_with_tags(&["at-query-test"]).expect("Can't init logger");

    //Setup
    const TEL_PATH: &str = "class/at-transport";
    let found_device =
        get_fake_device_in_isolated_devmgr(TEL_PATH).await.expect("getting fake device");
    let launcher = launcher().context("Failed to open launcher service")?;
    let chan = tel_ctl::connect_transport_device(&found_device).await?;
    let app =
        launch(&launcher, RIL_URL.to_string(), None).context("Failed to launch ril-at service")?;
    let ril_modem_setup = app.connect_to_service::<SetupMarker>()?;
    ril_modem_setup.connect_transport(chan).await?.expect("make sure telephony svc is running");
    let ril_modem = app.connect_to_service::<RadioInterfaceLayerMarker>()?;

    // Test sending and receiving one message.
    fx_log_err!("sending ATD");
    let resp = ril_modem.raw_command(&AT_CMD_REQ_ATD_STR).await?.expect("error sending get info");
    assert_eq!(resp, AT_CMD_RESP_NO_CARRIER_STR);
    fx_log_err!("received and verified responses");

    // Test sending a message that causes a parse error for the response.
    fx_log_err!("sending a request which expects an error response");
    let resp = ril_modem
        .raw_command(&AT_CMD_REQ_INVALID_UNICODE_STR)
        .await
        .expect("error sending get info");
    assert!(resp.is_err());
    fx_log_err!("received and verified responses");

    // Test interleaving a bunch of sends and receives.  let ril_modem_arc = Arc::new(Mutex::new(ril_modem));
    let ril_modem_arc = Arc::new(Mutex::new(ril_modem));
    let mut vec: Vec<Pin<Box<dyn Future<Output = (i32, String)>>>> = Vec::new();
    for x in 0..100 {
        let ril_modem_arc = ril_modem_arc.clone();
        vec.push(Box::pin(async move {
            let send_string = format!("RACE{:}", x);
            let ril_modem_arc = ril_modem_arc.lock().await;
            let recv_result = ril_modem_arc.raw_command(&send_string).await;
            (x, recv_result.unwrap().unwrap())
        }))
    }

    let joined = join_all(vec).await;

    for (x, recv_result) in joined.into_iter() {
        let recv_string = format!("ECAR{:}", x);
        assert!(recv_string == recv_result);
    }
    // Tear down
    unbind_fake_device(&found_device)?;
    fx_log_err!("unbinded device");
    validate_removal_of_fake_device(TEL_PATH).await.expect("validate removal of device");
    Ok(())
}