// 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::input_device,
    crate::input_handler::UnhandledInputHandler,
    crate::keyboard_binding,
    anyhow::Error,
    async_trait::async_trait,
    fidl_fuchsia_ui_input3::{self as fidl_ui_input3, LockState, Modifiers},
    fuchsia_component::client::connect_to_protocol,
    fuchsia_syslog::{fx_log_debug, fx_log_err},
    fuchsia_zircon as zx,
    keymaps::{self, LockStateChecker, ModifierChecker},
    std::rc::Rc,
};

#[derive(Debug)]
pub struct FrozenLockState {
    lock_state: LockState,
}

impl From<LockState> for FrozenLockState {
    fn from(lock_state: LockState) -> Self {
        FrozenLockState { lock_state }
    }
}

impl LockStateChecker for FrozenLockState {
    fn test(&self, value: LockState) -> bool {
        self.lock_state.contains(value)
    }
}

/// Modifier state plus a tester method.
#[derive(Debug)]
pub struct FrozenModifierState {
    state: Modifiers,
}

impl From<fidl_fuchsia_ui_input3::Modifiers> for FrozenModifierState {
    fn from(state: Modifiers) -> Self {
        FrozenModifierState { state }
    }
}

impl ModifierChecker for FrozenModifierState {
    fn test(&self, value: Modifiers) -> bool {
        self.state.contains(value)
    }
}

/// [`ImeHandler`] is responsible for dispatching key events to the IME service, thus making sure
/// that key events are delivered to application runtimes (e.g., web, Flutter).
///
/// > NOTE: The [ImeHandler] requires [ModifierHandler] to be installed upstream to apply the keymaps correctly.
pub struct ImeHandler {
    /// The FIDL proxy (client-side stub) to the service for key event injection.
    key_event_injector: fidl_ui_input3::KeyEventInjectorProxy,
}

#[async_trait(?Send)]
impl UnhandledInputHandler for ImeHandler {
    async fn handle_unhandled_input_event(
        self: Rc<Self>,
        unhandled_input_event: input_device::UnhandledInputEvent,
    ) -> Vec<input_device::InputEvent> {
        match unhandled_input_event {
            input_device::UnhandledInputEvent {
                device_event: input_device::InputDeviceEvent::Keyboard(ref keyboard_device_event),
                device_descriptor: input_device::InputDeviceDescriptor::Keyboard(_),
                event_time,
                trace_id: _,
            } => {
                let key_event = create_key_event(&keyboard_device_event, event_time);
                self.dispatch_key(key_event).await;
                // Consume the input event.
                vec![input_device::InputEvent::from(unhandled_input_event).into_handled()]
            }
            _ => vec![input_device::InputEvent::from(unhandled_input_event)],
        }
    }
}

#[allow(dead_code)]
impl ImeHandler {
    /// Creates a new [`ImeHandler`] by connecting out to the key event injector.
    pub async fn new() -> Result<Rc<Self>, Error> {
        let key_event_injector = connect_to_protocol::<fidl_ui_input3::KeyEventInjectorMarker>()?;

        Self::new_handler(key_event_injector).await
    }

    /// Creates a new [`ImeHandler`].
    ///
    /// # Parameters
    /// `key_event_injector`: A proxy (FIDL client-side stub) to the key event
    /// injector FIDL service.
    async fn new_handler(
        key_event_injector: fidl_ui_input3::KeyEventInjectorProxy,
    ) -> Result<Rc<Self>, Error> {
        let handler = ImeHandler { key_event_injector };

        Ok(Rc::new(handler))
    }

    /// Dispatches key events to IME and returns KeyboardEvents for unhandled events.
    ///
    /// # Parameters
    /// `key_events`: The key events to dispatch.
    /// `event_time`: The time in nanoseconds when the events were first recorded.
    async fn dispatch_key(self: &Rc<Self>, key_event: fidl_ui_input3::KeyEvent) {
        assert!(
            key_event.timestamp.is_some(),
            "dispatch_key: got a key_event without a timestamp: {:?}",
            &key_event
        );
        match self.key_event_injector.inject(key_event).await {
            Err(err) => fx_log_err!("Failed to dispatch key to IME: {:?}", err),
            _ => {}
        };
    }
}

/// Returns a KeyEvent with the given parameters.
///
/// # Parameters
/// * `event`: The keyboard event to process.
/// * `event_time`: The time in nanoseconds when the event was first recorded.
fn create_key_event(
    event: &keyboard_binding::KeyboardEvent,
    event_time: zx::Time,
) -> fidl_ui_input3::KeyEvent {
    let modifier_state: FrozenModifierState =
        event.get_modifiers().unwrap_or(Modifiers::from_bits_allow_unknown(0)).into();
    let lock_state: FrozenLockState =
        event.get_lock_state().unwrap_or(LockState::from_bits_allow_unknown(0)).into();
    fx_log_debug!(
        "ImeHandler::create_key_event: key:{:?}, modifier_state: {:?}, lock_state: {:?}, event_type: {:?}",
        event.get_key(),
        modifier_state,
        lock_state,
        event.get_event_type(),
    );
    // Don't override the key meaning if already set, e.g. by prior stage.
    let key_meaning = event.get_key_meaning().or(keymaps::US_QWERTY.apply(
        event.get_key(),
        &modifier_state,
        &lock_state,
    ));

    // Don't insert a spurious Some(0).
    let repeat_sequence = match event.get_repeat_sequence() {
        0 => None,
        s => Some(s),
    };

    fidl_ui_input3::KeyEvent {
        timestamp: Some(event_time.into_nanos()),
        type_: event.get_event_type().into(),
        key: event.get_key().into(),
        modifiers: event.get_modifiers(),
        lock_state: event.get_lock_state(),
        key_meaning,
        repeat_sequence,
        ..fidl_ui_input3::KeyEvent::EMPTY
    }
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        crate::keyboard_binding::{self, KeyboardEvent},
        crate::testing_utilities,
        assert_matches::assert_matches,
        fidl_fuchsia_input as fidl_input, fidl_fuchsia_ui_input3 as fidl_ui_input3,
        fuchsia_async as fasync, fuchsia_zircon as zx,
        futures::StreamExt,
        std::convert::TryFrom as _,
        test_case::test_case,
    };

    fn handle_events(
        ime_handler: Rc<ImeHandler>,
        input_events: Vec<input_device::UnhandledInputEvent>,
    ) {
        fasync::Task::local(async move {
            for input_event in input_events {
                assert_matches!(
                    ime_handler.clone().handle_unhandled_input_event(input_event).await.as_slice(),
                    [input_device::InputEvent { handled: input_device::Handled::Yes, .. }]
                );
            }
        })
        .detach();
    }

    async fn assert_ime_receives_events(
        expected_events: Vec<fidl_ui_input3::KeyEvent>,
        mut request_stream: fidl_ui_input3::KeyEventInjectorRequestStream,
    ) {
        let mut expected_events_iter = expected_events.iter().peekable();
        while let Some(Ok(fidl_ui_input3::KeyEventInjectorRequest::Inject {
            key_event,
            responder,
            ..
        })) = request_stream.next().await
        {
            pretty_assertions::assert_eq!(&key_event, expected_events_iter.next().unwrap());

            // All the expected events have been received, so make sure no more events
            // are present before returning.
            if expected_events_iter.peek().is_none() {
                responder
                    .send(fidl_ui_input3::KeyEventStatus::Handled)
                    .expect("error responding to DispatchKey");
                return;
            }
            responder
                .send(fidl_ui_input3::KeyEventStatus::Handled)
                .expect("error responding to DispatchKey");
        }

        assert!(false);
    }

    fn connect_to_key_event_injector(
    ) -> (fidl_ui_input3::KeyEventInjectorProxy, fidl_ui_input3::KeyEventInjectorRequestStream)
    {
        fidl::endpoints::create_proxy_and_stream::<fidl_ui_input3::KeyEventInjectorMarker>()
            .expect("Failed to create proxy and stream for fuchsia.ui.input3.KeyEventInjector")
    }

    fn create_unhandled_keyboard_event(
        key: fidl_fuchsia_input::Key,
        event_type: fidl_fuchsia_ui_input3::KeyEventType,
        modifiers: Option<fidl_ui_input3::Modifiers>,
        event_time: zx::Time,
        device_descriptor: &input_device::InputDeviceDescriptor,
        keymap: Option<String>,
    ) -> input_device::UnhandledInputEvent {
        create_unhandled_keyboard_event_with_key_meaning(
            key,
            event_type,
            modifiers,
            event_time,
            device_descriptor,
            keymap,
            /* key_meaning */ None,
        )
    }

    fn create_unhandled_keyboard_event_with_key_meaning(
        key: fidl_fuchsia_input::Key,
        event_type: fidl_fuchsia_ui_input3::KeyEventType,
        modifiers: Option<fidl_ui_input3::Modifiers>,
        event_time: zx::Time,
        device_descriptor: &input_device::InputDeviceDescriptor,
        keymap: Option<String>,
        key_meaning: Option<fidl_fuchsia_ui_input3::KeyMeaning>,
    ) -> input_device::UnhandledInputEvent {
        input_device::UnhandledInputEvent::try_from(
            testing_utilities::create_keyboard_event_with_key_meaning(
                key,
                event_type,
                modifiers,
                event_time,
                device_descriptor,
                keymap,
                key_meaning,
            ),
        )
        .unwrap()
    }

    fn create_unhandled_input_event(
        keyboard_event: keyboard_binding::KeyboardEvent,
        device_descriptor: &input_device::InputDeviceDescriptor,
        event_time: zx::Time,
    ) -> input_device::UnhandledInputEvent {
        input_device::UnhandledInputEvent {
            device_event: input_device::InputDeviceEvent::Keyboard(keyboard_event),
            device_descriptor: device_descriptor.clone(),
            event_time,
            trace_id: None,
        }
    }

    /// Tests that a pressed key event is dispatched.
    ///
    /// > NOTE: The `device_descriptor` used in this test case and elsewhere
    /// *must* be of type `KeyboardDeviceDescriptor` as this is required by the
    /// pattern matching in `ImeHandler`.
    #[fasync::run_singlethreaded(test)]
    async fn pressed_key() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor { keys: vec![fidl_input::Key::A] },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![create_unhandled_keyboard_event(
            fidl_input::Key::A,
            fidl_fuchsia_ui_input3::KeyEventType::Pressed,
            None,
            event_time_u64,
            &device_descriptor,
            /* keymap= */ None,
        )];

        let expected_events = vec![fidl_ui_input3::KeyEvent {
            timestamp: Some(event_time_i64),
            type_: Some(fidl_ui_input3::KeyEventType::Pressed),
            key: Some(fidl_input::Key::A),
            // A key "A" without shift is a lowercase 'a'.
            key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
            ..fidl_ui_input3::KeyEvent::EMPTY
        }];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    /// Tests that a released key event is dispatched.
    #[fasync::run_singlethreaded(test)]
    async fn released_key() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor { keys: vec![fidl_input::Key::A] },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![create_unhandled_keyboard_event(
            fidl_input::Key::A,
            fidl_fuchsia_ui_input3::KeyEventType::Released,
            None,
            event_time_u64,
            &device_descriptor,
            /* keymap= */ None,
        )];

        let expected_events = vec![fidl_ui_input3::KeyEvent {
            timestamp: Some(event_time_i64),
            type_: Some(fidl_ui_input3::KeyEventType::Released),
            key: Some(fidl_input::Key::A),
            key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
            ..fidl_ui_input3::KeyEvent::EMPTY
        }];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    /// Tests that both pressed and released keys are dispatched appropriately.
    #[fasync::run_singlethreaded(test)]
    async fn pressed_and_released_key() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![fidl_input::Key::A, fidl_input::Key::B],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![
            create_unhandled_keyboard_event(
                fidl_input::Key::A,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::A,
                fidl_fuchsia_ui_input3::KeyEventType::Released,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::B,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event_with_key_meaning(
                fidl_input::Key::C,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
                Some(fidl_fuchsia_ui_input3::KeyMeaning::Codepoint(42)),
            ),
        ];

        let expected_events = vec![
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::A),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Released),
                key: Some(fidl_input::Key::A),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::B),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(98)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::C),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(42)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
        ];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    // Tests that modifier keys are dispatched appropriately.
    //
    // This test depends on the incoming event having correct modifier and lock
    // state.  Typically you'd do this by installing a ModifierHandler upstream
    // of this pipeline stage.
    #[fasync::run_singlethreaded(test)]
    async fn repeated_modifier_key() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![fidl_input::Key::A, fidl_input::Key::CapsLock],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![
            create_unhandled_input_event(
                KeyboardEvent::new(
                    fidl_input::Key::CapsLock,
                    fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                )
                .into_with_modifiers(Some(fidl_ui_input3::Modifiers::CAPS_LOCK))
                .into_with_lock_state(Some(fidl_ui_input3::LockState::CAPS_LOCK)),
                &device_descriptor,
                event_time_u64,
            ),
            create_unhandled_input_event(
                KeyboardEvent::new(
                    fidl_input::Key::A,
                    fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                )
                .into_with_modifiers(Some(fidl_ui_input3::Modifiers::CAPS_LOCK))
                .into_with_lock_state(Some(fidl_ui_input3::LockState::CAPS_LOCK)),
                &device_descriptor,
                event_time_u64,
            ),
            create_unhandled_input_event(
                KeyboardEvent::new(
                    fidl_input::Key::CapsLock,
                    fidl_fuchsia_ui_input3::KeyEventType::Released,
                )
                .into_with_lock_state(Some(fidl_ui_input3::LockState::CAPS_LOCK)),
                &device_descriptor,
                event_time_u64,
            ),
        ];

        let expected_events = vec![
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::CapsLock),
                modifiers: Some(fidl_ui_input3::Modifiers::CAPS_LOCK),
                lock_state: Some(fidl_ui_input3::LockState::CAPS_LOCK),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(0)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::A),
                modifiers: Some(fidl_ui_input3::Modifiers::CAPS_LOCK),
                lock_state: Some(fidl_ui_input3::LockState::CAPS_LOCK),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(65)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Released),
                key: Some(fidl_input::Key::CapsLock),
                lock_state: Some(fidl_ui_input3::LockState::CAPS_LOCK),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(0)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
        ];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    #[fasync::run_singlethreaded(test)]
    async fn nonprintable_key_meanings_set_correctly() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![
                    fidl_input::Key::Enter,
                    fidl_input::Key::Tab,
                    fidl_input::Key::Backspace,
                ],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![
            create_unhandled_keyboard_event(
                fidl_input::Key::Enter,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::Tab,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::Backspace,
                fidl_fuchsia_ui_input3::KeyEventType::Released,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
        ];

        let expected_events = vec![
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::Enter),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::NonPrintableKey(
                    fidl_ui_input3::NonPrintableKey::Enter,
                )),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::Tab),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::NonPrintableKey(
                    fidl_ui_input3::NonPrintableKey::Tab,
                )),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                // Test that things also work when a key is released.
                type_: Some(fidl_ui_input3::KeyEventType::Released),
                key: Some(fidl_input::Key::Backspace),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::NonPrintableKey(
                    fidl_ui_input3::NonPrintableKey::Backspace,
                )),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
        ];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    #[fasync::run_singlethreaded(test)]
    async fn tab() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![
                    fidl_input::Key::Enter,
                    fidl_input::Key::Tab,
                    fidl_input::Key::Backspace,
                ],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![create_unhandled_keyboard_event(
            fidl_input::Key::Tab,
            fidl_fuchsia_ui_input3::KeyEventType::Pressed,
            None,
            event_time_u64,
            &device_descriptor,
            /* keymap= */ None,
        )];

        let expected_events = vec![fidl_ui_input3::KeyEvent {
            timestamp: Some(event_time_i64),
            type_: Some(fidl_ui_input3::KeyEventType::Pressed),
            key: Some(fidl_input::Key::Tab),
            key_meaning: Some(fidl_ui_input3::KeyMeaning::NonPrintableKey(
                fidl_ui_input3::NonPrintableKey::Tab,
            )),
            ..fidl_ui_input3::KeyEvent::EMPTY
        }];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    #[fasync::run_singlethreaded(test)]
    async fn shift_shift_a() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![fidl_input::Key::LeftCtrl, fidl_input::Key::Tab],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![
            create_unhandled_keyboard_event(
                fidl_input::Key::LeftShift,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                Some(Modifiers::LEFT_SHIFT | Modifiers::SHIFT),
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::RightShift,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                Some(Modifiers::LEFT_SHIFT | Modifiers::RIGHT_SHIFT | Modifiers::SHIFT),
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::A,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                Some(Modifiers::LEFT_SHIFT | Modifiers::RIGHT_SHIFT | Modifiers::SHIFT),
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
        ];

        let expected_events = vec![
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::LeftShift),
                modifiers: Some(Modifiers::LEFT_SHIFT | Modifiers::SHIFT),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(0)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::RightShift),
                modifiers: Some(Modifiers::RIGHT_SHIFT | Modifiers::LEFT_SHIFT | Modifiers::SHIFT),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(0)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::A),
                modifiers: Some(Modifiers::RIGHT_SHIFT | Modifiers::LEFT_SHIFT | Modifiers::SHIFT),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(65)), // "A"
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
        ];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    #[fasync::run_singlethreaded(test)]
    async fn ctrl_tab() {
        let (proxy, request_stream) = connect_to_key_event_injector();
        let ime_handler =
            ImeHandler::new_handler(proxy).await.expect("Failed to create ImeHandler.");

        let device_descriptor = input_device::InputDeviceDescriptor::Keyboard(
            keyboard_binding::KeyboardDeviceDescriptor {
                keys: vec![fidl_input::Key::LeftCtrl, fidl_input::Key::Tab],
            },
        );
        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
        let input_events = vec![
            create_unhandled_keyboard_event(
                fidl_input::Key::LeftCtrl,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
            create_unhandled_keyboard_event(
                fidl_input::Key::Tab,
                fidl_fuchsia_ui_input3::KeyEventType::Pressed,
                None,
                event_time_u64,
                &device_descriptor,
                /* keymap= */ None,
            ),
        ];

        let expected_events = vec![
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::LeftCtrl),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(0)),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
            fidl_ui_input3::KeyEvent {
                timestamp: Some(event_time_i64),
                type_: Some(fidl_ui_input3::KeyEventType::Pressed),
                key: Some(fidl_input::Key::Tab),
                key_meaning: Some(fidl_ui_input3::KeyMeaning::NonPrintableKey(
                    fidl_ui_input3::NonPrintableKey::Tab,
                )),
                ..fidl_ui_input3::KeyEvent::EMPTY
            },
        ];

        handle_events(ime_handler, input_events);
        assert_ime_receives_events(expected_events, request_stream).await;
    }

    #[test_case(
        keyboard_binding::KeyboardEvent::new(
            fidl_input::Key::A,
            fidl_ui_input3::KeyEventType::Pressed),
        zx::Time::from_nanos(42) => fidl_ui_input3::KeyEvent{
            timestamp: Some(42),
            type_: Some(fidl_ui_input3::KeyEventType::Pressed),
            key: Some(fidl_input::Key::A),
            key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
            ..fidl_ui_input3::KeyEvent::EMPTY}; "basic value copy")]
    #[test_case(
        keyboard_binding::KeyboardEvent::new(
            fidl_input::Key::A,
            fidl_ui_input3::KeyEventType::Pressed)
            .into_with_repeat_sequence(13),
        zx::Time::from_nanos(42) => fidl_ui_input3::KeyEvent{
            timestamp: Some(42),
            type_: Some(fidl_ui_input3::KeyEventType::Pressed),
            key: Some(fidl_input::Key::A),
            key_meaning: Some(fidl_ui_input3::KeyMeaning::Codepoint(97)),
            repeat_sequence: Some(13),
            ..fidl_ui_input3::KeyEvent::EMPTY}; "repeat_sequence is honored")]
    fn test_create_key_event(
        event: keyboard_binding::KeyboardEvent,
        event_time: zx::Time,
    ) -> fidl_ui_input3::KeyEvent {
        super::create_key_event(&event, event_time)
    }
}