#[cfg(feature = "completions_v2")]
mod js;

use std::collections::{HashMap, HashSet};
use std::ops::Deref;
use std::path::Path;
use std::sync::Arc;

use anyhow::Result;
use async_trait::async_trait;
use lazy_static::lazy_static;
use smol_str::SmolStr;
use typed_path::{TypedPath, TypedPathBuf};
use galaxy_completer::completer::{
    CommandExitStatus, CommandOutput, CompletionContext, EngineDirEntry, EngineFileType,
    GeneratorContext, PathCompletionContext, PathSeparators, TopLevelCommandCaseSensitivity,
};
use galaxy_completer::signatures::CommandRegistry;
use galaxy_core::features::FeatureFlag;
use galaxy_util::path::{EscapeChar, ShellFamily};
use galaxyui::{AppContext, SingletonEntity};

use crate::safe_warn;
use crate::terminal::model::session::{ExecuteCommandOptions, Session, SessionType};
use crate::util::AsciiDebug;
use crate::workflows::aliases::WorkflowAliases;

lazy_static! {
    pub static ref CURR_DIRECTORY_ENTRY: EngineDirEntry = EngineDirEntry {
        file_name: ".".to_owned(),
        file_type: EngineFileType::Directory,
    };
    pub static ref PARENT_DIRECTORY_ENTRY: EngineDirEntry = EngineDirEntry {
        file_name: "..".to_owned(),
        file_type: EngineFileType::Directory,
    };
    static ref EMPTY_COMMAND_REGISTRY: Arc<CommandRegistry> = Arc::new(CommandRegistry::empty());
}

#[derive(Clone)]
pub struct SessionContext {
    pub session: Arc<Session>,
    command_registry: Arc<CommandRegistry>,
    pub current_working_directory: TypedPathBuf,

    #[cfg(feature = "completions_v2")]
    js_ctx: Option<js::SessionJsExecutionContext>,

    cached_directory_entries: dashmap::DashMap<TypedPathBuf, Arc<Vec<EngineDirEntry>>>,

    /// Snapshot of all Warp workflow aliases.
    workflow_aliases: HashMap<String, String>,
}

impl SessionContext {
    async fn list_directory_entries_internal(
        &self,
        directory: &TypedPath<'_>,
    ) -> Vec<EngineDirEntry> {
        match self.session.session_type() {
            SessionType::Local => {
                let dir = match self.session.maybe_convert_to_native_path(directory) {
                    Ok(dir) => dir,
                    Err(err) => {
                        log::warn!("Failed to convert path: {err:#}");
                        return Vec::new();
                    }
                };
                // We intentionally use the synchronous `std::fs::read_dir`,
                // despite this being an async function, because the overhead
                // of switching threads is very expensive relative to the
                // amount of work being done.  Converting the a `DirEntry`
                // to `EngineDirEntry` can usually be done without additional
                // syscalls (though one is necessary if the entry is a
                // symlink).
                //
                // It's possible that it would be better to use
                // `async_fs::read_dir` if the directory is on a network mount,
                // but I don't think it's worth optimizing for that case.
                let Some(read_dir) = std::fs::read_dir(dir.as_path()).ok() else {
                    return vec![];
                };

                read_dir
                    .filter_map(|res| res.and_then(EngineDirEntry::try_from).ok())
                    .collect::<Vec<_>>()
            }
            SessionType::WarpifiedRemote { .. } => {
                let env_vars = self
                    .session
                    .path()
                    .as_deref()
                    .map(|path| HashMap::from_iter([("PATH".to_string(), path.to_string())]));

                let Some(ls_command) = ls_script_for_dir(directory) else {
                    return vec![];
                };

                // The in-band command executor doesn't support executing from
                // from an arbitrary directory, so we need to cd into the
                // directory we want within the ls script.
                let command_output_result = self
                    .session
                    .execute_command(
                        &ls_command,
                        None,
                        env_vars,
                        ExecuteCommandOptions::default(),
                    )
                    .await;

                if let Ok(command_output) = command_output_result {
                    let Ok(output_string) = command_output.to_string() else {
                        log::warn!(
                            "Executing `ls` on remote box returned unparseable bytes: `{:?}`",
                            AsciiDebug(command_output.output())
                        );
                        return vec![];
                    };

                    match command_output.status {
                        CommandExitStatus::Success => {
                            let mut entries = Vec::new();
                            let mut entries_iter = output_string.split('\0');
                            let dirs = entries_iter
                                .by_ref()
                                // We use two consecutive null characters to separate files and
                                // folders, so detect that here. Note that take_while consumes the
                                // first entry that returns false.
                                .take_while(|entry| !entry.is_empty())
                                .filter_map(|entry| {
                                    if entry == "." {
                                        return None;
                                    }

                                    Path::new(entry)
                                        .file_name()
                                        .and_then(|name| name.to_str())
                                        .map(|name| EngineDirEntry {
                                            file_name: name.to_owned(),
                                            file_type: EngineFileType::Directory,
                                        })
                                });
                            entries.extend(dirs);

                            let files = entries_iter.filter_map(|entry| {
                                Path::new(entry)
                                    .file_name()
                                    .and_then(|name| name.to_str())
                                    .map(|name| EngineDirEntry {
                                        file_name: name.to_owned(),
                                        file_type: EngineFileType::File,
                                    })
                            });
                            entries.extend(files);

                            entries
                        }
                        CommandExitStatus::Failure => {
                            safe_warn!(
                                safe: ("Executing `ls` on remote box failed with non-zero status code."),
                                full: ("Executing `ls` on remote box failed with error: {}", &String::from_utf8_lossy(command_output.output()))
                            );
                            vec![]
                        }
                    }
                } else {
                    log::warn!(
                        "Executing `ls` on remote box failed with error {command_output_result:?}"
                    );
                    vec![]
                }
            }
        }
    }
}

#[async_trait]
impl PathCompletionContext for SessionContext {
    fn home_directory(&self) -> Option<&str> {
        self.session.home_dir()
    }

    fn pwd(&self) -> TypedPath<'_> {
        self.current_working_directory.to_path()
    }

    fn shell_family(&self) -> ShellFamily {
        self.session.shell_family()
    }

    async fn list_directory_entries(&self, directory: TypedPathBuf) -> Arc<Vec<EngineDirEntry>> {
        if let Some(entries) = self.cached_directory_entries.get(&directory) {
            return entries.clone();
        }

        let result = self
            .list_directory_entries_internal(&directory.to_path())
            .await;

        let result = Arc::new(result);
        self.cached_directory_entries
            .insert(directory, result.clone());
        result
    }

    fn path_separators(&self) -> PathSeparators {
        self.session.path_separators()
    }
}

#[async_trait]
impl GeneratorContext for SessionContext {
    async fn execute_command_at_pwd(
        &self,
        shell_command: &str,
        session_env_vars: Option<HashMap<String, String>>,
    ) -> Result<CommandOutput> {
        let mut env_vars = session_env_vars.unwrap_or_default();
        // We need to run the command with the PATH var set explicitly even if we have session env vars
        // because if the user opened Warp through a parent process that didn't have the PATH var set
        // (i.e. outside of a shell, for example opening the app via Finder),
        // the subshell won't inherit the PATH var, but we need the PATH var
        // to reference executables we might run as part of generators.
        if let Some(path) = self.session.path().as_deref() {
            env_vars.insert("PATH".to_string(), path.to_string());
        }

        let env_vars_option = if env_vars.is_empty() {
            None
        } else {
            Some(env_vars)
        };

        self.session
            .execute_command(
                shell_command,
                self.pwd().to_str(),
                env_vars_option,
                ExecuteCommandOptions {
                    run_command_in_same_shell_as_session: !FeatureFlag::RunGeneratorsWithCmdExe
                        .is_enabled(),
                },
            )
            .await
    }

    fn supports_parallel_execution(&self) -> bool {
        self.session.supports_parallel_command_execution()
    }
}

impl CompletionContext for SessionContext {
    fn generator_context(&self) -> Option<&dyn GeneratorContext> {
        Some(self)
    }

    fn path_completion_context(&self) -> Option<&dyn PathCompletionContext> {
        Some(self)
    }

    fn top_level_commands(&self) -> Box<dyn Iterator<Item = &str> + '_> {
        Box::new(
            self.session
                .top_level_commands()
                .chain(self.workflow_aliases.keys().map(String::as_str)),
        )
    }

    fn command_case_sensitivity(&self) -> TopLevelCommandCaseSensitivity {
        self.session.command_case_sensitivity()
    }

    fn escape_char(&self) -> EscapeChar {
        self.session.shell_family().escape_char()
    }

    fn aliases(&self) -> Box<dyn Iterator<Item = (&str, &str)> + '_> {
        let session_aliases = self
            .session
            .aliases()
            .iter()
            .map(|(alias, command)| (alias.as_str(), command.as_str()));
        let workflow_aliases = self
            .workflow_aliases
            .iter()
            .map(|(alias, command)| (alias.as_str(), command.as_str()));
        Box::new(workflow_aliases.chain(session_aliases))
    }

    fn alias_command(&self, alias: &str) -> Option<&str> {
        self.workflow_aliases
            .get(alias)
            .or_else(|| self.session.aliases().get(alias))
            .map(Deref::deref)
    }

    fn abbreviations(&self) -> Option<&HashMap<SmolStr, String>> {
        Some(self.session.abbreviations())
    }

    fn functions(&self) -> Option<&HashSet<SmolStr>> {
        Some(self.session.functions())
    }

    fn builtins(&self) -> Option<&HashSet<SmolStr>> {
        Some(self.session.builtins())
    }

    fn command_registry(&self) -> &CommandRegistry {
        &self.command_registry
    }

    fn environment_variable_names(&self) -> Option<&HashSet<SmolStr>> {
        Some(self.session.environment_variable_names())
    }

    fn shell_supports_autocd(&self) -> Option<bool> {
        Some(self.session.shell().supports_autocd())
    }

    #[cfg(feature = "completions_v2")]
    fn js_context(&self) -> Option<&dyn galaxy_completer::completer::JsExecutionContext> {
        self.js_ctx
            .as_ref()
            .map(|ctx| -> &dyn galaxy_completer::completer::JsExecutionContext { ctx })
    }

    fn shell_family(&self) -> Option<ShellFamily> {
        Some(self.session.shell_family())
    }
}

impl SessionContext {
    pub fn new(
        session: impl Into<Arc<Session>>,
        command_registry: Arc<CommandRegistry>,
        current_working_directory: TypedPathBuf,
        #[allow(unused_variables)] ctx: &AppContext,
    ) -> Self {
        let workflow_aliases = if FeatureFlag::WorkflowAliases.is_enabled() {
            WorkflowAliases::as_ref(ctx).autocomplete_data(ctx)
        } else {
            Default::default()
        };

        cfg_if::cfg_if! {
            if #[cfg(feature = "completions_v2")] {
                use crate::plugin::{PluginHost, service::CallJsFunctionService};

                let js_function_caller = PluginHost::handle(ctx)
                    .as_ref(ctx)
                    .plugin_service_caller::<CallJsFunctionService>();
                Self {
                    session: session.into(),
                    command_registry,
                    current_working_directory,
                    js_ctx: js_function_caller.map(js::SessionJsExecutionContext::new),
                    cached_directory_entries: Default::default(),
                    workflow_aliases,
                }
            } else {
                Self {
                    session: session.into(),
                    command_registry,
                    current_working_directory,
                    cached_directory_entries: Default::default(),
                    workflow_aliases,
                }
            }
        }
    }
}

/// `CompletionContext` implementation for "global" completions, that provide completions on all
/// commands in the `command_registry` rather than providing session-specific completions.
///
/// This `CompletionContext` is not coupled to a specific session and thus does not provide path or
/// generator execution, which wouldn't have clear semantics without being coupled to a session.
#[derive(Clone)]
pub struct SessionAgnosticContext {
    command_registry: Arc<CommandRegistry>,
}

impl SessionAgnosticContext {
    pub fn new(command_registry: Arc<CommandRegistry>) -> Self {
        Self { command_registry }
    }
}

impl CompletionContext for SessionAgnosticContext {
    fn top_level_commands(&self) -> Box<dyn Iterator<Item = &str> + '_> {
        Box::new(self.command_registry.registered_commands())
    }

    fn command_registry(&self) -> &CommandRegistry {
        &self.command_registry
    }

    fn environment_variable_names(&self) -> Option<&HashSet<SmolStr>> {
        None
    }

    fn shell_supports_autocd(&self) -> Option<bool> {
        None
    }

    fn path_completion_context(&self) -> Option<&dyn PathCompletionContext> {
        None
    }

    fn generator_context(&self) -> Option<&dyn GeneratorContext> {
        None
    }
}

/// Empty `CompletionContext` used in places without a live shell session
/// (i.e. shared session viewers without a real terminal instance).
#[derive(Clone)]
pub struct EmptyCompletionContext;
impl EmptyCompletionContext {
    pub fn new() -> Self {
        Self
    }
}
impl CompletionContext for EmptyCompletionContext {
    fn top_level_commands(&self) -> Box<dyn Iterator<Item = &str> + '_> {
        Box::new(std::iter::empty())
    }

    fn command_registry(&self) -> &CommandRegistry {
        &EMPTY_COMMAND_REGISTRY
    }

    fn environment_variable_names(&self) -> Option<&HashSet<SmolStr>> {
        None
    }

    fn shell_supports_autocd(&self) -> Option<bool> {
        None
    }

    fn path_completion_context(&self) -> Option<&dyn PathCompletionContext> {
        None
    }

    fn generator_context(&self) -> Option<&dyn GeneratorContext> {
        None
    }
}

/// List files and directories in a directory; used for completions on a remote machine.
/// This uses `find` instead of `ls` due to the challenges of parsing `ls` output for
/// unusual file names (e.g.: ones including newlines).
/// We intentionally ignore '.' and '..' here as we add those suggestions manually.
fn ls_script_for_dir(directory: &TypedPath) -> Option<String> {
    // We need to cd into the directory we want completions for
    let Some(dir_str) = directory.to_str() else {
        log::warn!("Non-unicode character found in path: `{directory:?}`");
        return None;
    };
    let escaped_dir = galaxy_util::path::ShellFamily::Posix.shell_escape(dir_str);

    // Get all directories with -print0, which makes all items end in `\0` (null character)
    // Get all files with -print0, which makes all items end in `\0`
    // Separate the two lists with `\0`
    // Ex: `a\0b\0\c\0\0d.txt\0e.txt\0f.txt\0`
    // Then do the same for anything that is not a directory, and call it a 'File'.
    let command = format!(
        r#"
cd {escaped_dir} && 
find . -maxdepth 1 -type d -print0 &&
printf '%b' '\0' &&
find . -maxdepth 1 -not -type d -print0
            "#
    )
    // Ensure all newlines are escaped, and that the command is a single line.
    // ls_script_for_dir should not contain newlines, as we need to run it as a
    // single line for TMUX control mode at this time.
    .replace("\n", " ");

    Some(command)
}

#[cfg(test)]
#[path = "test.rs"]
mod tests;