// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! This module contains an implementation of `ImeState`, the internal state object of `LegacyIme`.

use {
    anyhow::{Context as _, Error},
    fidl_fuchsia_input as input, fidl_fuchsia_ui_input as uii,
    std::{
        char,
        collections::{HashMap, HashSet},
        ops::Range,
    },
};

use super::position;
use crate::{index_convert as idx, keyboard::events::KeyEvent, text_manager::TextManager};

/// The internal state of the IME, held within `LegacyIme` inside `Arc<Mutex<ImeState>>`, so it can
/// be accessed from multiple message handler async tasks. Methods that aren't message handlers
/// don't usually need to access `Arc<Mutex<LegacyIme>>` itself, and so can be put in here instead
/// of on `LegacyIme` itself.
pub struct ImeState {
    pub text_state: uii::TextInputState,

    /// A handle to call methods on the text field.
    pub client: Box<dyn uii::InputMethodEditorClientProxyInterface>,

    pub keyboard_type: uii::KeyboardType,

    pub action: uii::InputMethodAction,
    pub text_manager: TextManager,

    /// Currently pressed keys.
    pub keys_pressed: HashSet<input::Key>,

    /// A number used to serve the TextField interface. It increments any time any
    /// party makes a change to the state.
    pub revision: u64,

    /// A TextPoint is a u64 token that represents a character position in the new
    /// TextField interface. Each token is a unique ID; this represents the ID we
    /// will assign to the next TextPoint that is created. It increments every time
    /// a TextPoint is created. This is never reset, even when TextPoints are
    /// invalidated; TextPoints have globally unique IDs.
    pub next_text_point_id: u64,

    /// A TextPoint is a u64 token that represents a character position in the new
    /// TextField interface. This maps TextPoint IDs to byte indexes inside
    /// `text_state.text`. When a new revision is created, all preexisting TextPoints
    /// are deleted, which means we clear this out.
    pub text_points: HashMap<u64, usize>,
}

/// Looks up a TextPoint's byte index from a list of points. Usually this list will be
/// `ImeState.text_points`, but in the middle of a transaction, we clone it to a temporary list
/// so that we can mutate them without mutating the original list. That way, if the transaction
/// gets rejected, the original list is left intact.
impl ImeState {
    /// Forwards a keyboard event to any listening clients without changing the actual state of the
    /// IME at all.
    pub(crate) fn forward_event(&mut self, key_event: KeyEvent) -> Result<(), Error> {
        let keyboard_event: uii::KeyboardEvent =
            key_event.try_into().context("error converting key event to keyboard event")?;

        let state = idx::text_state_byte_to_codeunit(self.text_state.clone());
        self.client
            .did_update_state(&state, Some(&uii::InputEvent::Keyboard(keyboard_event)))
            .with_context(|| {
                format!(
                    "ImeState::forward_event: error sending state update to ImeClient: {:?}",
                    &keyboard_event
                )
            })?;
        Ok(())
    }

    /// Any time the state is updated, this method is called, which allows ImeState to inform any
    /// listening clients (either TextField or InputMethodEditorClientProxy) that state has updated.
    /// If InputMethodEditorClient caused the update with SetState, set call_did_update_state so that
    /// we don't send its own edit back to it. Otherwise, set to true.
    pub fn increment_revision(&mut self, call_did_update_state: bool) {
        self.revision += 1;
        self.text_points = HashMap::new();

        if call_did_update_state {
            let state = idx::text_state_byte_to_codeunit(self.text_state.clone());
            self.client.did_update_state(&state, None).unwrap_or_else(|e| {
                tracing::warn!(
                    "ImeState::increment_revision: error sending state update to ImeClient: {:?}",
                    e
                )
            });
        }
    }

    // gets start and len, and sets base/extent to start of string if don't exist
    pub fn selection(&mut self) -> Range<usize> {
        let s = &mut self.text_state.selection;
        s.base = s.base.max(0).min(self.text_state.text.len() as i64);
        s.extent = s.extent.max(0).min(self.text_state.text.len() as i64);
        let start = s.base.min(s.extent) as usize;
        let end = s.base.max(s.extent) as usize;
        start..end
    }

    pub fn type_keycode(&mut self, code_point: u32) {
        self.text_state.revision += 1;

        let replacement = match char::from_u32(code_point) {
            Some(v) => v.to_string(),
            None => return,
        };

        let selection = self.selection();
        self.text_state.text.replace_range(selection.clone(), &replacement);

        self.text_state.selection.base = selection.start as i64 + replacement.len() as i64;
        self.text_state.selection.extent = self.text_state.selection.base;
    }

    pub fn delete_backward(&mut self) {
        self.text_state.revision += 1;

        // set base and extent to 0 if either is -1, to ensure there is a selection/cursor
        self.selection();

        if self.text_state.selection.base == self.text_state.selection.extent {
            // Select one grapheme or character to the left, so that it can be uniformly handled by
            // the selection-deletion code below.
            self.text_state.selection.base = position::adjacent_cursor_position(
                &self.text_state.text,
                self.text_state.selection.base as usize,
                position::HorizontalMotion::GraphemeLeft(
                    position::GraphemeTraversal::CombiningCharacters,
                ),
            ) as i64;
        }
        self.delete_selection();
    }

    pub fn delete_forward(&mut self) {
        self.text_state.revision += 1;

        // Ensure valid selection/cursor.
        self.selection();

        if self.text_state.selection.base == self.text_state.selection.extent {
            // Select one grapheme to the right so that it can be handled by the selection-deletion
            // code below.
            self.text_state.selection.extent = position::adjacent_cursor_position(
                &self.text_state.text,
                self.text_state.selection.base as usize,
                position::HorizontalMotion::GraphemeRight,
            ) as i64;
        }
        self.delete_selection();
    }

    /// Deletes the selected text if the selection isn't empty.
    /// Does not increment revision number. Should only be called from methods that do.
    fn delete_selection(&mut self) {
        // Delete the current selection.
        let selection = self.selection();
        if selection.start != selection.end {
            self.text_state.text.replace_range(selection.clone(), "");
            self.text_state.selection.extent = selection.start as i64;
            self.text_state.selection.base = self.text_state.selection.extent;
        }
    }

    pub fn cursor_horizontal_move(&mut self, modifiers: u32, go_right: bool) {
        self.text_state.revision += 1;

        let shift_pressed = modifiers & uii::MODIFIER_SHIFT != 0;
        let ctrl_pressed = modifiers & uii::MODIFIER_CONTROL != 0;
        let selection = self.selection();
        let text_is_selected = selection.start != selection.end;
        let mut new_position = self.text_state.selection.extent;

        if !shift_pressed && text_is_selected {
            // canceling selection, new position based on start/end of selection
            if go_right {
                new_position = selection.end as i64;
            } else {
                new_position = selection.start as i64;
            }
            if ctrl_pressed {
                new_position = position::adjacent_cursor_position(
                    &self.text_state.text,
                    new_position as usize,
                    if go_right {
                        position::HorizontalMotion::WordRight
                    } else {
                        position::HorizontalMotion::WordLeft
                    },
                ) as i64;
            }
        } else {
            // new position based previous value of extent
            new_position = position::adjacent_cursor_position(
                &self.text_state.text,
                new_position as usize,
                match (go_right, ctrl_pressed) {
                    (true, true) => position::HorizontalMotion::WordRight,
                    (false, true) => position::HorizontalMotion::WordLeft,
                    (true, false) => position::HorizontalMotion::GraphemeRight,
                    (false, false) => position::HorizontalMotion::GraphemeLeft(
                        position::GraphemeTraversal::WholeGrapheme,
                    ),
                },
            ) as i64;
        }

        self.text_state.selection.extent = new_position;
        if !shift_pressed {
            self.text_state.selection.base = new_position;
        }
        self.text_state.selection.affinity = uii::TextAffinity::Downstream;
    }
}