rm-lisa 0.3.2

//! A transaction on the input state.
//!
//! A single transaction should be created, and operated on _per_ `read()`
//! call for wherever you're reading from. If you reuse a transaction, or
//! create one at a finer grained scale you _will_ notice issues when
//! processing multi character input sequences like shift-tab.

use crate::input::{
	autocomplete::AutocompleteProvider,
	history::HistoryProvider,
	stdin::{MultibyteCursorControl, state::raw::UnlockedStdinInputState},
};
use std::borrow::Cow;

/// A wrapper around a write lock, and doing batch processing of input state.
///
/// The goal of the transaction is to process a single data from a read call,
/// and produce all of the changes that happened, and events that might be
/// queued as a result of this transaction.
#[allow(clippy::struct_excessive_bools)]
pub struct InputStateTransaction<'lf> {
	/// The actual underlying write guard.
	locked: &'lf mut UnlockedStdinInputState,
	/// An append buffer that is used to track if we can fire off an append
	/// event, or a 'change' event.
	///
	/// To be more clear:
	///
	/// - If  this is `None`, and input has changed, CHANGE EVENT MUST BE
	///   FIRED.
	/// - If this is `Some`, then you can safely file an append event, or
	///   mass append event.
	append_buffer: Option<String>,
	/// If a cancel has been queued.
	cancel_is_queued: bool,
	/// If a clear screen event has been queued.
	clear_is_queued: bool,
	/// If a pause event has been queued.
	pause_is_queued: bool,
	/// If a start action has been queued.
	start_is_queued: bool,
	/// Used to track if a finish is queued.
	///
	/// - If this is `None`, then a finish is not queued.
	/// - If this is `Some`, then a finish is queued, and this is set to
	///   (`previous_autocomplete`, `input`).
	finish_queued: Option<(Option<String>, String)>,
	/// A multibyte cursor control character has occured.
	multibyte_queued: Option<MultibyteCursorControl>,
	/// Shift-Insert requires multiple bytes that all come in at once in order
	/// to detect.
	///
	/// This counter keeps how far along we are into a multibyte counter.
	multibyte_paste_counter: u8,
	/// Detect multibyte cursor control characters.
	///
	/// Those that start with `\u{1b}`, and `[` followed by more characters
	/// afterwards. This keeps track of those inputs.
	multibyte_cursor_counter: u8,
}

impl<'lf> InputStateTransaction<'lf> {
	/// Create a new transaction to star tprocessing inputs.
	#[must_use]
	pub(super) fn new(lock: &'lf mut UnlockedStdinInputState) -> Self {
		Self {
			locked: lock,
			append_buffer: Some(String::new()),
			cancel_is_queued: false,
			clear_is_queued: false,
			pause_is_queued: false,
			start_is_queued: false,
			finish_queued: None,
			multibyte_cursor_counter: 0,
			multibyte_paste_counter: 0,
			multibyte_queued: None,
		}
	}

	/// Mark that all of our processing has finished.
	///
	/// This will return an 'append' buffer (if one is present). This append
	/// buffer can be used to fire off append events, vs input change events.
	pub fn finished_processing(mut self) -> Option<String> {
		if self.locked.check_promote_history_buffer() {
			self.append_buffer = None;
		}
		self.append_buffer
	}

	/// Get the current cursor position in terms of characters.
	#[must_use]
	pub fn cursor_position(&self) -> usize {
		self.locked.cursor_position()
	}

	/// Attempt to move the cursor left by an amount.
	///
	/// Will return if the cursor actually moved in anyway.
	#[must_use]
	pub fn move_cursor_left(&mut self, amount: usize) -> bool {
		let did_move = self.locked.move_cursor_left(amount);
		if did_move {
			self.append_buffer = None;
		}
		did_move
	}

	/// Attempt to move the cursor right by an amount.
	///
	/// Will return if the cursor actually moved in anyway.
	#[must_use]
	pub fn move_cursor_right(&mut self, amount: usize) -> bool {
		let did_move = self.locked.move_cursor_right(amount);
		if did_move {
			self.append_buffer = None;
		}
		did_move
	}

	/// Get a reference to the current input buffer *WITH* autocomplete.
	#[must_use]
	pub fn current_input(&self) -> Cow<'_, str> {
		self.locked.buffer()
	}

	/// Get the last used completion index, and increment it by one.
	///
	/// Used to determine what autocomplete suggestion specifically we're using.
	#[must_use]
	pub fn get_last_completion_index(&mut self) -> Option<usize> {
		self.locked.get_last_completion_index()
	}

	/// Get the last used completion index, and decrement it by one.
	///
	/// Used to determine what autocomplete suggestion specifically we're using.
	#[must_use]
	pub fn get_previous_completion_index(&mut self) -> Option<usize> {
		self.locked.get_previous_completion_index()
	}

	/// Get the current input *WITHOUT* pending auto completes.
	#[must_use]
	pub fn uncompleted_input(&self) -> &str {
		self.locked.uncompleted_input()
	}

	/// Perform a backspace operation.
	pub fn backspace(&mut self) {
		let (was_previously_started, did_backspace) = self.locked.backspace();
		if was_previously_started && did_backspace {
			self.append_buffer = None;
		}
		if !was_previously_started && !did_backspace && self.locked.started() {
			_ = self.cancel();
		}
	}

	/// Perform a cancel operation and reset all our state.
	///
	/// Returning if we had previously started accepting inputs.
	#[must_use]
	pub fn cancel(&mut self) -> bool {
		self.cancel_is_queued = true;

		let had_started = self.locked.cancel();
		if !had_started && !self.start_is_queued {
			self.append_buffer = Some(String::new());
		}
		had_started
	}

	/// Process a user requesting that we clear the screen.
	pub fn clear(&mut self) {
		self.locked.promote_autocomplete_buffer();
		self.append_buffer = None;
		self.clear_is_queued = true;
	}

	/// Complete the current input, or mark it as 'finished'.
	///
	/// Will ignore empty completion events.
	pub fn complete(&mut self) {
		// Promote autocomplete incase inner locked is still autocompleted
		// last.
		let prev_autocomplete = self.append_buffer.take();
		self.append_buffer = Some(String::new());

		let completed = self.locked.complete();
		if !completed.is_empty() {
			_ = self.finish_queued.insert((prev_autocomplete, completed));
		}
	}

	/// Process a tab/shift-tab character, and potentially autocomplete input.
	pub fn tab_action(
		&mut self,
		autocomplete_provider: Option<&dyn AutocompleteProvider>,
		history_provider: Option<&dyn HistoryProvider>,
		do_insert_tab: bool,
		is_shift_tab: bool,
	) {
		if let Some(buff) = self.locked.history_search_buffer_mut().take() {
			self.locked.handle_new_autocomplete_suggestion(&buff);
			self.append_buffer = None;
			return;
		}

		let Some(ap) = autocomplete_provider else {
			if do_insert_tab {
				return self.new_character_action(' ', history_provider);
			}

			return;
		};

		if ap.can_autocomplete() {
			let completion_index = if is_shift_tab {
				self.get_previous_completion_index()
			} else {
				self.get_last_completion_index()
			};
			// Either a change, or a cursor change.
			self.append_buffer = None;

			let Some(ac_value) = ap.get_tab_completion(completion_index, self.uncompleted_input())
			else {
				if do_insert_tab {
					return self.new_character_action(' ', history_provider);
				}

				return;
			};

			if ac_value.is_empty() {
				if do_insert_tab {
					self.new_character_action(' ', history_provider);
				}
			} else {
				self.locked.handle_new_autocomplete_suggestion(&ac_value);
			}
		} else if do_insert_tab {
			self.new_character_action(' ', history_provider);
		}
	}

	/// Look up the previous command run in history, and set that as our new
	/// input.
	///
	/// Previous history action can be thought of as hitting the 'up arrow' once,
	/// and getitng the previous command that was run.
	pub fn previous_history_action(&mut self, history_provider: Option<&dyn HistoryProvider>) {
		let Some(hprovider) = history_provider else {
			return self.cancel_if_empty();
		};
		let next_index = self.locked.get_next_history_index();
		if let Some(history_item) = hprovider.get_previous_command(next_index) {
			let prev_buff_is_empty = self.locked.uncompleted_input().is_empty();
			let max_len = history_item.chars().count();
			if !prev_buff_is_empty && self.locked.original_uncompleted_history().is_none() {
				let to_save = self.locked.uncompleted_input().to_owned();
				self.locked.set_uncompleted_history(to_save);
			}
			self.locked.handle_new_buff_from_history(history_item);
			self.append_buffer = None;

			if !self.locked.started() {
				self.locked.mark_started();
				self.start_is_queued = true;
			}
			if prev_buff_is_empty {
				self.locked.set_cursor_position(max_len);
			}
		} else {
			self.cancel_if_empty();
		}
	}

	/// Look up the next command run in history, and set that as our new input.
	///
	/// Get the next item in history in the future (e.g. hitting the down arrow).
	pub fn next_history_action(&mut self, history_provider: Option<&dyn HistoryProvider>) {
		let Some(hprovider) = history_provider else {
			return self.cancel_if_empty();
		};
		let Some(next_index) = self.locked.get_previous_history_index() else {
			if let Some(value) = self.locked.take_original_uncompleted_history() {
				self.locked.handle_new_buff_from_history(value);
				self.append_buffer = None;
				return;
			}

			return self.cancel_if_empty();
		};

		if let Some(history_item) = hprovider.get_previous_command(next_index) {
			self.locked.handle_new_buff_from_history(history_item);
			self.append_buffer = None;

			if !self.locked.started() {
				self.locked.mark_started();
				self.start_is_queued = true;
			}
		} else if let Some(value) = self.locked.take_original_uncompleted_history() {
			self.locked.handle_new_buff_from_history(value);
			self.append_buffer = None;
		} else {
			self.cancel_if_empty();
		}
	}

	/// Start a history search action.
	pub fn start_history_search_action(&mut self, history: Option<&dyn HistoryProvider>) {
		self.locked.start_history_search_suggestions(history);
		self.append_buffer = None;
	}

	/// Process a user typing in a new character.
	pub fn new_character_action(
		&mut self,
		new_character: char,
		history: Option<&dyn HistoryProvider>,
	) {
		self.check_multibyte_paste(new_character);
		let did_multibyte = self.check_multibyte_u1b(new_character);

		let did_change;
		(self.start_is_queued, did_change) =
			self.locked.process(new_character, did_multibyte, history);
		if did_change {
			self.append_buffer = None;
		} else if let Some(buf) = self.append_buffer.as_mut() {
			buf.push(new_character);
		}
	}

	/// Process a user typing a lot of characters at once (e.g. from a clipboard).
	pub fn new_string_action(&mut self, data: &str, history: Option<&dyn HistoryProvider>) {
		let did_change;
		(self.start_is_queued, did_change) = self.locked.process_all(data, history);
		if did_change {
			self.append_buffer = None;
		} else if let Some(buf) = self.append_buffer.as_mut() {
			*buf += data;
		}
	}

	/// Process a Ctrl-U action which cuts all the content from the cursor to
	/// the beginning, and saves it.
	pub fn uwk_cursor_to_begin(&mut self) {
		if self.locked.uwk_cursor_to_begin() {
			self.append_buffer = None;
		}
	}

	/// Process a Ctrl-K action which cuts all the content from the cursor to
	/// the end, and saves it.
	pub fn uwk_cursor_to_end(&mut self) {
		if self.locked.uwk_cursor_to_end() {
			self.append_buffer = None;
		}
	}

	/// Process a Ctrl-W action which cuts out a current word from your cursor.
	pub fn uwk_cursor_word(&mut self) {
		if self.locked.uwk_cursor_word() {
			self.append_buffer = None;
		}
	}

	/// Paste in content form the UWK buffer.
	pub fn paste_uwk(&mut self) {
		if self.locked.paste_uwk() {
			self.append_buffer = None;
		}
	}

	/// Swap the last two characters on standard in, including whitespace.
	pub fn swap_last_two_characters(&mut self) {
		if self.locked.swap_last_two_characters() {
			self.append_buffer = None;
		}
	}

	/// Process a user requesting that we pause STDOUT/STDERR.
	pub fn pause_output(&mut self) {
		self.locked.promote_autocomplete_buffer();
		self.pause_is_queued = true;
	}

	/// Check if a cancel was triggered, and reset it's state.
	#[must_use]
	pub const fn did_trigger_cancel(&mut self) -> bool {
		let queued = self.cancel_is_queued;
		self.cancel_is_queued = false;
		queued
	}

	/// If someone has requested clearing a screening.
	#[must_use]
	pub const fn did_trigger_clear(&mut self) -> bool {
		let queued = self.clear_is_queued;
		self.clear_is_queued = false;
		queued
	}

	#[must_use]
	pub const fn did_trigger_pause(&mut self) -> bool {
		let queued = self.pause_is_queued;
		self.pause_is_queued = false;
		queued
	}

	/// Check if a multibyte-paste should be triggered.
	#[must_use]
	pub fn did_trigger_multibyte_paste(&mut self) -> bool {
		if self.multibyte_paste_counter == 9 {
			self.multibyte_paste_counter = 0;
			// We hit a multibyte paste! YAY!
			self.locked.pop_n(9);
			if let Some(ledger) = self.append_buffer.as_mut() {
				for _ in 0..9 {
					_ = ledger.pop();
				}
			}
			return true;
		}

		false
	}

	/// Check if a multibyte cursor control event occured.
	///
	/// This has to take an autocomplete provider because shift-tab
	/// can trigger autocomplete cycling.
	pub fn did_trigger_multibyte_cursor(
		&mut self,
		autocomplete_provider: Option<&dyn AutocompleteProvider>,
		history_provider: Option<&dyn HistoryProvider>,
		ansi_supported: bool,
	) -> Option<(bool, usize, Option<String>, usize)> {
		let event = self.multibyte_queued.take()?;

		match event {
			MultibyteCursorControl::ShiftTab => {
				self.locked.pop_n(3);
				if let Some(ledger) = self.append_buffer.as_mut() {
					for _ in 0..3 {
						_ = ledger.pop();
					}
				}

				self.tab_action(autocomplete_provider, history_provider, false, true);
			}
			MultibyteCursorControl::UpArrow => {
				self.locked.pop_n_promoting_autocomplete_buffer(3);
				if let Some(ledger) = self.append_buffer.as_mut() {
					for _ in 0..3 {
						_ = ledger.pop();
					}
				}

				self.previous_history_action(history_provider);
			}
			MultibyteCursorControl::DownArrow => {
				self.locked.pop_n_promoting_autocomplete_buffer(3);
				if let Some(ledger) = self.append_buffer.as_mut() {
					for _ in 0..3 {
						_ = ledger.pop();
					}
				}

				self.next_history_action(history_provider);
			}
			MultibyteCursorControl::LeftArrow | MultibyteCursorControl::RightArrow => {
				self.locked.pop_n_promoting_autocomplete_buffer(3);
				if let Some(ledger) = self.append_buffer.as_mut() {
					for _ in 0..3 {
						_ = ledger.pop();
					}
				}

				if ansi_supported {
					let org_append = self.append_buffer.take();
					let org_position = self.cursor_position();
					let move_left = matches!(event, MultibyteCursorControl::LeftArrow);
					let move_result = if move_left {
						self.locked.move_cursor_left(1)
					} else {
						self.locked.move_cursor_right(1)
					};
					return if move_result {
						self.append_buffer = Some(String::with_capacity(0));
						Some((move_left, 1, org_append, org_position))
					} else {
						None
					};
				}
			}
			MultibyteCursorControl::ShiftLeftArrow | MultibyteCursorControl::ShiftRightArrow => {
				self.locked.pop_n_promoting_autocomplete_buffer(6);
				if let Some(ledger) = self.append_buffer.as_mut() {
					for _ in 0..6 {
						_ = ledger.pop();
					}
				}

				if ansi_supported {
					let move_left = matches!(event, MultibyteCursorControl::ShiftLeftArrow);
					let cursor_move_amount =
						if let Some((start, end)) = self.locked.get_word_bounds_at_cursor() {
							if move_left {
								self.locked.cursor_position() - start
							} else {
								end - self.locked.cursor_position()
							}
						} else if move_left {
							self.locked.cursor_position()
						} else {
							self.locked.uncompleted_input().chars().count()
						};
					let move_result = if move_left {
						self.locked.move_cursor_left(cursor_move_amount)
					} else {
						self.locked.move_cursor_right(cursor_move_amount)
					};

					return if move_result {
						let org_append = self.append_buffer.take();
						self.append_buffer = Some(String::with_capacity(0));
						let org_position = self.cursor_position();
						Some((move_left, cursor_move_amount, org_append, org_position))
					} else {
						None
					};
				}
			}
		}

		self.multibyte_cursor_counter = 0;
		None
	}

	/// Check if a start was triggered, and reset it's state.
	#[must_use]
	pub fn did_trigger_start(&mut self) -> bool {
		let queued = self.start_is_queued;
		self.start_is_queued = false;
		queued
	}

	/// Check if a finish was triggered, and reset it's state.
	#[must_use]
	pub fn did_trigger_finish(&mut self) -> Option<(Option<String>, String)> {
		self.finish_queued.take()
	}

	/// Perform a cancellation if the buffer is currently empty.
	fn cancel_if_empty(&mut self) {
		if self.locked.buffer().is_empty() && self.locked.started() {
			_ = self.cancel();
		}
	}

	/// Check if a new character is part of a multibyte paste counter.
	fn check_multibyte_paste(&mut self, new_character: char) {
		if new_character == '\\' && self.multibyte_paste_counter == 0 {
			self.multibyte_paste_counter += 1;
		} else if self.multibyte_paste_counter > 0 {
			let do_reset = match self.multibyte_paste_counter {
				1 => new_character != '\\',
				2 => new_character != 'u',
				3 => new_character != '{',
				4 => new_character != '1',
				5 => new_character != 'b',
				6 => new_character != '}',
				7 => new_character != '[',
				8 => new_character != 'Z',
				_ => true,
			};

			if do_reset {
				self.multibyte_paste_counter = 0;
			} else {
				self.multibyte_paste_counter += 1;
			}
		}
	}

	/// Check for multibyte cursor counters returning if it was part of a
	/// multibyte character.
	fn check_multibyte_u1b(&mut self, new_character: char) -> bool {
		if new_character == '\u{1b}' && self.multibyte_cursor_counter == 0 {
			self.multibyte_cursor_counter += 1;
			true
		} else if self.multibyte_cursor_counter > 0 {
			let mut did_multibyte = true;
			let do_reset = match self.multibyte_cursor_counter {
				1 => {
					let should_reset = new_character != '[';
					if should_reset {
						did_multibyte = false;
					}
					should_reset
				}
				2 => match new_character {
					'A' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::UpArrow);
						true
					}
					'B' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::DownArrow);
						true
					}
					'C' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::RightArrow);
						true
					}
					'D' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::LeftArrow);
						true
					}
					'Z' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::ShiftTab);
						true
					}
					'1' => false,
					_ => {
						did_multibyte = false;
						true
					}
				},
				3 => {
					if new_character != ';' {
						did_multibyte = false;
					}
					false
				}
				4 => {
					if new_character != '2' {
						did_multibyte = false;
					}
					false
				}
				5 => match new_character {
					'C' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::ShiftRightArrow);
						true
					}
					'D' => {
						_ = self
							.multibyte_queued
							.insert(MultibyteCursorControl::ShiftLeftArrow);
						true
					}
					_ => {
						did_multibyte = false;
						true
					}
				},
				_ => {
					did_multibyte = false;
					true
				}
			};

			if do_reset {
				self.multibyte_cursor_counter = 0;
			} else {
				self.multibyte_cursor_counter += 1;
			}
			did_multibyte
		} else {
			false
		}
	}
}