pub use rfd::*;

#[cfg(not(target_os = "linux"))]
macro_rules! run_dialog {
  ($e:expr, $h: ident) => {{
    std::thread::spawn(move || {
      let response = $e;
      $h(response);
    });
  }};
}

#[cfg(target_os = "linux")]
macro_rules! run_dialog {
  ($e:expr, $h: ident) => {{
    std::thread::spawn(move || {
      let context = glib::MainContext::default();
      context.invoke(move || {
        let response = $e;
        $h(response);
      });
    });
  }};
}

#[cfg(not(target_os = "linux"))]
macro_rules! run_file_dialog {
  ($e:expr, $h: ident) => {{
    std::thread::spawn(move || {
      let response = crate::async_runtime::block_on($e);
      $h(response);
    });
  }};
}

#[cfg(target_os = "linux")]
macro_rules! run_file_dialog {
  ($e:expr, $h: ident) => {{
    std::thread::spawn(move || {
      let context = glib::MainContext::default();
      context.invoke_with_priority(glib::PRIORITY_HIGH, move || {
        let response = $e;
        $h(response);
      });
    });
  }};
}

/// # 运行dialog
/// ```rust
/// use e_utils::dialog::*;
/// use std::sync::mpsc::channel;
/// fn main() {
///   let (sx, rx) = channel();
///   dialog(
///     "测试",
///     "通知",
///     MessageButtons::Ok,
///     MessageLevel::Error,
///     move |_x| {
///       sx.send(true).unwrap();
///     },
///   );
///   rx.recv().unwrap();
/// }
/// ```
#[allow(unused_variables)]
pub fn dialog<F: FnOnce(MessageDialogResult) + Send + 'static>(
  title: impl AsRef<str>,
  message: impl AsRef<str>,
  buttons: MessageButtons,
  level: MessageLevel,
  f: F,
) {
  let title = title.as_ref().to_string();
  let message = message.as_ref().to_string();
  #[allow(unused_mut)]
  let mut builder = MessageDialog::new()
    .set_title(&title)
    .set_description(&message)
    .set_buttons(buttons)
    .set_level(level.into());

  run_dialog!(builder.show(), f)
}

/// # 运行dialog
/// ```rust
/// use e_utils::dialog::*;
/// use e_utils::Result;
/// fn main() -> Result<()> {
///   dialog_block(
///     "测试",
///     "通知",
///     MessageButtons::Ok,
///     MessageLevel::Error,
///     |_x| {},
///   );
///   Ok(())
/// }
///```
#[allow(unused_variables)]
pub fn dialog_block<F: FnOnce(MessageDialogResult) + Send + 'static>(
  title: impl AsRef<str>,
  message: impl AsRef<str>,
  buttons: MessageButtons,
  level: MessageLevel,
  f: F,
) {
  let title = title.as_ref().to_string();
  let message = message.as_ref().to_string();
  #[allow(unused_mut)]
  let mut builder = MessageDialog::new()
    .set_title(&title)
    .set_description(&message)
    .set_buttons(buttons)
    .set_level(level.into());
  f(builder.show())
}
/// # 错误dialog
#[allow(unused_variables)]
pub fn dialog_err(title: impl AsRef<str>, message: impl AsRef<str>) {
  let msg = message.as_ref();
  dialog(
    title.as_ref(),
    msg,
    MessageButtons::Ok,
    MessageLevel::Error,
    |_| {},
  );
}
/// # 错误dialog
#[allow(unused_variables)]
pub fn dialog_err_block(title: impl AsRef<str>, message: impl AsRef<str>) {
  let msg = message.as_ref();
  dialog_block(
    title.as_ref(),
    msg,
    MessageButtons::Ok,
    MessageLevel::Error,
    |_| {},
  );
}

macro_rules! file_dialog_builder {
  () => {
    #[cfg(target_os = "linux")]
    type FileDialog = rfd::FileDialog;
    #[cfg(not(target_os = "linux"))]
    type FileDialog = rfd::AsyncFileDialog;

    /// The file dialog builder.
    ///
    /// Constructs file picker dialogs that can select single/multiple files or directories.
    #[derive(Debug, Default)]
    pub struct FileBuilder(FileDialog);

    impl FileBuilder {
      /// Gets the default file dialog builder.
      pub fn new() -> Self {
        Default::default()
      }

      /// Add file extension filter. Takes in the name of the filter, and list of extensions
      #[must_use]
      pub fn add_filter(mut self, name: impl AsRef<str>, extensions: &[&str]) -> Self {
        self.0 = self.0.add_filter(name.as_ref(), extensions);
        self
      }

      /// Set starting directory of the dialog.
      #[must_use]
      pub fn set_directory<P: AsRef<Path>>(mut self, directory: P) -> Self {
        self.0 = self.0.set_directory(directory);
        self
      }

      /// Set starting file name of the dialog.
      #[must_use]
      pub fn set_file_name(mut self, file_name: &str) -> Self {
        self.0 = self.0.set_file_name(file_name);
        self
      }
      /// Set the title of the dialog.
      #[must_use]
      pub fn set_title(mut self, title: &str) -> Self {
        self.0 = self.0.set_title(title);
        self
      }
    }
  };
}

macro_rules! message_dialog_builder {
  () => {
    /// A builder for message dialogs.
    #[derive(Debug)]
    pub struct MessageDialogBuilder(rfd::MessageDialog);

    impl MessageDialogBuilder {
      /// Creates a new message dialog builder.
      pub fn new(title: impl AsRef<str>, message: impl AsRef<str>) -> Self {
        let title = title.as_ref().to_string();
        let message = message.as_ref().to_string();
        Self(
          rfd::MessageDialog::new()
            .set_title(&title)
            .set_description(&message),
        )
      }

      /// Set the set of button that will be displayed on the dialog.
      pub fn buttons(mut self, buttons: MessageDialogButtons) -> Self {
        self.0 = self.0.set_buttons(buttons.into());
        self
      }

      /// Set type of a dialog.
      ///
      /// Depending on the system it can result in type specific icon to show up,
      /// the will inform user it message is a error, warning or just information.
      pub fn kind(mut self, kind: MessageDialogKind) -> Self {
        self.0 = self.0.set_level(kind.into());
        self
      }
    }
  };
}

/// Options for action buttons on message dialogs.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MessageDialogButtons {
  /// Ok button.
  Ok,
  /// Ok and Cancel buttons.
  OkCancel,
  /// Yes and No buttons.
  YesNo,
  /// OK button with customized text.
  OkWithLabel(String),
  /// Ok and Cancel buttons with customized text.
  OkCancelWithLabels(String, String),
}

impl From<MessageDialogButtons> for rfd::MessageButtons {
  fn from(kind: MessageDialogButtons) -> Self {
    match kind {
      MessageDialogButtons::Ok => Self::Ok,
      MessageDialogButtons::OkCancel => Self::OkCancel,
      MessageDialogButtons::YesNo => Self::YesNo,
      MessageDialogButtons::OkWithLabel(ok_text) => Self::OkCustom(ok_text),
      MessageDialogButtons::OkCancelWithLabels(ok_text, cancel_text) => {
        Self::OkCancelCustom(ok_text, cancel_text)
      }
    }
  }
}

/// Types of message, ask and confirm dialogs.
#[non_exhaustive]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum MessageDialogKind {
  /// Information dialog.
  Info,
  /// Warning dialog.
  Warning,
  /// Error dialog.
  Error,
}

impl From<MessageDialogKind> for rfd::MessageLevel {
  fn from(kind: MessageDialogKind) -> Self {
    match kind {
      MessageDialogKind::Info => Self::Info,
      MessageDialogKind::Warning => Self::Warning,
      MessageDialogKind::Error => Self::Error,
    }
  }
}

macro_rules! run_dialog_sync {
  ($e:expr) => {{
    let (tx, rx) = sync_channel(0);
    let cb = move |response| {
      tx.send(response).unwrap();
    };
    run_file_dialog!($e, cb);
    rx.recv().unwrap()
  }};
}
/// Blocking interfaces for the dialog APIs.
///
/// The blocking APIs will block the current thread to execute instead of relying on callback closures,
/// which makes them easier to use.
///
/// **NOTE:** You cannot block the main thread when executing the dialog APIs, so you must use the [`crate::api::dialog`] methods instead.
/// Examples of main thread context are the [`crate::App::run`] closure and non-async commands.
pub mod blocking {
  use super::{MessageDialogButtons, MessageDialogKind};
  use std::path::{Path, PathBuf};
  use std::sync::mpsc::sync_channel;
  file_dialog_builder!();
  message_dialog_builder!();
  impl FileBuilder {
    /// Shows the dialog to select a single file.
    /// This is a blocking operation,
    /// and should *NOT* be used when running on the main thread context.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use e_utils::dialog::blocking::FileBuilder;
    /// #[tokio::main]
    /// async fn my_command() {
    ///   let file_path = FileBuilder::new().pick_file();
    ///   // do something with the optional file path here
    ///   // the file path is `None` if the user closed the dialog
    /// }
    /// ```
    pub fn pick_file(self) -> Option<PathBuf> {
      #[allow(clippy::let_and_return)]
      let response = run_dialog_sync!(self.0.pick_file());
      #[cfg(not(target_os = "linux"))]
      let response = response.map(|p| p.path().to_path_buf());
      response
    }

    /// Shows the dialog to select multiple files.
    /// This is a blocking operation,
    /// and should *NOT* be used when running on the main thread context.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use e_utils::dialog::blocking::FileBuilder;
    /// #[tokio::main]
    /// async fn my_command() {
    ///   let file_path = FileBuilder::new().pick_files();
    ///   // do something with the optional file paths here
    ///   // the file paths value is `None` if the user closed the dialog
    /// }
    /// ```
    pub fn pick_files(self) -> Option<Vec<PathBuf>> {
      #[allow(clippy::let_and_return)]
      let response = run_dialog_sync!(self.0.pick_files());
      #[cfg(not(target_os = "linux"))]
      let response =
        response.map(|paths| paths.into_iter().map(|p| p.path().to_path_buf()).collect());
      response
    }

    /// Shows the dialog to select a single folder.
    /// This is a blocking operation,
    /// and should *NOT* be used when running on the main thread context.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use e_utils::dialog::blocking::FileBuilder;
    /// #[tokio::main]
    /// async fn my_command() {
    ///   let folder_path = FileBuilder::new().pick_folder();
    ///   // do something with the optional folder path here
    ///   // the folder path is `None` if the user closed the dialog
    /// }
    /// ```
    pub fn pick_folder(self) -> Option<PathBuf> {
      #[allow(clippy::let_and_return)]
      let response = run_dialog_sync!(self.0.pick_folder());
      #[cfg(not(target_os = "linux"))]
      let response = response.map(|p| p.path().to_path_buf());
      response
    }

    /// Shows the dialog to select multiple folders.
    /// This is a blocking operation,
    /// and should *NOT* be used when running on the main thread context.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use e_utils::dialog::blocking::FileBuilder;
    /// #[tokio::main]
    /// async fn my_command() {
    ///   let folder_paths = FileBuilder::new().pick_folders();
    ///   // do something with the optional folder paths here
    ///   // the folder paths value is `None` if the user closed the dialog
    /// }
    /// ```
    pub fn pick_folders(self) -> Option<Vec<PathBuf>> {
      #[allow(clippy::let_and_return)]
      let response = run_dialog_sync!(self.0.pick_folders());
      #[cfg(not(target_os = "linux"))]
      let response =
        response.map(|paths| paths.into_iter().map(|p| p.path().to_path_buf()).collect());
      response
    }

    /// Shows the dialog to save a file.
    /// This is a blocking operation,
    /// and should *NOT* be used when running on the main thread context.
    ///
    /// # Examples
    ///
    /// ```rust,no_run
    /// use e_utils::dialog::blocking::FileBuilder;
    /// #[tokio::main]
    /// async fn my_command() {
    ///   let file_path = FileBuilder::new().save_file();
    ///   // do something with the optional file path here
    ///   // the file path is `None` if the user closed the dialog
    /// }
    /// ```
    pub fn save_file(self) -> Option<PathBuf> {
      #[allow(clippy::let_and_return)]
      let response = run_dialog_sync!(self.0.save_file());
      #[cfg(not(target_os = "linux"))]
      let response = response.map(|p| p.path().to_path_buf());
      response
    }
  }
}