/*
 * This file is part of espanso.
 *
 * Copyright (C) 2019-2021 Federico Terzi
 *
 * espanso is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * espanso is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with espanso.  If not, see <https://www.gnu.org/licenses/>.
 */

use anyhow::Result;
use indoc::formatdoc;
use std::sync::Arc;
use std::{collections::HashSet, path::Path};
use thiserror::Error;

pub(crate) mod default;
mod parse;
mod path;
mod resolve;
pub(crate) mod store;
mod util;

#[cfg(test)]
use mockall::{automock, predicate::*};

use crate::error::NonFatalErrorSet;
#[cfg_attr(test, automock)]
pub trait Config: Send + Sync {
  fn id(&self) -> i32;
  fn label(&self) -> &str;
  fn match_paths(&self) -> &[String];

  // The mechanism used to perform the injection. Espanso can either
  // inject text by simulating keypresses (Inject backend) or
  // by using the clipboard (Clipboard backend). Both of them have pros
  // and cons, so the "Auto" backend is used by default to automatically
  // choose the most appropriate one based on the situation.
  // If for whatever reason the Auto backend is not appropriate, you
  // can change this option to override it.
  fn backend(&self) -> Backend;

  // If false, espanso will be disabled for the current configuration.
  // This option can be used to selectively disable espanso when
  // using a specific application (by creating an app-specific config).
  fn enable(&self) -> bool;

  // Number of chars after which a match is injected with the clipboard
  // backend instead of the default one. This is done for efficiency
  // reasons, as injecting a long match through separate events becomes
  // slow for long strings.
  fn clipboard_threshold(&self) -> usize;

  // Delay (in ms) that espanso should wait to trigger the paste shortcut
  // after copying the content in the clipboard. This is needed because
  // if we trigger a "paste" shortcut before the content is actually
  // copied in the clipboard, the operation will fail.
  fn pre_paste_delay(&self) -> usize;

  // Number of milliseconds between keystrokes when simulating the Paste shortcut
  // For example: CTRL + (wait 5ms) + V + (wait 5ms) + release V + (wait 5ms) + release CTRL
  // This is needed as sometimes (for example on macOS), without a delay some keystrokes
  // were not registered correctly
  fn paste_shortcut_event_delay(&self) -> usize;

  // Customize the keyboard shortcut used to paste an expansion.
  // This should follow this format: CTRL+SHIFT+V
  fn paste_shortcut(&self) -> Option<String>;

  // NOTE: This is only relevant on Linux under X11 environments
  // Switch to a slower (but sometimes more supported) way of injecting
  // key events based on XTestFakeKeyEvent instead of XSendEvent.
  // From my experiements, disabling fast inject becomes particularly slow when
  // using the Gnome desktop environment.
  fn disable_x11_fast_inject(&self) -> bool;

  // Defines the key that disables/enables espanso when double pressed
  fn toggle_key(&self) -> Option<ToggleKey>;

  // If true, instructs the daemon process to restart the worker (and refresh
  // the configuration) after a configuration file change is detected on disk.
  fn auto_restart(&self) -> bool;

  // If true, espanso will attempt to preserve the previous clipboard content
  // after an expansion has taken place (when using the Clipboard backend).
  fn preserve_clipboard(&self) -> bool;

  // The number of milliseconds to wait before restoring the previous clipboard
  // content after an expansion. This is needed as without this delay, sometimes
  // the target application detects the previous clipboard content instead of
  // the expansion content.
  fn restore_clipboard_delay(&self) -> usize;

  // Number of milliseconds between text injection events. Increase if the target
  // application is missing some characters.
  fn inject_delay(&self) -> Option<usize>;

  // Number of milliseconds between key injection events. Increase if the target
  // application is missing some key events.
  fn key_delay(&self) -> Option<usize>;

  // Extra delay to apply when injecting modifiers under the EVDEV backend.
  // This is useful on Wayland if espanso is injecting seemingly random
  // cased letters, for example "Hi theRE1" instead of "Hi there!".
  // Increase if necessary, decrease to speed up the injection.
  fn evdev_modifier_delay(&self) -> Option<usize>;

  // Chars that when pressed mark the start and end of a word.
  // Examples of this are . or ,
  fn word_separators(&self) -> Vec<String>;

  // Maximum number of backspace presses espanso keeps track of.
  // For example, this is needed to correctly expand even if typos
  // are typed.
  fn backspace_limit(&self) -> usize;

  // If false, avoid applying the built-in patches to the current config.
  fn apply_patch(&self) -> bool;

  // On Wayland, overrides the auto-detected keyboard configuration (RMLVO)
  // which is used both for the detection and injection process.
  fn keyboard_layout(&self) -> Option<RMLVOConfig>;

  // Trigger used to show the Search UI
  fn search_trigger(&self) -> Option<String>;

  // Hotkey used to trigger the Search UI
  fn search_shortcut(&self) -> Option<String>;

  // When enabled, espanso automatically "reverts" an expansion if the user
  // presses the Backspace key afterwards.
  fn undo_backspace(&self) -> bool;

  // If false, disable all notifications
  fn show_notifications(&self) -> bool;

  // If false, avoid showing the espanso icon on the system's tray bar
  // Note: currently not working on Linux
  fn show_icon(&self) -> bool;

  // If false, avoid showing the SecureInput notification on macOS
  fn secure_input_notification(&self) -> bool;

  // If true, use the `xclip` command to implement the clipboard instead of
  // the built-in native module on X11.
  fn x11_use_xclip_backend(&self) -> bool;

  // If true, filter out keyboard events without an explicit HID device source on Windows.
  // This is needed to filter out the software-generated events, including
  // those from espanso, but might need to be disabled when using some software-level keyboards.
  // Disabling this option might conflict with the undo feature.
  fn win32_exclude_orphan_events(&self) -> bool;

  // The maximum interval (in milliseconds) for which a keyboard layout
  // can be cached. If switching often between different layouts, you
  // could lower this amount to avoid the "lost detection" effect described
  // in this issue: https://github.com/federico-terzi/espanso/issues/745
  fn win32_keyboard_layout_cache_interval(&self) -> i64;

  fn is_match<'a>(&self, app: &AppProperties<'a>) -> bool;

  fn pretty_dump(&self) -> String {
    formatdoc! {"
        [espanso config: {:?}]

        backend: {:?}
        enable: {:?}
        paste_shortcut: {:?}
        inject_delay: {:?}
        key_delay: {:?}
        apply_patch: {:?}
        word_separators: {:?}
        
        preserve_clipboard: {:?}
        clipboard_threshold: {:?}
        disable_x11_fast_inject: {}
        pre_paste_delay: {}
        paste_shortcut_event_delay: {}
        toggle_key: {:?}
        auto_restart: {:?}
        restore_clipboard_delay: {:?} 
        backspace_limit: {}
        search_trigger: {:?}
        search_shortcut: {:?}
        keyboard_layout: {:?}

        show_icon: {:?}
        show_notifications: {:?}
        secure_input_notification: {:?}

        x11_use_xclip_backend: {:?}
        win32_exclude_orphan_events: {:?}
        win32_keyboard_layout_cache_interval: {:?}

        match_paths: {:#?}
      ", 
      self.label(),
      self.backend(),
      self.enable(),
      self.paste_shortcut(),
      self.inject_delay(),
      self.key_delay(),
      self.apply_patch(),
      self.word_separators(),

      self.preserve_clipboard(),
      self.clipboard_threshold(),
      self.disable_x11_fast_inject(),
      self.pre_paste_delay(),
      self.paste_shortcut_event_delay(),
      self.toggle_key(),
      self.auto_restart(),
      self.restore_clipboard_delay(),
      self.backspace_limit(),
      self.search_trigger(),
      self.search_shortcut(),
      self.keyboard_layout(),

      self.show_icon(),
      self.show_notifications(),
      self.secure_input_notification(),

      self.x11_use_xclip_backend(),
      self.win32_exclude_orphan_events(),
      self.win32_keyboard_layout_cache_interval(),

      self.match_paths(),
    }
  }
}

pub trait ConfigStore: Send {
  fn default(&self) -> Arc<dyn Config>;
  fn active<'a>(&'a self, app: &AppProperties) -> Arc<dyn Config>;
  fn configs(&self) -> Vec<Arc<dyn Config>>;

  fn get_all_match_paths(&self) -> HashSet<String>;
}

pub struct AppProperties<'a> {
  pub title: Option<&'a str>,
  pub class: Option<&'a str>,
  pub exec: Option<&'a str>,
}

#[derive(Debug, Copy, Clone)]
pub enum Backend {
  Inject,
  Clipboard,
  Auto,
}

#[derive(Debug, Copy, Clone)]
pub enum ToggleKey {
  Ctrl,
  Meta,
  Alt,
  Shift,
  RightCtrl,
  RightAlt,
  RightShift,
  RightMeta,
  LeftCtrl,
  LeftAlt,
  LeftShift,
  LeftMeta,
}

#[derive(Debug, Clone, Default)]
pub struct RMLVOConfig {
  pub rules: Option<String>,
  pub model: Option<String>,
  pub layout: Option<String>,
  pub variant: Option<String>,
  pub options: Option<String>,
}

impl std::fmt::Display for RMLVOConfig {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    write!(
      f,
      "[R={}, M={}, L={}, V={}, O={}]",
      self.rules.as_deref().unwrap_or_default(),
      self.model.as_deref().unwrap_or_default(),
      self.layout.as_deref().unwrap_or_default(),
      self.variant.as_deref().unwrap_or_default(),
      self.options.as_deref().unwrap_or_default(),
    )
  }
}

pub fn load_store(config_dir: &Path) -> Result<(impl ConfigStore, Vec<NonFatalErrorSet>)> {
  store::DefaultConfigStore::load(config_dir)
}

#[derive(Error, Debug)]
pub enum ConfigStoreError {
  #[error("invalid config directory")]
  InvalidConfigDir(),

  #[error("missing default.yml config")]
  MissingDefault(),

  #[error("io error")]
  IOError(#[from] std::io::Error),
}