use crate::error::{CobbleError, CobbleResult};
use crate::minecraft::argument_replacements::ArgumentReplacements;
use crate::minecraft::launch_options::LaunchOptions;
use crate::minecraft::models::version_data::VersionData;
use crate::minecraft::process_handle::GameProcessHandle;
use crate::utils::os::Platform;
use ipc_channel::ipc;
use std::path::{Path, PathBuf};
use std::process::{exit, Command};
use std::thread::sleep;
use std::time::Duration;

/// Launches the game command, forks the process and returns a basic handle to the game process.
/// The handle can be used to stop the game and wait for it to stop.
pub fn launch(mut command: Command) -> CobbleResult<GameProcessHandle> {
    debug!("Launching minecraft");
    trace!("{:?}", command);

    let (stop_sender, stop_receiver) = ipc::bytes_channel()?;
    let (stopped_sender, stopped_receiver) = ipc::bytes_channel()?;

    let handle = GameProcessHandle::new(stop_sender, stopped_receiver);

    match fork::fork() {
        Ok(fork::Fork::Parent(_)) => {
            return Ok(handle);
        }
        Ok(fork::Fork::Child) => {
            // Start game process
            let mut child = match command.spawn() {
                Ok(child) => child,
                Err(err) => {
                    error!("{}", err);
                    exit(1);
                }
            };
            let game_pid = nix::unistd::Pid::from_raw(child.id() as i32);

            loop {
                // Check game exit
                match child.try_wait() {
                    Ok(Some(status)) => {
                        // Game exited
                        if !status.success() {
                            debug!("Game exited with status '{:?}'", status.code());
                        } else {
                            debug!("Game exited successfully");
                        }

                        if let Err(err) = stopped_sender.send(&[]) {
                            error!("{}", err);
                        }
                        break;
                    }
                    Ok(None) => {
                        // Game running
                    }
                    Err(err) => {
                        error!("Could not check if game still running: {}", err);
                        break;
                    }
                }

                // Check manual stop
                match stop_receiver.try_recv() {
                    Ok(_) => {
                        // Send SIGINT to game process
                        let signal = nix::sys::signal::Signal::SIGINT;
                        if let Err(err) = nix::sys::signal::kill(game_pid, signal) {
                            error!("{}", err);
                        }
                    }
                    Err(ipc::TryRecvError::Empty) => {
                        // Not yet sended
                    }
                    Err(err) => {
                        error!("{}", err);
                        break;
                    }
                }

                sleep(Duration::from_millis(500));
            }
        }
        Err(_) => {
            return Err(CobbleError::ProcessForking);
        }
    }

    Ok(handle)
}

/// Plugs every arguments together and creates the command
pub fn launch_command(
    java_exec: String,
    minecraft_path: impl AsRef<Path>,
    jvm_args: Vec<String>,
    log_argument: Option<String>,
    main_class: String,
    game_args: Vec<String>,
) -> Command {
    let mut command = Command::new(java_exec);
    command.current_dir(minecraft_path);
    command.args(jvm_args);

    if let Some(log_argument) = log_argument {
        command.arg(log_argument);
    }

    command.arg(main_class);
    command.args(game_args);

    command
}

/// Builds the launch command for Minecraft.
///
/// The game needs to be installed to launch properly.
pub fn build_launch_command(
    version_data: &VersionData,
    minecraft_path: impl AsRef<Path>,
    libraries_path: impl AsRef<Path>,
    assets_path: impl AsRef<Path>,
    natives_path: impl AsRef<Path>,
    log_configs_path: impl AsRef<Path>,
    launch_options: &LaunchOptions,
) -> CobbleResult<Command> {
    debug!("Building launch command");
    trace!("Version: {}", &version_data.id);
    trace!(
        "Minecraft Path: {}",
        minecraft_path.as_ref().to_string_lossy()
    );
    trace!(
        "Libraries Path: {}",
        libraries_path.as_ref().to_string_lossy()
    );
    trace!("Assets Path: {}", assets_path.as_ref().to_string_lossy());
    trace!("Natives Path: {}", natives_path.as_ref().to_string_lossy());
    trace!(
        "Log Configs Path: {}",
        log_configs_path.as_ref().to_string_lossy()
    );

    let classpath = build_classpath(version_data, &minecraft_path, &libraries_path)?;
    let argument_replacements = ArgumentReplacements::build(
        launch_options,
        version_data,
        classpath,
        minecraft_path.as_ref().to_string_lossy().to_string(),
        assets_path.as_ref().to_string_lossy().to_string(),
        natives_path.as_ref().to_string_lossy().to_string(),
    );

    let jvm_args = build_jvm_args(version_data, &argument_replacements, launch_options);
    let game_args = build_game_args(version_data, &argument_replacements, launch_options);

    // Logging config
    let log_argument = version_data.logging.clone().map(|logging_info| {
        let mut log_config_path = PathBuf::from(log_configs_path.as_ref());
        log_config_path.push(
            logging_info
                .client
                .file
                .id
                .as_ref()
                .expect("Logging info has no ID"),
        );

        logging_info
            .client
            .argument
            .clone()
            .replace("${path}", &log_config_path.to_string_lossy())
    });

    let command = launch_command(
        get_java_exec(launch_options),
        minecraft_path,
        jvm_args,
        log_argument,
        version_data.main_class.clone(),
        game_args,
    );

    Ok(command)
}

/// Gets the Java executable from launch options.
///
/// If [`java_exec`](crate::minecraft::launch_options::LaunchOptions::java_exec) is empty, fall back to `java`.
pub fn get_java_exec(launch_options: &LaunchOptions) -> String {
    if !launch_options.java_exec.is_empty() {
        return launch_options.java_exec.clone();
    }

    String::from("java")
}

/// Build the game arguments and replaces placeholders.
pub fn build_game_args(
    version_data: &VersionData,
    argument_replacements: &ArgumentReplacements,
    launch_options: &LaunchOptions,
) -> Vec<String> {
    debug!("Building Minecraft Args");

    let mut arguments = vec![];

    // New style
    if let Some(args) = &version_data.arguments {
        for argument in args.game_arguments() {
            arguments.push(argument_replacements.replace(&argument));
        }
    }

    // Old style
    if let Some(args) = &version_data.minecraft_arguments {
        for argument in args.split_whitespace() {
            arguments.push(argument_replacements.replace(argument));
        }
    }

    if launch_options.use_fullscreen {
        arguments.push("--fullscreen".to_string());
    } else if launch_options.enable_window_size {
        arguments.extend_from_slice(&[
            "--width".to_string(),
            launch_options.window_width.to_string(),
            "--height".to_string(),
            launch_options.window_height.to_string(),
        ]);
    }

    arguments
}

/// Build JVM arguments and replaces placeholders.
pub fn build_jvm_args(
    version_data: &VersionData,
    argument_replacements: &ArgumentReplacements,
    launch_options: &LaunchOptions,
) -> Vec<String> {
    debug!("Building JVM Args");

    let mut arguments = vec![];

    if launch_options.enable_memory {
        arguments.push(format!("-Xms{}M", launch_options.min_memory));
        arguments.push(format!("-Xmx{}M", launch_options.max_memory));
    }

    if launch_options.enable_jvm_args {
        // Custom
        for argument in launch_options.jvm_args.split_whitespace() {
            arguments.push(argument_replacements.replace(argument));
        }
    } else if let Some(args) = &version_data.arguments {
        // Version Data
        for argument in args.jvm_arguments() {
            arguments.push(argument_replacements.replace(&argument));
        }
    }

    // Essentials
    if !arguments
        .iter()
        .any(|arg| arg.starts_with("-Djava.library.path="))
    {
        let arg = "-Djava.library.path=${natives_directory}";
        arguments.push(argument_replacements.replace(arg));
    }
    if !arguments.iter().any(|arg| arg.starts_with("-cp")) {
        let arg = "${classpath}";
        arguments.push("-cp".to_string());
        arguments.push(argument_replacements.replace(arg));
    }

    arguments
}

/// Build the classpath.
pub fn build_classpath(
    version_data: &VersionData,
    minecraft_path: impl AsRef<Path>,
    libraries_path: impl AsRef<Path>,
) -> CobbleResult<String> {
    debug!("Building classpath");

    let mut classes: Vec<String> = vec![];

    for library in version_data.needed_libraries() {
        let jar_path = match &library.get_native() {
            Some(native) => library.jar_path(libraries_path.as_ref(), Some(native))?,
            None => library.jar_path(libraries_path.as_ref(), None)?,
        };

        classes.push(jar_path.to_string_lossy().to_string());
    }

    let mut minecraft_path = PathBuf::from(minecraft_path.as_ref());
    minecraft_path.push("bin");
    minecraft_path.push(format!("minecraft-{}-client.jar", &version_data.id));

    classes.push(minecraft_path.to_string_lossy().to_string());

    Ok(classes.join(&Platform::current().classpath_seperator().to_string()))
}