use crate::unit_client::UnitClientError;
use crate::unitd_docker::UnitdContainer;
use serde::ser::SerializeMap;
use serde::{Serialize, Serializer};
use std::error::Error as StdError;
use std::path::{Path, PathBuf};
use std::{fmt, io};
use which::which;

use crate::runtime_flags::RuntimeFlags;
use crate::unitd_configure_options::UnitdConfigureOptions;
use crate::unitd_process::UnitdProcess;

pub const UNITD_PATH_ENV_KEY: &str = "UNITD_PATH";
pub const UNITD_BINARY_NAMES: [&str; 2] = ["unitd", "unitd-debug"];

#[derive(Debug)]
pub struct UnitdInstance {
    pub process: UnitdProcess,
    pub configure_options: Option<UnitdConfigureOptions>,
    pub errors: Vec<UnitClientError>,
}

impl Serialize for UnitdInstance {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_map(Some(11))?;
        let runtime_flags = self
            .process
            .cmd()
            .and_then(|cmd| cmd.flags)
            .map(|flags| flags.to_string());

        let configure_flags = self.configure_options.as_ref().map(|opts| opts.all_flags.clone());

        state.serialize_entry("process", &self.process)?;
        state.serialize_entry("version", &self.version())?;
        state.serialize_entry("control_socket", &self.control_api_socket_address())?;
        state.serialize_entry("log_path", &self.log_path())?;
        state.serialize_entry("pid_path", &self.pid_path())?;
        state.serialize_entry("modules_directory", &self.modules_directory())?;
        state.serialize_entry("state_directory", &self.state_directory())?;
        state.serialize_entry("tmp_directory", &self.tmp_directory())?;
        state.serialize_entry("runtime_flags", &runtime_flags)?;
        state.serialize_entry("configure_flags", &configure_flags)?;
        let string_errors = &self.errors.iter().map(|e| e.to_string()).collect::<Vec<String>>();
        state.serialize_entry("errors", string_errors)?;

        state.end()
    }
}

impl UnitdInstance {
    pub async fn running_unitd_instances() -> Vec<UnitdInstance> {
        Self::collect_unitd_processes(
            UnitdProcess::find_unitd_processes()
                .into_iter()
                .chain(
                    UnitdContainer::find_unitd_containers()
                        .await
                        .into_iter()
                        .map(|x| UnitdProcess::from(&x))
                        .collect::<Vec<_>>(),
                )
                .collect(),
        )
    }

    /// Find all running unitd processes and convert them into UnitdInstances and filter
    /// out all errors by printing them to stderr and leaving errored instances out of
    /// the returned vector.
    fn collect_unitd_processes(processes: Vec<UnitdProcess>) -> Vec<UnitdInstance> {
        Self::map_processes_to_instances(processes).into_iter().collect()
    }

    fn map_processes_to_instances(processes: Vec<UnitdProcess>) -> Vec<UnitdInstance> {
        fn unitd_path_from_process(process: &UnitdProcess) -> Result<Box<Path>, UnitClientError> {
            match process.executable_path() {
                Some(executable_path) => {
                    let is_absolute_working_dir = process
                        .working_dir
                        .as_ref()
                        .map(|p| p.is_absolute())
                        .unwrap_or_default();
                    if executable_path.is_absolute() {
                        Ok(executable_path.to_owned())
                    } else if executable_path.is_relative() && is_absolute_working_dir {
                        let new_path = process
                            .working_dir
                            .as_ref()
                            .unwrap()
                            .join(executable_path)
                            .canonicalize()
                            .map(|path| path.into_boxed_path())
                            .map_err(|error| UnitClientError::UnitdProcessParseError {
                                message: format!("Error canonicalizing unitd executable path: {}", error),
                                pid: process.process_id,
                            })?;
                        Ok(new_path)
                    } else if process.container.is_none() {
                        Err(UnitClientError::UnitdProcessParseError {
                            message: "Unable to get absolute unitd executable path from process".to_string(),
                            pid: process.process_id,
                        })
                    } else {
                        // container case
                        Ok(PathBuf::from("/").into_boxed_path())
                    }
                }
                None => Err(UnitClientError::UnitdProcessParseError {
                    message: "Unable to get unitd executable path from process".to_string(),
                    pid: process.process_id,
                }),
            }
        }

        fn map_process_to_unitd_instance(process: &UnitdProcess) -> UnitdInstance {
            match unitd_path_from_process(process) {
                Ok(_) if process.container.is_some() => {
                    let mut err = vec![];
                    // double check that it is running
                    let running = process.container
                        .as_ref()
                        .unwrap()
                        .container_is_running();

                    if running.is_none() || !running.unwrap() {
                        err.push(UnitClientError::UnitdProcessParseError{
                            message: "process container is not running".to_string(),
                            pid: process.process_id,
                        });
                    }

                    UnitdInstance {
                        process: process.to_owned(),
                        configure_options: None,
                        errors: err,
                    }
                },
                Ok(unitd_path) => match UnitdConfigureOptions::new(
                    &unitd_path.clone()
                        .into_path_buf()) {
                    Ok(configure_options) => UnitdInstance {
                        process: process.to_owned(),
                        configure_options: Some(configure_options),
                        errors: vec![],
                    },
                    Err(error) => {
                        let error = UnitClientError::UnitdProcessExecError {
                            source: error,
                            executable_path: unitd_path.to_string_lossy().parse().unwrap_or_default(),
                            message: "Error running unitd binary to get configure options".to_string(),
                            pid: process.process_id,
                        };
                        UnitdInstance {
                            process: process.to_owned(),
                            configure_options: None,
                            errors: vec![error],
                        }
                    }
                },
                Err(err) => UnitdInstance {
                    process: process.to_owned(),
                    configure_options: None,
                    errors: vec![err],
                },
            }
        }

        processes
            .iter()
            // This converts processes into a UnitdInstance
            .map(map_process_to_unitd_instance)
            .collect()
    }

    fn version(&self) -> Option<String> {
        match self.process.cmd()?.version {
            Some(version) => Some(version),
            None => self.configure_options.as_ref().map(|opts| opts.version.to_string()),
        }
    }

    fn flag_or_default_option<R>(
        &self,
        read_flag: fn(RuntimeFlags) -> Option<R>,
        read_opts: fn(UnitdConfigureOptions) -> Option<R>,
    ) -> Option<R> {
        self.process
            .cmd()?
            .flags
            .and_then(read_flag)
            .or_else(|| self.configure_options.to_owned().and_then(read_opts))
    }

    pub fn control_api_socket_address(&self) -> Option<String> {
        self.flag_or_default_option(
            |flags| flags.control_api_socket_address(),
            |opts| opts.default_control_api_socket_address(),
        )
    }

    pub fn pid_path(&self) -> Option<Box<Path>> {
        self.flag_or_default_option(|flags| flags.pid_path(), |opts| opts.default_pid_path())
    }

    pub fn log_path(&self) -> Option<Box<Path>> {
        self.flag_or_default_option(|flags| flags.log_path(), |opts| opts.default_log_path())
    }

    pub fn modules_directory(&self) -> Option<Box<Path>> {
        self.flag_or_default_option(
            |flags| flags.modules_directory(),
            |opts| opts.default_modules_directory(),
        )
    }

    pub fn state_directory(&self) -> Option<Box<Path>> {
        self.flag_or_default_option(|flags| flags.state_directory(), |opts| opts.default_state_directory())
    }

    pub fn tmp_directory(&self) -> Option<Box<Path>> {
        self.flag_or_default_option(|flags| flags.tmp_directory(), |opts| opts.default_tmp_directory())
    }
}

impl fmt::Display for UnitdInstance {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        const UNKNOWN: &str = "[unknown]";
        let version = self.version().unwrap_or_else(|| String::from("[unknown]"));
        let runtime_flags = self
            .process
            .cmd()
            .and_then(|cmd| cmd.flags)
            .map(|flags| flags.to_string())
            .unwrap_or_else(|| UNKNOWN.into());
        let configure_flags = self
            .configure_options
            .as_ref()
            .map(|opts| opts.all_flags.clone())
            .unwrap_or_else(|| UNKNOWN.into());
        let unitd_path: String = self
            .process
            .executable_path()
            .map(|p| p.to_string_lossy().into())
            .unwrap_or_else(|| UNKNOWN.into());
        let working_dir: String = self
            .process
            .working_dir
            .as_ref()
            .map(|p| p.to_string_lossy().into())
            .unwrap_or_else(|| UNKNOWN.into());
        let socket_address = self.control_api_socket_address().unwrap_or_else(|| UNKNOWN.to_string());
        let child_pids = self
            .process
            .child_pids
            .iter()
            .map(u64::to_string)
            .collect::<Vec<String>>()
            .join(", ");

        writeln!(
            f,
            "{} instance [pid: {}, version: {}]:",
            self.process.binary_name, self.process.process_id, version
        )?;
        writeln!(f, "  Executable: {}", unitd_path)?;
        writeln!(f, "  Process working directory: {}", working_dir)?;
        write!(f, "  Process ownership: ")?;
        if let Some(user) = &self.process.user {
            writeln!(f, "name: {}, uid: {}, gid: {}", user.name, user.uid, user.gid)?;
        } else {
            writeln!(f, "{}", UNKNOWN)?;
        }
        write!(f, "  Process effective ownership: ")?;
        if let Some(user) = &self.process.effective_user {
            writeln!(f, "name: {}, uid: {}, gid: {}", user.name, user.uid, user.gid)?;
        } else {
            writeln!(f, "{}", UNKNOWN)?;
        }

        writeln!(f, "  API control unix socket: {}", socket_address)?;
        writeln!(f, "  Child processes ids: {}", child_pids)?;
        writeln!(f, "  Runtime flags: {}", runtime_flags)?;
        writeln!(f, "  Configure options: {}", configure_flags)?;

        if let Some(ctr) = &self.process.container {
            writeln!(f, "  Container:")?;
            writeln!(f, "    Platform: {}", ctr.platform)?;
            if let Some(id) = ctr.container_id.clone() {
                writeln!(f, "    Container ID: {}", id)?;
            }
            writeln!(f, "    Mounts:")?;
            for (k, v) in &ctr.mounts {
                writeln!(f, "      {} => {}", k.to_string_lossy(), v.to_string_lossy())?;
            }
        }

        if !self.errors.is_empty() {
            write!(f, "  Errors:")?;
            for error in &self.errors {
                write!(f, "\n    {}", error)?;
            }
        }

        Ok(())
    }
}

pub fn find_executable_path(specific_path: Result<String, Box<dyn StdError>>) -> Result<PathBuf, Box<dyn StdError>> {
    fn find_unitd_in_system_path() -> Vec<PathBuf> {
        UNITD_BINARY_NAMES
            .iter()
            .map(which)
            .filter_map(Result::ok)
            .collect::<Vec<PathBuf>>()
    }

    match specific_path {
        Ok(path) => Ok(PathBuf::from(path)),
        Err(_) => {
            let unitd_paths = find_unitd_in_system_path();
            if unitd_paths.is_empty() {
                let err_msg = format!(
                    "Could not find unitd in system path or in UNITD_PATH environment variable. Searched for: {:?}",
                    UNITD_BINARY_NAMES
                );
                let err = io::Error::new(io::ErrorKind::NotFound, err_msg);
                Err(Box::from(err))
            } else {
                Ok(unitd_paths[0].clone())
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rand::rngs::StdRng;
    use rand::{RngCore, SeedableRng};

    // We don't need a secure seed for testing, in fact it is better that we have a
    // predictable value
    const SEED: [u8; 32] = [
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
        30, 31,
    ];
    #[tokio::test]
    async fn can_find_unitd_instances() {
        UnitdInstance::running_unitd_instances().await.iter().for_each(|p| {
            println!("{:?}", p);
            println!("Runtime Flags: {:?}", p.process.cmd().map(|c| c.flags));
            println!("Temp directory: {:?}", p.tmp_directory());
        })
    }

    fn mock_process<S: Into<String>>(
        rng: &mut StdRng,
        binary_name: S,
        executable_path: Option<String>,
    ) -> UnitdProcess {
        UnitdProcess {
            process_id: rng.next_u32() as u64,
            binary_name: binary_name.into(),
            executable_path: executable_path.map(|p| Box::from(Path::new(&p))),
            environ: vec![],
            all_cmds: vec![],
            working_dir: Some(Box::from(Path::new("/opt/unit"))),
            child_pids: vec![],
            user: None,
            effective_user: None,
            container: None,
        }
    }

    #[test]
    fn will_list_without_errors_valid_processes() {
        let specific_path = std::env::var(UNITD_PATH_ENV_KEY).map_err(|error| Box::new(error) as Box<dyn StdError>);
        let binding = match find_executable_path(specific_path) {
            Ok(path) => path,
            Err(error) => {
                eprintln!("Could not find unitd executable path: {} - skipping test", error);
                return;
            }
        };
        let binary_name = binding
            .file_name()
            .expect("Could not get binary name")
            .to_string_lossy()
            .to_string();
        let unitd_path = binding.to_string_lossy();
        let mut rng: StdRng = SeedableRng::from_seed(SEED);

        let processes = vec![
            mock_process(&mut rng, &binary_name, Some(unitd_path.to_string())),
            mock_process(&mut rng, &binary_name, Some(unitd_path.to_string())),
        ];
        let instances = UnitdInstance::collect_unitd_processes(processes);
        // assert_eq!(instances.len(), 3);
        instances.iter().for_each(|p| {
            assert_eq!(p.errors.len(), 0, "Expected no errors, got: {:?}", p.errors);
        })
    }
}