// 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::{
    common_utils::common::macros::{fx_err_and_bail, with_line},
    light::types::{SerializableGroupInfo, SerializableInfo, SerializableRgb},
};
use anyhow::Error;
use fidl_fuchsia_hardware_light::{LightMarker, LightProxy, Rgb};
use fuchsia_syslog::macros::*;
use glob::glob;
use parking_lot::{RwLock, RwLockUpgradableReadGuard};

/// Perform Light operations.
///
/// Note this object is shared among all threads created by server.
///
#[derive(Debug)]
pub struct LightFacade {
    proxy: RwLock<Option<LightProxy>>,
}

impl LightFacade {
    pub fn new() -> Self {
        Self { proxy: RwLock::new(None) }
    }

    #[cfg(test)]
    fn new_with_proxy(proxy: LightProxy) -> Self {
        Self { proxy: RwLock::new(Some(proxy)) }
    }

    fn get_proxy(&self) -> Result<LightProxy, Error> {
        let tag = "LightFacade::get_proxy";

        let lock = self.proxy.upgradable_read();
        if let Some(proxy) = lock.as_ref() {
            Ok(proxy.clone())
        } else {
            let (proxy, server) = match fidl::endpoints::create_proxy::<LightMarker>() {
                Ok(r) => r,
                Err(e) => fx_err_and_bail!(
                    &with_line!(tag),
                    format_err!("Failed to get light proxy {:?}", e)
                ),
            };

            let found_path = glob("/dev/class/light/*")?.filter_map(|entry| entry.ok()).next();
            match found_path {
                Some(path) => {
                    fdio::service_connect(path.to_string_lossy().as_ref(), server.into_channel())?;
                    *RwLockUpgradableReadGuard::upgrade(lock) = Some(proxy.clone());
                    Ok(proxy)
                }
                None => fx_err_and_bail!(&with_line!(tag), format_err!("Failed to find device")),
            }
        }
    }

    pub async fn get_num_lights(&self) -> Result<u32, Error> {
        Ok(self.get_proxy()?.get_num_lights().await?)
    }

    pub async fn get_num_light_groups(&self) -> Result<u32, Error> {
        Ok(self.get_proxy()?.get_num_light_groups().await?)
    }

    pub async fn get_info(&self, index: u32) -> Result<SerializableInfo, Error> {
        let tag = "LightFacade::get_info";
        match self.get_proxy()?.get_info(index).await? {
            Ok(r) => Ok(SerializableInfo::new(&r)),
            Err(e) => fx_err_and_bail!(&with_line!(tag), format_err!("GetInfo failed {:?}", e)),
        }
    }

    pub async fn get_current_simple_value(&self, index: u32) -> Result<bool, Error> {
        let tag = "LightFacade::get_current_simple_value";
        match self.get_proxy()?.get_current_simple_value(index).await? {
            Ok(r) => Ok(r),
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("GetCurrentSimpleValue failed {:?}", e)
            ),
        }
    }

    pub async fn set_simple_value(&self, index: u32, value: bool) -> Result<(), Error> {
        let tag = "LightFacade::set_simple_value";
        match self.get_proxy()?.set_simple_value(index, value).await? {
            Ok(r) => Ok(r),
            Err(e) => {
                fx_err_and_bail!(&with_line!(tag), format_err!("SetSimpleValue failed {:?}", e))
            }
        }
    }

    pub async fn get_current_brightness_value(&self, index: u32) -> Result<f64, Error> {
        let tag = "LightFacade::get_current_brightness_value";
        match self.get_proxy()?.get_current_brightness_value(index).await? {
            Ok(r) => Ok(r),
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("GetCurrentBrightnessValue failed {:?}", e)
            ),
        }
    }

    pub async fn set_brightness_value(&self, index: u32, value: f64) -> Result<(), Error> {
        let tag = "LightFacade::set_brightness_value";
        match self.get_proxy()?.set_brightness_value(index, value).await? {
            Ok(r) => Ok(r),
            Err(e) => {
                fx_err_and_bail!(&with_line!(tag), format_err!("SetBrightnessValue failed {:?}", e))
            }
        }
    }

    pub async fn get_current_rgb_value(&self, index: u32) -> Result<SerializableRgb, Error> {
        let tag = "LightFacade::get_current_rgb_value";
        match self.get_proxy()?.get_current_rgb_value(index).await? {
            Ok(r) => Ok(SerializableRgb::new(&r)),
            Err(e) => {
                fx_err_and_bail!(&with_line!(tag), format_err!("GetCurrentRgbValue failed {:?}", e))
            }
        }
    }

    pub async fn set_rgb_value(&self, index: u32, value: SerializableRgb) -> Result<(), Error> {
        let tag = "LightFacade::set_rgb_value";
        let mut rgb = Rgb { red: value.red, green: value.green, blue: value.blue };
        match self.get_proxy()?.set_rgb_value(index, &mut rgb).await? {
            Ok(r) => Ok(r),
            Err(e) => fx_err_and_bail!(&with_line!(tag), format_err!("SetRgbValue failed {:?}", e)),
        }
    }

    pub async fn get_group_info(&self, index: u32) -> Result<SerializableGroupInfo, Error> {
        let tag = "LightFacade::get_group_info";
        match self.get_proxy()?.get_group_info(index).await? {
            Ok(r) => Ok(SerializableGroupInfo::new(&r)),
            Err(e) => {
                fx_err_and_bail!(&with_line!(tag), format_err!("GetGroupInfo failed {:?}", e))
            }
        }
    }

    pub async fn get_group_current_simple_value(&self, index: u32) -> Result<Vec<bool>, Error> {
        let tag = "LightFacade::get_group_current_simple_value";
        match self.get_proxy()?.get_group_current_simple_value(index).await? {
            Ok(r) => match r {
                Some(v) => Ok(v),
                None => fx_err_and_bail!(&with_line!(tag), format_err!("Expected a vector")),
            },
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("GetGroupCurrentSimpleValue failed {:?}", e)
            ),
        }
    }

    pub async fn set_group_simple_value(&self, index: u32, value: Vec<bool>) -> Result<(), Error> {
        let tag = "LightFacade::set_group_simple_value";
        match self.get_proxy()?.set_group_simple_value(index, &mut value.into_iter()).await? {
            Ok(_) => Ok(()),
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("SetGroupSimpleValue failed {:?}", e)
            ),
        }
    }

    pub async fn get_group_current_brightness_value(&self, index: u32) -> Result<Vec<f64>, Error> {
        let tag = "LightFacade::get_group_current_brightness_value";
        match self.get_proxy()?.get_group_current_brightness_value(index).await? {
            Ok(r) => match r {
                Some(v) => Ok(v),
                None => fx_err_and_bail!(&with_line!(tag), format_err!("Expected a vector")),
            },
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("GetGroupCurrentBrightnessValue failed {:?}", e)
            ),
        }
    }

    pub async fn set_group_brightness_value(
        &self,
        index: u32,
        value: Vec<f64>,
    ) -> Result<(), Error> {
        let tag = "LightFacade::set_group_brightness_value";
        match self.get_proxy()?.set_group_brightness_value(index, &value).await? {
            Ok(_) => Ok(()),
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("SetGroupBrightnessValue failed {:?}", e)
            ),
        }
    }

    pub async fn get_group_current_rgb_value(
        &self,
        index: u32,
    ) -> Result<Vec<SerializableRgb>, Error> {
        let tag = "LightFacade::get_group_current_rgb_value";
        let values = match self.get_proxy()?.get_group_current_rgb_value(index).await? {
            Ok(r) => match r {
                Some(v) => v,
                None => fx_err_and_bail!(&with_line!(tag), format_err!("Expected a vector")),
            },
            Err(e) => fx_err_and_bail!(
                &with_line!(tag),
                format_err!("GetGroupCurrentRgbValue failed {:?}", e)
            ),
        };
        let ret = values
            .into_iter()
            .map(|x| SerializableRgb { red: x.red, green: x.green, blue: x.blue })
            .collect::<Vec<_>>();
        Ok(ret)
    }

    pub async fn set_group_rgb_value(
        &self,
        index: u32,
        value: Vec<SerializableRgb>,
    ) -> Result<(), Error> {
        let tag = "LightFacade::set_group_rgb_value";
        let mut rgb = value
            .into_iter()
            .map(|x| Rgb { red: x.red, green: x.green, blue: x.blue })
            .collect::<Vec<Rgb>>();
        match self.get_proxy()?.set_group_rgb_value(index, &mut rgb.iter_mut()).await? {
            Ok(_) => Ok(()),
            Err(e) => {
                fx_err_and_bail!(&with_line!(tag), format_err!("SetGroupRgbValue failed {:?}", e))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::light::types::SerializableCapability;
    use fidl_fuchsia_hardware_light::{Capability, GroupInfo, Info, LightError, LightRequest, Rgb};
    use futures::{future::Future, join, stream::StreamExt};
    use matches::assert_matches;

    struct MockLightBuilder {
        expected: Vec<Box<dyn FnOnce(LightRequest) + Send + 'static>>,
    }

    impl MockLightBuilder {
        fn new() -> Self {
            Self { expected: vec![] }
        }

        fn push(mut self, request: impl FnOnce(LightRequest) + Send + 'static) -> Self {
            self.expected.push(Box::new(request));
            self
        }

        fn expect_get_num_lights(self, count: u32) -> Self {
            self.push(move |req| match req {
                LightRequest::GetNumLights { responder } => responder.send(count).unwrap(),
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_num_light_groups(self, count: u32) -> Self {
            self.push(move |req| match req {
                LightRequest::GetNumLightGroups { responder } => responder.send(count).unwrap(),
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_info(self, idx: u32, res: Result<SerializableInfo, LightError>) -> Self {
            self.push(move |req| match req {
                LightRequest::GetInfo { index, responder } => {
                    assert_eq!(idx, index);
                    responder
                        .send(&mut res.map(|info| Info {
                            name: info.name.clone(),
                            capability: Capability::from(info.capability),
                        }))
                        .unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_current_simple_value(self, idx: u32, res: Result<bool, LightError>) -> Self {
            self.push(move |req| match req {
                LightRequest::GetCurrentSimpleValue { index, responder } => {
                    assert_eq!(idx, index);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_simple_value(self, idx: u32, val: bool, res: Result<(), LightError>) -> Self {
            self.push(move |req| match req {
                LightRequest::SetSimpleValue { index, value, responder } => {
                    assert_eq!(idx, index);
                    assert_eq!(val, value);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_current_brightness_value(
            self,
            idx: u32,
            res: Result<f64, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetCurrentBrightnessValue { index, responder } => {
                    assert_eq!(idx, index);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_brightness_value(
            self,
            idx: u32,
            val: f64,
            res: Result<(), LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::SetBrightnessValue { index, value, responder } => {
                    assert_eq!(idx, index);
                    assert_eq!(val, value);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_current_rgb_value(
            self,
            idx: u32,
            res: Result<SerializableRgb, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetCurrentRgbValue { index, responder } => {
                    assert_eq!(idx, index);
                    responder
                        .send(&mut res.map(|rgb| Rgb {
                            red: rgb.red,
                            green: rgb.green,
                            blue: rgb.blue,
                        }))
                        .unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_rgb_value(
            self,
            idx: u32,
            val: SerializableRgb,
            res: Result<(), LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::SetRgbValue { index, value, responder } => {
                    assert_eq!(idx, index);
                    assert_eq!(val, SerializableRgb::new(&value));
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_group_info(
            self,
            id: u32,
            res: Result<SerializableGroupInfo, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetGroupInfo { group_id, responder } => {
                    assert_eq!(id, group_id);
                    responder
                        .send(&mut res.map(|info| GroupInfo {
                            name: info.name.clone(),
                            count: info.count,
                            capability: Capability::from(info.capability),
                        }))
                        .unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_group_current_simple_value(
            self,
            id: u32,
            res: Result<Vec<bool>, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetGroupCurrentSimpleValue { group_id, responder } => {
                    assert_eq!(id, group_id);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_group_simple_value(
            self,
            id: u32,
            vals: Vec<bool>,
            res: Result<(), LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::SetGroupSimpleValue { group_id, values, responder } => {
                    assert_eq!(id, group_id);
                    assert_eq!(vals, values);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_group_current_brightness_value(
            self,
            id: u32,
            res: Result<Vec<f64>, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetGroupCurrentBrightnessValue { group_id, responder } => {
                    assert_eq!(id, group_id);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_group_brightness_value(
            self,
            id: u32,
            vals: Vec<f64>,
            res: Result<(), LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::SetGroupBrightnessValue { group_id, values, responder } => {
                    assert_eq!(id, group_id);
                    assert_eq!(vals, values);
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_get_group_current_rgb_value(
            self,
            id: u32,
            res: Result<Option<Vec<SerializableRgb>>, LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::GetGroupCurrentRgbValue { group_id, responder } => {
                    assert_eq!(id, group_id);
                    responder
                        .send(&mut res.map(|opt| {
                            opt.map(|vec| {
                                vec.iter().map(|x| Into::into(x.clone())).collect::<Vec<_>>()
                            })
                        }))
                        .unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn expect_set_group_rgb_value(
            self,
            id: u32,
            vals: Vec<SerializableRgb>,
            res: Result<(), LightError>,
        ) -> Self {
            self.push(move |req| match req {
                LightRequest::SetGroupRgbValue { group_id, values, responder } => {
                    assert_eq!(id, group_id);
                    assert_eq!(vals, values.iter().map(|x| Into::into(*x)).collect::<Vec<_>>());
                    responder.send(&mut res.map(Into::into)).unwrap()
                }
                req => panic!("unexpected request: {:?}", req),
            })
        }

        fn build(self) -> (LightFacade, impl Future<Output = ()>) {
            let (proxy, mut stream) =
                fidl::endpoints::create_proxy_and_stream::<LightMarker>().unwrap();
            let fut = async move {
                for expected in self.expected {
                    expected(stream.next().await.unwrap().unwrap());
                }
                assert_matches!(stream.next().await, None);
            };

            (LightFacade::new_with_proxy(proxy), fut)
        }
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_num_lights_ok() {
        let (facade, lights) = MockLightBuilder::new().expect_get_num_lights(3).build();
        let test = async move {
            assert_matches!(facade.get_num_lights().await, Ok(3));
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_num_light_groups_ok() {
        let (facade, lights) = MockLightBuilder::new().expect_get_num_light_groups(5).build();
        let test = async move {
            assert_matches!(facade.get_num_light_groups().await, Ok(5));
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_info_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_info(
                4,
                Ok(SerializableInfo {
                    name: "test_light".to_string(),
                    capability: SerializableCapability::Rgb,
                }),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade.get_info(4).await,
                Ok(info) if info == SerializableInfo {
                    name: "test_light".to_string(),
                    capability: SerializableCapability::Rgb
                }
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_current_simple_value_ok() {
        let (facade, lights) =
            MockLightBuilder::new().expect_get_current_simple_value(2, Ok(true)).build();
        let test = async move {
            assert_matches!(facade.get_current_simple_value(2).await, Ok(true));
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_simple_value_ok() {
        let (facade, lights) =
            MockLightBuilder::new().expect_set_simple_value(1, false, Ok(())).build();
        let test = async move {
            assert_matches!(facade.set_simple_value(1, false).await, Ok(()));
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_current_brightness_value_ok() {
        let (facade, lights) =
            MockLightBuilder::new().expect_get_current_brightness_value(0, Ok(0.3321)).build();
        let test = async move {
            assert_matches!(facade.get_current_brightness_value(0).await, Ok(v) if v == 0.3321);
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_brightness_value_ok() {
        let (facade, lights) =
            MockLightBuilder::new().expect_set_brightness_value(1, 0.2515, Ok(())).build();
        let test = async move {
            assert_matches!(facade.set_brightness_value(1, 0.2515).await, Ok(()));
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_current_rgb_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_current_rgb_value(
                4,
                Ok(SerializableRgb { red: 0.21, green: 0.94, blue: 0.59 }),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade.get_current_rgb_value(4).await,
                Ok(rgb) if rgb == SerializableRgb { red: 0.21, green: 0.94, blue: 0.59 }
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_rgb_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_set_rgb_value(
                3,
                SerializableRgb { red: 0.33, green: 0.45, blue: 0.155 },
                Ok(()),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade
                    .set_rgb_value(3, SerializableRgb { red: 0.33, green: 0.45, blue: 0.155 })
                    .await,
                Ok(())
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_group_info_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_group_info(
                2,
                Ok(SerializableGroupInfo {
                    name: "test_light_group".to_string(),
                    count: 5,
                    capability: SerializableCapability::Brightness,
                }),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade.get_group_info(2).await,
                Ok(info) if info == SerializableGroupInfo {
                    name: "test_light_group".to_string(),
                    count: 5,
                    capability: SerializableCapability::Brightness
                }
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_group_current_simple_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_group_current_simple_value(0, Ok(vec![false, true, false]))
            .build();
        let test = async move {
            assert_matches!(
                facade.get_group_current_simple_value(0).await,
                Ok(v) if v == vec![false, true, false]
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_group_simple_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_set_group_simple_value(3, vec![true, true, false], Ok(()))
            .build();
        let test = async move {
            assert_matches!(
                facade.set_group_simple_value(3, vec![true, true, false]).await,
                Ok(())
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_group_current_brightness_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_group_current_brightness_value(1, Ok(vec![0.46, 0.2, 0.77, 0.315, 0.8]))
            .build();
        let test = async move {
            assert_matches!(
                facade.get_group_current_brightness_value(1).await,
                Ok(v) if v == vec![0.46, 0.2, 0.77, 0.315, 0.8]
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_group_brightness_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_set_group_brightness_value(2, vec![0.0, 0.96, 0.37, 0.63], Ok(()))
            .build();
        let test = async move {
            assert_matches!(
                facade.set_group_brightness_value(2, vec![0.0, 0.96, 0.37, 0.63]).await,
                Ok(())
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn get_group_current_rgb_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_get_group_current_rgb_value(
                0,
                Ok(Some(vec![
                    SerializableRgb { red: 0.24, green: 0.41, blue: 0.121 },
                    SerializableRgb { red: 0.83, green: 0.23, blue: 0.155 },
                ])),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade.get_group_current_rgb_value(0).await,
                Ok(v) if v == vec![
                    SerializableRgb { red: 0.24, green: 0.41, blue: 0.121 },
                    SerializableRgb { red: 0.83, green: 0.23, blue: 0.155 }
                ]
            );
        };

        join!(lights, test);
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn set_group_rgb_value_ok() {
        let (facade, lights) = MockLightBuilder::new()
            .expect_set_group_rgb_value(
                1,
                vec![
                    SerializableRgb { red: 0.0, green: 0.3, blue: 0.3 },
                    SerializableRgb { red: 0.111, green: 0.222, blue: 0.11 },
                    SerializableRgb { red: 0.194, green: 0.9, blue: 0.70 },
                ],
                Ok(()),
            )
            .build();
        let test = async move {
            assert_matches!(
                facade
                    .set_group_rgb_value(
                        1,
                        vec![
                            SerializableRgb { red: 0.0, green: 0.3, blue: 0.3 },
                            SerializableRgb { red: 0.111, green: 0.222, blue: 0.11 },
                            SerializableRgb { red: 0.194, green: 0.9, blue: 0.70 }
                        ]
                    )
                    .await,
                Ok(())
            );
        };

        join!(lights, test);
    }
}