// Copyright 2021 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::Error,
    fidl::prelude::*,
    fidl_fuchsia_accessibility::{MagnificationHandlerMarker, MagnifierMarker},
    fidl_fuchsia_accessibility_scene as a11y_view,
    fidl_fuchsia_input_injection::InputDeviceRegistryRequestStream,
    fidl_fuchsia_session_scene::{
        ManagerRequest as SceneManagerRequest, ManagerRequestStream as SceneManagerRequestStream,
    },
    fidl_fuchsia_ui_accessibility_view::{
        RegistryRequest as A11yViewRegistryRequest,
        RegistryRequestStream as A11yViewRegistryRequestStream,
    },
    fidl_fuchsia_ui_app as ui_app, fidl_fuchsia_ui_composition as fland,
    fidl_fuchsia_ui_scenic::ScenicMarker,
    fidl_fuchsia_ui_views as ui_views, fuchsia_async as fasync,
    fuchsia_component::{client::connect_to_protocol, server::ServiceFs},
    fuchsia_inspect as inspect,
    fuchsia_syslog::{fx_log_err, fx_log_info, fx_log_warn},
    fuchsia_zircon as zx,
    futures::lock::Mutex,
    futures::{StreamExt, TryStreamExt},
    scene_management::{self, SceneManager},
    std::rc::Rc,
    std::sync::Arc,
};

mod input_device_registry_server;
mod input_pipeline;

enum ExposedServices {
    AccessibilityViewRegistry(A11yViewRegistryRequestStream),
    SceneManager(SceneManagerRequestStream),
    InputDeviceRegistry(InputDeviceRegistryRequestStream),
}

#[fuchsia::main(logging_tags = [ "scene_manager" ])]
async fn main() -> Result<(), Error> {
    let mut fs = ServiceFs::new_local();

    inspect_runtime::serve(inspect::component::inspector(), &mut fs)?;

    fs.dir("svc").add_fidl_service(ExposedServices::AccessibilityViewRegistry);
    fs.dir("svc").add_fidl_service(ExposedServices::SceneManager);
    fs.dir("svc").add_fidl_service(ExposedServices::InputDeviceRegistry);
    fs.take_and_serve_directory_handle()?;

    let (input_device_registry_server, input_device_registry_request_stream_receiver) =
        input_device_registry_server::make_server_and_receiver();

    // This call should normally never fail. The ICU data loader must be kept alive to ensure
    // Unicode data is kept in memory.
    let icu_data_loader = icu_data::Loader::new().unwrap();

    let scenic = connect_to_protocol::<ScenicMarker>()?;

    let use_flatland = scenic.uses_flatland().await.expect("Failed to get flatland info.");
    let display_ownership =
        scenic.get_display_ownership_event().await.expect("Failed to get display ownership.");
    fx_log_info!("Instantiating SceneManager, use_flatland: {:?}", use_flatland);

    let scene_manager: Arc<Mutex<Box<dyn SceneManager>>> = if use_flatland {
        // TODO(fxbug.dev/86379): Support for insertion of accessibility view.  Pass ViewRefInstalled
        // to the SceneManager, the same way we do for the Gfx branch.
        let display = connect_to_protocol::<fland::FlatlandDisplayMarker>()?;
        let root_flatland = connect_to_protocol::<fland::FlatlandMarker>()?;
        let pointerinjector_flatland = connect_to_protocol::<fland::FlatlandMarker>()?;
        let a11y_flatland = connect_to_protocol::<fland::FlatlandMarker>()?;
        let cursor_view_provider = connect_to_protocol::<ui_app::ViewProviderMarker>()?;
        let a11y_view_provider = connect_to_protocol::<a11y_view::ProviderMarker>()?;
        Arc::new(Mutex::new(Box::new(
            scene_management::FlatlandSceneManager::new(
                scenic,
                display,
                pointerinjector_flatland,
                root_flatland,
                a11y_flatland,
                cursor_view_provider,
                a11y_view_provider,
            )
            .await?,
        )))
    } else {
        let view_ref_installed = connect_to_protocol::<ui_views::ViewRefInstalledMarker>()?;
        let gfx_scene_manager: Arc<Mutex<Box<dyn SceneManager>>> = Arc::new(Mutex::new(Box::new(
            scene_management::GfxSceneManager::new(scenic, view_ref_installed, None, None).await?,
        )));
        if let Err(e) = register_gfx_as_magnifier(Arc::clone(&gfx_scene_manager)) {
            fx_log_warn!("failed to register as the magnification handler: {:?}", e);
        }
        gfx_scene_manager
    };

    // Create a node under root to hang all input pipeline inspect data off of.
    let inspect_node =
        Rc::new(inspect::component::inspector().root().create_child("input_pipeline"));

    // Start input pipeline.
    if let Ok(input_pipeline) = input_pipeline::handle_input(
        use_flatland,
        scene_manager.clone(),
        input_device_registry_request_stream_receiver,
        icu_data_loader,
        &inspect_node.clone(),
        display_ownership,
    )
    .await
    {
        fasync::Task::local(input_pipeline.handle_input_events()).detach();
    }

    while let Some(service_request) = fs.next().await {
        match service_request {
            ExposedServices::AccessibilityViewRegistry(request_stream) => {
                fasync::Task::local(handle_accessibility_view_registry_request_stream(
                    request_stream,
                    Arc::clone(&scene_manager),
                ))
                .detach()
            }
            ExposedServices::SceneManager(request_stream) => {
                fasync::Task::local(handle_scene_manager_request_stream(
                    request_stream,
                    Arc::clone(&scene_manager),
                ))
                .detach();
            }
            ExposedServices::InputDeviceRegistry(request_stream) => {
                match &input_device_registry_server.handle_request(request_stream).await {
                    Ok(()) => (),
                    Err(e) => {
                        // If `handle_request()` returns `Err`, then the `unbounded_send()` call
                        // from `handle_request()` failed with either:
                        // * `TrySendError::SendErrorKind::Full`, or
                        // * `TrySendError::SendErrorKind::Disconnected`.
                        //
                        // These are unexpected, because:
                        // * `Full` can't happen, because `InputDeviceRegistryServer`
                        //   uses an `UnboundedSender`.
                        // * `Disconnected` is highly unlikely, because the corresponding
                        //   `UnboundedReceiver` lives in `main::input_fut`, and `input_fut`'s
                        //   lifetime is nearly as long as `input_device_registry_server`'s.
                        //
                        // Nonetheless, InputDeviceRegistry isn't critical to production use.
                        // So we just log the error and move on.
                        fx_log_warn!(
                            "failed to forward InputDeviceRegistryRequestStream: {:?}; \
                                must restart to enable input injection",
                            e
                        )
                    }
                }
            }
        }
    }

    fx_log_info!("Finished service handler loop; exiting main.");
    Ok(())
}

pub async fn handle_scene_manager_request_stream(
    mut request_stream: SceneManagerRequestStream,
    scene_manager: Arc<Mutex<Box<dyn scene_management::SceneManager>>>,
) {
    while let Ok(Some(request)) = request_stream.try_next().await {
        match request {
            SceneManagerRequest::SetRootView { view_provider, responder } => {
                if let Ok(proxy) = view_provider.into_proxy() {
                    let mut scene_manager = scene_manager.lock().await;
                    match scene_manager.set_root_view(proxy).await {
                        Ok(mut view_ref) => match responder.send(&mut view_ref) {
                            Ok(_) => {}
                            Err(e) => {
                                fx_log_err!("Error responding to SetRootView(): {}", e);
                            }
                        },
                        Err(e) => {
                            // Log an error and close the connection.  This can be a consequence of
                            // the child View not connecting to the scene graph (hence we don't
                            // receive the ViewRef to return), or perhaps an internal bug which
                            // requires further investigation.
                            fx_log_err!("Failed to obtain ViewRef from set_root_view(): {}", e);
                        }
                    }
                }
            }
        };
    }
}

pub async fn handle_accessibility_view_registry_request_stream(
    mut request_stream: A11yViewRegistryRequestStream,
    scene_manager: Arc<Mutex<Box<dyn scene_management::SceneManager>>>,
) {
    while let Ok(Some(request)) = request_stream.try_next().await {
        match request {
            A11yViewRegistryRequest::CreateAccessibilityViewHolder {
                a11y_view_ref: _,
                a11y_view_token,
                responder,
                ..
            } => {
                let mut scene_manager = scene_manager.lock().await;
                let r = scene_manager.insert_a11y_view(a11y_view_token);

                let _ = match r {
                    Ok(mut result) => {
                        let _ = responder.send(&mut result);
                    }
                    Err(e) => {
                        fx_log_warn!("Closing A11yViewRegistry connection due to error {:?}", e);
                        responder.control_handle().shutdown_with_epitaph(zx::Status::PEER_CLOSED);
                    }
                };
            }
            A11yViewRegistryRequest::CreateAccessibilityViewport {
                viewport_creation_token: _,
                responder,
                ..
            } => {
                fx_log_err!("A11yViewRegistry.CreateAccessibilityViewport not implemented!");
                responder.control_handle().shutdown_with_epitaph(zx::Status::PEER_CLOSED);
            }
        };
    }
}

fn register_gfx_as_magnifier(
    scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
) -> Result<(), anyhow::Error> {
    let (magnification_handler_client, magnification_handler_server) =
        fidl::endpoints::create_request_stream::<MagnificationHandlerMarker>()?;
    scene_management::GfxSceneManager::handle_magnification_handler_request_stream(
        magnification_handler_server,
        scene_manager,
    );
    let magnifier_proxy = connect_to_protocol::<MagnifierMarker>()?;
    magnifier_proxy.register_handler(magnification_handler_client)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use anyhow::format_err;
    use fidl::endpoints::create_endpoints;
    use fidl_fuchsia_session_scene::{
        ManagerMarker as SceneManagerMarker, ManagerProxy as SceneManagerProxy,
    };
    use fidl_fuchsia_ui_accessibility_view::{RegistryMarker, RegistryProxy};
    use fidl_fuchsia_ui_app::{ViewProviderMarker, ViewProviderRequest};
    use fidl_fuchsia_ui_scenic as ui_scenic;
    use fidl_fuchsia_ui_views as ui_views;
    use fidl_fuchsia_ui_views::ViewToken;
    use fuchsia_async as fasync;
    use fuchsia_component_test::{
        Capability, ChildOptions, RealmBuilder, RealmInstance, Ref, Route,
    };
    use fuchsia_scenic as scenic;
    use futures::TryStreamExt;

    const SCENIC_URL: &str = "#meta/scenic.cm";

    const MOCK_COBALT_URL: &str = "#meta/mock_cobalt.cm";

    const SCENE_MANAGER_URL: &str = "#meta/scene_manager.cm";

    const FAKE_HDCP_URL: &str = "#meta/hdcp.cm";

    async fn setup_realm() -> Result<RealmInstance, anyhow::Error> {
        let builder = RealmBuilder::new().await?;

        let mock_cobalt =
            builder.add_child("mock_cobalt", MOCK_COBALT_URL, ChildOptions::new().eager()).await?;

        let hdcp = builder.add_child("hdcp", FAKE_HDCP_URL, ChildOptions::new().eager()).await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.sysmem.Allocator"))
                    .capability(Capability::protocol_by_name("fuchsia.tracing.provider.Registry"))
                    .from(Ref::parent())
                    .to(&hdcp),
            )
            .await?;

        let scenic = builder
            .add_child("scenic", SCENIC_URL, ChildOptions::new().eager())
            .await
            .expect("Failed to start scenic");
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.hardware.display.Provider"))
                    .from(&hdcp)
                    .to(&scenic),
            )
            .await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.scheduler.ProfileProvider"))
                    .capability(Capability::protocol_by_name("fuchsia.sysmem.Allocator"))
                    .capability(Capability::protocol_by_name("fuchsia.tracing.provider.Registry"))
                    .capability(Capability::protocol_by_name("fuchsia.ui.input.ImeService"))
                    .capability(Capability::protocol_by_name("fuchsia.vulkan.loader.Loader"))
                    .from(Ref::parent())
                    .to(&scenic),
            )
            .await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.cobalt.LoggerFactory"))
                    .from(&mock_cobalt)
                    .to(&scenic),
            )
            .await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.ui.views.ViewRefFocused"))
                    .from(&scenic)
                    .to(Ref::parent()),
            )
            .await?;

        let scene_manager = builder
            .add_child("scene_manager", SCENE_MANAGER_URL, ChildOptions::new().eager())
            .await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name(
                        "fuchsia.ui.accessibility.view.Registry",
                    ))
                    .capability(Capability::protocol_by_name("fuchsia.session.scene.Manager"))
                    .from(&scene_manager)
                    .to(Ref::parent()),
            )
            .await?;
        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.ui.app.ViewProvider"))
                    .from(Ref::parent())
                    .to(&scene_manager),
            )
            .await?;

        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.ui.views.ViewRefInstalled"))
                    .capability(Capability::protocol_by_name("fuchsia.ui.scenic.Scenic"))
                    .capability(Capability::protocol_by_name("fuchsia.ui.scenic.Session"))
                    .capability(Capability::protocol_by_name("fuchsia.ui.composition.Flatland"))
                    .capability(Capability::protocol_by_name(
                        "fuchsia.ui.composition.FlatlandDisplay",
                    ))
                    .from(&scenic)
                    .to(Ref::parent())
                    .to(&scene_manager),
            )
            .await?;

        builder
            .add_route(
                Route::new()
                    .capability(Capability::protocol_by_name("fuchsia.logger.LogSink"))
                    .from(Ref::parent())
                    .to(&hdcp)
                    .to(&mock_cobalt)
                    .to(&scene_manager)
                    .to(&scenic),
            )
            .await?;

        let instance = builder.build().await.expect("Failed to build instance");
        Ok(instance)
    }

    async fn present_session_changes(session: &scenic::SessionPtr) {
        let _ = session
            .lock()
            // Passing 0 for requested_presentation_time tells scenic that that it should process
            // enqueued operation as soon as possible.
            // Passing 0 for requested_prediction_span guarantees that scenic will provide at least
            // one future time.
            .present2(0, 0)
            .await
            .expect("Failed to present");
    }

    async fn view_is_focused(
        view_ref_focused_proxy: &ui_views::ViewRefFocusedProxy,
    ) -> Result<bool, anyhow::Error> {
        view_ref_focused_proxy
            .watch()
            .await
            .map_err(|err| format_err!("ViewRefFocused fidl error for client view: {:?}", err))
            .map(|focused_state| focused_state.focused.unwrap_or(false))
    }

    async fn insert_a11y_view(
        session: scenic::SessionPtr,
        accessibility_view_registry_proxy: &RegistryProxy,
    ) -> Result<(scenic::View, scenic::ViewHolder, ui_views::ViewRef), anyhow::Error> {
        // Create a11y ViewRef and ViewToken pairs.
        let mut a11y_view_token_pair = scenic::ViewTokenPair::new()?;
        let a11y_viewref_pair = scenic::ViewRefPair::new()?;
        let mut viewref_dup_for_registry =
            fuchsia_scenic::duplicate_view_ref(&a11y_viewref_pair.view_ref)?;
        let viewref_dup_to_return =
            fuchsia_scenic::duplicate_view_ref(&a11y_viewref_pair.view_ref)?;
        // Create a11y view and try inserting into scene.
        let a11y_view = scenic::View::new3(
            session.clone(),
            a11y_view_token_pair.view_token,
            a11y_viewref_pair.control_ref,
            a11y_viewref_pair.view_ref,
            Some(String::from("a11y view")),
        );

        present_session_changes(&session).await;

        let proxy_view_holder_token = accessibility_view_registry_proxy
            .create_accessibility_view_holder(
                &mut viewref_dup_for_registry,
                &mut a11y_view_token_pair.view_holder_token,
            )
            .await
            .unwrap();

        // Attach proxy view holder to the scene. This step is necessary to ensure that the client
        // view is attached to the scene.
        let proxy_view_holder = scenic::ViewHolder::new(
            session.clone(),
            proxy_view_holder_token,
            Some(String::from("proxy view holder")),
        );
        a11y_view.add_child(&proxy_view_holder);
        present_session_changes(&session).await;

        Ok((a11y_view, proxy_view_holder, viewref_dup_to_return))
    }

    async fn set_root_view(
        client_session: scenic::SessionPtr,
        scene_manager: SceneManagerProxy,
    ) -> Result<(scenic::View, ui_views::ViewRef), anyhow::Error> {
        // Create ViewProvider endpoints. The scene manager uses this service to create the root
        // view.
        let (view_provider_client, view_provider_server) = create_endpoints::<ViewProviderMarker>()
            .expect("Failed to create local ViewProvider proxy and stream");

        let client_view_ref = scene_manager.set_root_view(view_provider_client).await.unwrap();

        // Create a mock ViewProvider.
        let mut view_provider_stream = view_provider_server.into_stream()?;
        let client_view = match view_provider_stream.try_next().await.unwrap() {
            Some(ViewProviderRequest::CreateViewWithViewRef {
                token,
                view_ref_control,
                view_ref,
                ..
            }) => {
                let view_token = ViewToken { value: token };
                Ok(scenic::View::new3(
                    client_session.clone(),
                    view_token,
                    view_ref_control,
                    view_ref,
                    Some(String::from("root view")),
                ))
            }

            _ => Err("Unexpected method call"),
        }
        .expect("CreateViewWithViewRef was not called");

        present_session_changes(&client_session).await;

        Ok((client_view, client_view_ref))
    }

    #[allow(unused_variables)]
    #[fasync::run_singlethreaded(test)]
    async fn test_attach_a11y_view() -> Result<(), anyhow::Error> {
        // Setup realm instance.
        let realm_instance = setup_realm().await.expect("Failed to setup realm");

        // Connect to services.
        let accessibility_view_registry_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<RegistryMarker>()?;

        let view_ref_installed_proxy = realm_instance
            .root
            .connect_to_protocol_at_exposed_dir::<ui_views::ViewRefInstalledMarker>()?;

        let scenic_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<ui_scenic::ScenicMarker>()?;

        // Instantiate scenic session in which to create a11y view.
        let (session_proxy, session_request_stream) = fidl::endpoints::create_proxy()?;
        scenic_proxy.create_session2(session_request_stream, None, None)?;
        let session = scenic::Session::new(session_proxy);

        // Create a11y view. Proxy view holder is not required for this test case, and can be dropped.
        let (a11y_view, _, mut a11y_view_ref) =
            insert_a11y_view(session, &accessibility_view_registry_proxy).await.unwrap();

        // Listen for a11y view ref installed event.
        let watch_result = view_ref_installed_proxy
            .watch(&mut a11y_view_ref)
            .await
            .expect("ViewRefInstalled fidl error for a11y view")
            .expect("ViewRefInstalledError for a11y view");

        Ok(())
    }

    #[allow(unused_variables)]
    #[fasync::run_singlethreaded(test)]
    async fn test_set_root_view_before_a11y_view() -> Result<(), anyhow::Error> {
        // Setup realm instance.
        let realm_instance = setup_realm().await.expect("Failed to setup realm");

        // Connect to services.
        let accessibility_view_registry_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<RegistryMarker>()?;

        let view_ref_installed_proxy = realm_instance
            .root
            .connect_to_protocol_at_exposed_dir::<ui_views::ViewRefInstalledMarker>()?;

        let scenic_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<ui_scenic::ScenicMarker>()?;

        let scene_manager =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<SceneManagerMarker>().unwrap();

        // Instantiate scenic session in which to create a11y view.
        let (session_proxy, session_request_stream) = fidl::endpoints::create_proxy()?;
        scenic_proxy.create_session2(session_request_stream, None, None)?;
        let session = scenic::Session::new(session_proxy);

        // Insert a11y view. The a11y view ref is not required for this test case, and can be
        // dropped.
        let (a11y_view, proxy_view_holder, _) =
            insert_a11y_view(session, &accessibility_view_registry_proxy).await.unwrap();

        // Create session in which to create root view.
        let (client_session_proxy, client_session_request_stream) =
            fidl::endpoints::create_proxy()?;
        scenic_proxy.create_session2(client_session_request_stream, None, None)?;
        let client_session = scenic::Session::new(client_session_proxy);

        // Set root view.
        let (client_view, mut client_view_ref) =
            set_root_view(client_session, scene_manager).await.unwrap();

        // Verify that the client view was attached to the scene.
        let watch_result = view_ref_installed_proxy
            .watch(&mut client_view_ref)
            .await
            .expect("ViewRefInstalled fidl error for client view")
            .expect("ViewRefInstalledError for client view");

        Ok(())
    }

    #[allow(unused_variables)]
    #[fasync::run_singlethreaded(test)]
    async fn test_set_root_view_after_a11y_view() -> Result<(), anyhow::Error> {
        // Setup realm instance.
        let realm_instance = setup_realm().await.expect("Failed to setup realm");

        // Connect to services.
        let accessibility_view_registry_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<RegistryMarker>()?;

        let view_ref_installed_proxy = realm_instance
            .root
            .connect_to_protocol_at_exposed_dir::<ui_views::ViewRefInstalledMarker>()?;

        let scenic_proxy =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<ui_scenic::ScenicMarker>()?;

        let scene_manager =
            realm_instance.root.connect_to_protocol_at_exposed_dir::<SceneManagerMarker>().unwrap();

        // Create session in which to create root view.
        // The |view_ref_focused| endpoint is required to verify that the client view is refocused
        // after the a11y view is inserted.
        let (client_session_proxy, client_session_request_stream) =
            fidl::endpoints::create_proxy()?;
        let (view_ref_focused_proxy, view_ref_focused_request_stream) =
            fidl::endpoints::create_proxy()?;
        let mut session_endpoints = ui_scenic::SessionEndpoints::EMPTY;
        session_endpoints.session = Some(client_session_request_stream);
        session_endpoints.view_ref_focused = Some(view_ref_focused_request_stream);
        scenic_proxy.create_session_t(session_endpoints).await?;
        let client_session = scenic::Session::new(client_session_proxy);

        // Create ViewProvider endpoints. The scene manager uses this service to create the root
        // view.
        let (view_provider_client, view_provider_server) = create_endpoints::<ViewProviderMarker>()
            .expect("Failed to create local ViewProvider proxy and stream");

        // Set root view. Client view ref is not required for this test case, and can be dropped.
        let (client_view, _) = set_root_view(client_session, scene_manager).await.unwrap();

        // Instantiate scenic session in which to create a11y view.
        let (session_proxy, session_request_stream) = fidl::endpoints::create_proxy()?;
        scenic_proxy.create_session2(session_request_stream, None, None)?;
        let session = scenic::Session::new(session_proxy);

        // Insert a11y view. The a11y view ref is not required for this test case, and can be
        // dropped.
        let (a11y_view, proxy_view_holder, _) =
            insert_a11y_view(session, &accessibility_view_registry_proxy).await.unwrap();

        // Verify that the client view was focused.
        let client_view_focused = view_is_focused(&view_ref_focused_proxy).await.unwrap();
        if !client_view_focused {
            panic!("Client view ref not focused after a11y view inserted");
        }

        Ok(())
    }
}