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

#[cfg(test)]
use std::collections::HashMap;
use std::option::Option::Some;
use std::sync::Arc;

use fidl_fuchsia_settings::{LightError, LightMarker, LightProxy};
use futures::lock::Mutex;

use crate::agent::restore_agent;
use crate::registry::device_storage::testing::*;
use crate::registry::device_storage::DeviceStorage;
use crate::switchboard::base::SettingType;
use crate::switchboard::light_types::{
    ColorRgb, LightGroup, LightInfo, LightState, LightType, LightValue,
};
use crate::tests::fakes::hardware_light_service::HardwareLightService;
use crate::tests::fakes::service_registry::ServiceRegistry;
use crate::EnvironmentBuilder;

type HardwareLightServiceHandle = Arc<Mutex<HardwareLightService>>;

const ENV_NAME: &str = "settings_service_light_test_environment";
const CONTEXT_ID: u64 = 0;

const LIGHT_NAME_1: &str = "light_name_1";
const LIGHT_NAME_2: &str = "light_name_2";

fn get_test_light_info() -> LightInfo {
    let mut light_groups = HashMap::new();
    light_groups.insert(
        LIGHT_NAME_1.to_string(),
        LightGroup {
            name: LIGHT_NAME_1.to_string(),
            enabled: true,
            light_type: LightType::Brightness,
            lights: vec![LightState { value: Some(LightValue::Brightness(42)) }],
            hardware_index: vec![0],
        },
    );
    light_groups.insert(
        LIGHT_NAME_2.to_string(),
        LightGroup {
            name: LIGHT_NAME_2.to_string(),
            enabled: true,
            light_type: LightType::Simple,
            lights: vec![LightState { value: Some(LightValue::Simple(true)) }],
            hardware_index: vec![1],
        },
    );

    LightInfo { light_groups }
}

/// Populates the given HardwareLightService fake with the lights from a LightInfo.
///
/// Assumes that each light group has one light, as if the light groups were read from the
/// underlying fuchsia.hardware.light API.
async fn populate_single_test_lights(
    hardware_light_service_handle: HardwareLightServiceHandle,
    light_info: LightInfo,
) {
    for (name, group) in light_info.light_groups.into_iter() {
        hardware_light_service_handle
            .lock()
            .await
            .insert_light(
                group.hardware_index[0],
                name,
                group.light_type,
                group.lights[0].value.clone().unwrap(),
            )
            .await;
    }
}

/// Populates the given HardwareLightService fake with the lights from a LightInfo.
///
/// For each light group, adds a new light with the light's index in the LightGroup appended to it.
/// For example a light group with name RED and 3 lights would result in RED_1, RED_2, RED_3 being
/// inserted into the fake service.
async fn populate_multiple_test_lights(
    hardware_light_service_handle: HardwareLightServiceHandle,
    light_info: LightInfo,
) {
    for (name, group) in light_info.light_groups.into_iter() {
        for i in 0..group.hardware_index.len() {
            hardware_light_service_handle
                .lock()
                .await
                .insert_light(
                    group.hardware_index[i],
                    format!("{}_{}", name, i),
                    group.light_type.clone(),
                    group.lights[i].value.clone().unwrap(),
                )
                .await;
        }
    }
}

/// Creates a test environment for light.
///
/// If starting_light_info is provided, the device storage will be initialized with the given value.
/// If hardware_light_service_handle is provided, it will be used as the fake service in the service
/// registry, otherwise one will be constructed.
async fn create_test_light_env_with_service(
    starting_light_info: Option<LightInfo>,
    hardware_light_service_handle: Option<HardwareLightServiceHandle>,
) -> (LightProxy, Arc<Mutex<DeviceStorage<LightInfo>>>) {
    let service_registry = ServiceRegistry::create();
    let service_handle = match hardware_light_service_handle.clone() {
        Some(service) => service,
        None => Arc::new(Mutex::new(HardwareLightService::new())),
    };
    service_registry.lock().await.register_service(service_handle.clone());

    let storage_factory = InMemoryStorageFactory::create();
    let store = storage_factory
        .lock()
        .await
        .get_device_storage::<LightInfo>(StorageAccessContext::Test, CONTEXT_ID);

    if let Some(info) = starting_light_info {
        store.lock().await.write(&info, false).await.expect("write starting values");
        if hardware_light_service_handle.is_none() {
            // If a fake hardware light service wasn't provided for us, populate the initial lights.
            populate_single_test_lights(service_handle.clone(), info).await;
        }
    }

    let env = EnvironmentBuilder::new(storage_factory)
        .service(Box::new(ServiceRegistry::serve(service_registry)))
        .agents(&[restore_agent::blueprint::create()])
        .settings(&[SettingType::Light])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .unwrap();

    let light_service = env.connect_to_service::<LightMarker>().unwrap();

    (light_service, store)
}

async fn set_light_value(service: &LightProxy, light_group: LightGroup) {
    service
        .set_light_group_values(
            light_group.name.as_str(),
            &mut light_group.lights.into_iter().map(LightState::into),
        )
        .await
        .expect("set completed")
        .expect("set successful");
}

/// Compares a vector of light group from the settings FIDL API and the light groups from a
/// service-internal LightInfo object for equality.
fn assert_lights_eq(mut groups: Vec<fidl_fuchsia_settings::LightGroup>, info: LightInfo) {
    // Watch returns vector, internally we use a HashMap, so convert into a vector for comparison.
    let mut expected_value = info
        .light_groups
        .into_iter()
        .map(|(_, value)| fidl_fuchsia_settings::LightGroup::from(value))
        .collect::<Vec<_>>();

    // Sort by names for stability
    groups.sort_by_key(|group: &fidl_fuchsia_settings::LightGroup| group.name.clone());
    expected_value.sort_by_key(|group| group.name.clone());
    assert_eq!(groups, expected_value);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_light_restore() {
    // Populate the fake service with the initial lights that will be restored.
    let hardware_light_service_handle = Arc::new(Mutex::new(HardwareLightService::new()));
    populate_single_test_lights(hardware_light_service_handle.clone(), get_test_light_info()).await;

    let (light_service, store) =
        create_test_light_env_with_service(None, Some(hardware_light_service_handle)).await;

    let expected_light_group = get_test_light_info().light_groups.remove(LIGHT_NAME_1).unwrap();

    // Verify that the restored value is persisted.
    let mut store_lock = store.lock().await;
    let retrieved_struct = store_lock.get().await;
    assert_eq!(
        &expected_light_group.clone(),
        retrieved_struct.light_groups.get(LIGHT_NAME_1).unwrap()
    );

    // Verify that the restored value is returned on a watch call.
    let settings: fidl_fuchsia_settings::LightGroup =
        light_service.watch_light_group(LIGHT_NAME_1).await.expect("watch completed");
    assert_eq!(fidl_fuchsia_settings::LightGroup::from(expected_light_group), settings);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_light_restores_on_watch() {
    let hardware_light_service_handle = Arc::new(Mutex::new(HardwareLightService::new()));

    let (light_service, _) =
        create_test_light_env_with_service(None, Some(hardware_light_service_handle.clone())).await;

    // Don't populate the fake service with lights until after the service starts.
    let expected_light_info = get_test_light_info();
    populate_single_test_lights(hardware_light_service_handle.clone(), expected_light_info.clone())
        .await;

    // Upon a watch call, light controller will read the underlying value from the fake service.
    let settings = light_service.watch_light_groups().await.expect("watch completed");
    assert_lights_eq(settings, expected_light_info);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_light_store_and_watch() {
    let mut expected_light_info = get_test_light_info();
    let mut changed_light_group =
        expected_light_info.light_groups.get(LIGHT_NAME_1).unwrap().clone();
    changed_light_group.lights = vec![LightState { value: Some(LightValue::Brightness(128)) }];
    expected_light_info.light_groups.insert(LIGHT_NAME_1.to_string(), changed_light_group.clone());

    let (light_service, store) =
        create_test_light_env_with_service(Some(get_test_light_info()), None).await;

    // Set a light value.
    set_light_value(&light_service, changed_light_group).await;

    // Verify the value we set is persisted in DeviceStorage.
    assert_eq!(expected_light_info, store.lock().await.get().await);

    // Ensure value from Watch matches set value.
    let settings: Vec<fidl_fuchsia_settings::LightGroup> =
        light_service.watch_light_groups().await.expect("watch completed");
    assert_lights_eq(settings, expected_light_info);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_light_set_wrong_size() {
    let (light_service, _) =
        create_test_light_env_with_service(Some(get_test_light_info()), None).await;

    // Light group only has one light, attempt to set two lights.
    light_service
        .set_light_group_values(
            LIGHT_NAME_1,
            &mut vec![
                LightState { value: Some(LightValue::Brightness(128)) },
                LightState { value: Some(LightValue::Brightness(11)) },
            ]
            .into_iter()
            .map(LightState::into),
        )
        .await
        .expect("set completed")
        .expect_err("set failed");
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_light_set_none() {
    const TEST_LIGHT_NAME: &str = "multiple_lights";
    const LIGHT_1_VAL: u8 = 42;
    const LIGHT_2_START_VAL: u8 = 24;
    const LIGHT_2_CHANGED_VAL: u8 = 11;
    // For this test, create a light group with two lights to test setting one light at a time.
    let original_light_group = LightGroup {
        name: TEST_LIGHT_NAME.to_string(),
        enabled: true,
        light_type: LightType::Brightness,
        lights: vec![
            LightState { value: Some(LightValue::Brightness(LIGHT_1_VAL)) },
            LightState { value: Some(LightValue::Brightness(LIGHT_2_START_VAL)) },
        ],
        hardware_index: vec![0, 1],
    };

    // When changing the light group, specify None for the first light.
    let mut changed_light_group = original_light_group.clone();
    changed_light_group.lights = vec![
        LightState { value: None },
        LightState { value: Some(LightValue::Brightness(LIGHT_2_CHANGED_VAL)) },
    ];

    // Only the second light shoudl change.
    let mut expected_light_group = original_light_group.clone();
    expected_light_group.lights = vec![
        LightState { value: Some(LightValue::Brightness(LIGHT_1_VAL)) },
        LightState { value: Some(LightValue::Brightness(LIGHT_2_CHANGED_VAL)) },
    ];

    let mut light_groups = HashMap::new();
    light_groups.insert(TEST_LIGHT_NAME.to_string(), original_light_group);
    let starting_light_info = LightInfo { light_groups };

    let mut expected_light_info = starting_light_info.clone();
    expected_light_info
        .light_groups
        .insert(TEST_LIGHT_NAME.to_string(), expected_light_group.clone());

    let hardware_light_service_handle = Arc::new(Mutex::new(HardwareLightService::new()));

    let (light_service, store) = create_test_light_env_with_service(
        Some(starting_light_info.clone()),
        Some(hardware_light_service_handle.clone()),
    )
    .await;

    // Populate the fake service with the initial lights so the set calls aren't rejected.
    populate_multiple_test_lights(hardware_light_service_handle, starting_light_info).await;

    set_light_value(&light_service, changed_light_group).await;

    // Verify the value we set is persisted in DeviceStorage.
    assert_eq!(expected_light_info, store.lock().await.get().await);

    // Ensure value from Watch matches set value.
    let mut settings: Vec<fidl_fuchsia_settings::LightGroup> =
        light_service.watch_light_groups().await.expect("watch completed");
    settings.sort_by_key(|group: &fidl_fuchsia_settings::LightGroup| group.name.clone());

    let settings = light_service.watch_light_group(TEST_LIGHT_NAME).await.expect("watch completed");
    assert_eq!(settings, expected_light_group.into());
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_individual_light_group() {
    let test_light_info = get_test_light_info();
    let light_group_1 = test_light_info.light_groups.get(LIGHT_NAME_1).unwrap().clone();
    let mut light_group_1_updated = light_group_1.clone();
    light_group_1_updated.lights = vec![LightState { value: Some(LightValue::Brightness(128)) }];

    let light_group_2 = test_light_info.light_groups.get(LIGHT_NAME_2).unwrap().clone();
    let mut light_group_2_updated = light_group_2.clone();
    light_group_2_updated.lights = vec![LightState { value: Some(LightValue::Simple(false)) }];

    let (light_service, _) =
        create_test_light_env_with_service(Some(get_test_light_info()), None).await;

    // Ensure values from Watch matches set values.
    let settings = light_service.watch_light_group(LIGHT_NAME_1).await.expect("watch completed");
    assert_eq!(settings, light_group_1.into());
    let settings = light_service.watch_light_group(LIGHT_NAME_2).await.expect("watch completed");
    assert_eq!(settings, light_group_2.into());

    // Set updated values for the two lights.
    set_light_value(&light_service, light_group_1_updated.clone()).await;

    let settings = light_service.watch_light_group(LIGHT_NAME_1).await.expect("watch completed");
    assert_eq!(settings, light_group_1_updated.into());

    set_light_value(&light_service, light_group_2_updated.clone()).await;

    let settings = light_service.watch_light_group(LIGHT_NAME_2).await.expect("watch completed");
    assert_eq!(settings, light_group_2_updated.into());
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_watch_unknown_light_group_name() {
    let (light_service, _) =
        create_test_light_env_with_service(Some(get_test_light_info()), None).await;

    // Unknown name should be rejected.
    light_service.watch_light_group("unknown_name").await.expect_err("watch should fail");
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_set_unknown_light_group_name() {
    let (light_service, _) =
        create_test_light_env_with_service(Some(get_test_light_info()), None).await;

    // Unknown name should be rejected.
    let result = light_service
        .set_light_group_values("unknown_name", &mut vec![].into_iter())
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidName));
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_set_wrong_state_length() {
    let test_light_info = get_test_light_info();
    let (light_service, _) = create_test_light_env_with_service(Some(test_light_info), None).await;

    // Set with no light state should fail.
    let result = light_service
        .set_light_group_values(LIGHT_NAME_1, &mut vec![].into_iter())
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));

    // Set with an extra light state should fail.
    let extra_state = vec![
        fidl_fuchsia_settings::LightState { value: None },
        fidl_fuchsia_settings::LightState { value: None },
    ];
    let result = light_service
        .set_light_group_values(LIGHT_NAME_1, &mut extra_state.into_iter())
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_set_wrong_value_type() {
    const TEST_LIGHT_NAME: &str = "multiple_lights";
    const LIGHT_START_VAL: u8 = 24;
    const LIGHT_CHANGED_VAL: u8 = 11;
    let original_light_group = LightGroup {
        name: TEST_LIGHT_NAME.to_string(),
        enabled: true,
        light_type: LightType::Brightness,
        lights: vec![
            LightState { value: Some(LightValue::Brightness(LIGHT_START_VAL)) },
            LightState { value: Some(LightValue::Brightness(LIGHT_START_VAL)) },
        ],
        hardware_index: vec![0, 1],
    };
    let mut light_groups = HashMap::new();
    light_groups.insert(TEST_LIGHT_NAME.to_string(), original_light_group);
    let starting_light_info = LightInfo { light_groups };

    let hardware_light_service_handle = Arc::new(Mutex::new(HardwareLightService::new()));

    let (light_service, _) = create_test_light_env_with_service(
        Some(starting_light_info.clone()),
        Some(hardware_light_service_handle.clone()),
    )
    .await;

    // One of the light values is On instead of brightness, the set should fail.
    let result = light_service
        .set_light_group_values(
            TEST_LIGHT_NAME,
            &mut vec![
                fidl_fuchsia_settings::LightState { value: None },
                fidl_fuchsia_settings::LightState {
                    value: Some(fidl_fuchsia_settings::LightValue::On(true)),
                },
            ]
            .into_iter(),
        )
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));

    // One of the values is the right type, but the other is still wrong, the set should fail.
    let result = light_service
        .set_light_group_values(
            TEST_LIGHT_NAME,
            &mut vec![
                fidl_fuchsia_settings::LightState {
                    value: Some(fidl_fuchsia_settings::LightValue::Brightness(LIGHT_CHANGED_VAL)),
                },
                fidl_fuchsia_settings::LightState {
                    value: Some(fidl_fuchsia_settings::LightValue::On(true)),
                },
            ]
            .into_iter(),
        )
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_set_invalid_rgb_values() {
    const TEST_LIGHT_NAME: &str = "light";
    const LIGHT_START_VAL: f32 = 0.25;
    const INVALID_VAL_1: f32 = 1.1;
    const INVALID_VAL_2: f32 = -0.1;
    let original_light_group = LightGroup {
        name: TEST_LIGHT_NAME.to_string(),
        enabled: true,
        light_type: LightType::Rgb,
        lights: vec![LightState {
            value: Some(LightValue::Rgb(ColorRgb {
                red: LIGHT_START_VAL,
                green: LIGHT_START_VAL,
                blue: LIGHT_START_VAL,
            })),
        }],
        hardware_index: vec![0],
    };
    let mut light_groups = HashMap::new();
    light_groups.insert(TEST_LIGHT_NAME.to_string(), original_light_group);
    let starting_light_info = LightInfo { light_groups };

    let hardware_light_service_handle = Arc::new(Mutex::new(HardwareLightService::new()));

    let (light_service, _) = create_test_light_env_with_service(
        Some(starting_light_info.clone()),
        Some(hardware_light_service_handle.clone()),
    )
    .await;

    // One of the RGB components is too big, the set should fail.
    let result = light_service
        .set_light_group_values(
            TEST_LIGHT_NAME,
            &mut vec![fidl_fuchsia_settings::LightState {
                value: Some(fidl_fuchsia_settings::LightValue::Color(
                    fidl_fuchsia_ui_types::ColorRgb {
                        red: LIGHT_START_VAL,
                        green: LIGHT_START_VAL,
                        blue: INVALID_VAL_1,
                    },
                )),
            }]
            .into_iter(),
        )
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));

    // One of the RGB components is negative, the set should fail.
    let result = light_service
        .set_light_group_values(
            TEST_LIGHT_NAME,
            &mut vec![fidl_fuchsia_settings::LightState {
                value: Some(fidl_fuchsia_settings::LightValue::Color(
                    fidl_fuchsia_ui_types::ColorRgb {
                        red: LIGHT_START_VAL,
                        green: INVALID_VAL_2,
                        blue: LIGHT_START_VAL,
                    },
                )),
            }]
            .into_iter(),
        )
        .await
        .expect("set returns");
    assert_eq!(result, Err(LightError::InvalidValue));
}