use crate::configuration::Configuration;
use crate::remote::sync_up;
use std::io::Result;

pub struct SyncUp;

impl SyncUp {
    pub fn new() -> Self {
        SyncUp
    }
}

impl super::Command for SyncUp {
    fn before_dependencies(&self) -> Vec<Box<dyn super::Command>> {
        vec![]
    }

    fn execute(
        &self,
        _: Option<&String>,
        configuration: &Configuration,
        command: &str,
    ) -> Result<()> {
        match sync_up(&configuration.data_directory, &configuration.remote_config) {
            Ok(()) => {}
            Err(e) => {
                if command == self.command() {
                    return Err(e);
                }
            }
        }
        Ok(())
    }

    fn after_dependencies(&self) -> Vec<Box<dyn super::Command>> {
        vec![]
    }

    fn command(&self) -> &'static str {
        "sync-up"
    }

    fn help(&self) -> &'static str {
        "\t\t\t\tPushes to the git remote if configured"
    }
}

#[cfg(test)]
mod tests {
    use std::fs::create_dir_all;

    use super::*;
    use crate::command::Command;
    use crate::configuration::Configuration;

    use test_utilities::*;

    #[test]
    fn test_sync_up_command() {
        let sync_up = SyncUp::new();

        let test_dir = setup_test_dir();
        let local_dir = test_dir.join("commandlocal");
        let remote_dir = test_dir.join("commandremote");
        create_dir_all(&local_dir).expect("Could not create local test directory");
        create_dir_all(&remote_dir).expect("Could not create remote test directory");

        create_remote(&remote_dir);

        let remote_dir_as_string = remote_dir.display().to_string();
        create_test_file(&test_dir.join("remoteconfig"), &remote_dir_as_string);

        let mut configuration = Configuration::new().unwrap();
        configuration.data_directory = local_dir.clone();
        configuration.remote_config = test_dir.join("remoteconfig");

        create_test_file(&local_dir.join("file1.txt"), "I exist");
        sync_up
            .execute(None, &configuration, "sync-up")
            .expect("Could not sync up to remote");
        assert_file_in_repo_with_contents(&remote_dir_as_string, "file1.txt", "I exist");
        assert_file_in_repo_does_not_exist(&remote_dir_as_string, "file2.txt");

        create_test_file(&local_dir.join("file2.txt"), "I also exist now, btw");
        sync_up
            .execute(None, &configuration, "sync-up")
            .expect("Could not sync up to remote");
        assert_file_in_repo_with_contents(&remote_dir_as_string, "file1.txt", "I exist");
        assert_file_in_repo_with_contents(
            &remote_dir_as_string,
            "file2.txt",
            "I also exist now, btw",
        );
        cleanup_test_dir(&test_dir);
    }

    #[test]
    fn test_sync_up_fails_with_incorrect_remote() {
        let sync_up = SyncUp::new();

        let test_dir = setup_test_dir();
        create_test_file(&test_dir.join("remoteconfig"), "DO NOT WAAANT");

        let mut configuration = Configuration::new().unwrap();
        configuration.data_directory = test_dir.clone();
        configuration.remote_config = test_dir.join("remoteconfig");

        let result = sync_up.execute(None, &configuration, "sync-up");
        assert!(result.is_err());
        cleanup_test_dir(&test_dir);
    }

    #[test]
    fn test_sync_up_does_not_fail_if_running_as_dependency() {
        let sync_up = SyncUp::new();

        let test_dir = setup_test_dir();
        create_test_file(&test_dir.join("remoteconfig"), "DO NOT WAAANT");

        let mut configuration = Configuration::new().unwrap();
        configuration.data_directory = test_dir.clone();
        configuration.remote_config = test_dir.join("remoteconfig");

        let result = sync_up.execute(None, &configuration, "NOPE");
        assert!(result.is_ok());
        cleanup_test_dir(&test_dir);
    }

    #[test]
    fn sync_up_before_dependencies() {
        let sync_up = SyncUp::new();
        let dependencies = sync_up.before_dependencies();

        assert_eq!(dependencies.len(), 0);
    }

    #[test]
    fn sync_up_after_dependencies() {
        let sync_up = SyncUp::new();
        let dependencies = sync_up.after_dependencies();

        assert_eq!(dependencies.len(), 0);
    }

    // These two tests feel pointless but I'm doing it for the coverage :p

    #[test]
    fn sync_up_command_output() {
        let sync_up = SyncUp::new();
        sync_up.command();
    }

    #[test]
    fn sync_up_help_output() {
        let sync_up = SyncUp::new();
        sync_up.help();
    }
}