use nextsync::config::config::Config;
use rand::{distributions::Alphanumeric, Rng};
use std::env;
use std::fs::{self, File};
use std::io::{self, Write};
use std::path::PathBuf;
use std::process::{Command, Output};
use std::str;

pub struct ClientTest {
    volume: String,      // temp dir for the test
    pub test_id: String, // name of the test (e.g nextsync_rand)
    exe_path: PathBuf,   // absolute path of nextsync executable
}

pub fn get_random_test_id() -> String {
    rand::thread_rng()
        .sample_iter(&Alphanumeric)
        .take(4)
        .map(char::from)
        .collect()
}

impl ClientTest {
    pub fn new(id: &str) -> Self {
        let mut test_id = id.to_string();
        test_id.push_str("_");
        test_id.push_str(&get_random_test_id());

        // create a directory in /tmp with the given id
        let mut vol = String::from("/tmp/nextsync/");
        vol.push_str(&test_id);
        let _ = fs::remove_dir_all(&vol);
        let _ = fs::create_dir_all(&vol);

        // get nextsync path
        let mut exe_path = env::current_dir().unwrap();
        exe_path = exe_path.join("target/debug/nextsync");

        // build the client
        ClientTest {
            volume: vol,
            test_id,
            exe_path,
        }
    }

    pub fn init(mut self) -> Self {
        self.exec_ok("init");
        println!("========== {} ========== ", &self.test_id);

        // set remote url
        // let url = String::from(format!("{}@nextcloud.local/{}", self.user, self.test_id));
        // self.run_cmd_ok(&format!("remote add origin {}", url));

        // // set force_unsecure as debug server has not certificate
        // self.run_cmd_ok("config set force_insecure true");

        // // set token for request
        // self.run_cmd_ok(&format!("credential add {} {}", self.user, self.user));
        self
    }

    pub fn get_config(&self) -> Config {
        Config::from(Some(&self.volume))
    }

    pub fn ok(self) -> io::Result<()> {
        fs::remove_dir_all(&self.volume)?;
        Ok(())
    }

    pub fn exec_ok(&mut self, args: &str) -> Output {
        let output = self.exec(args);
        if !output.status.success() {
            println!("id: {}", self.test_id.clone());
            println!("Failed to execute: '{}'", args);
            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
        }
        assert!(output.status.success());
        output
    }

    pub fn exec(&mut self, args: &str) -> Output {
        let output = Command::new(self.exe_path.to_str().unwrap())
            .current_dir(self.volume.clone())
            .args(args.split(" "))
            .output()
            .expect("Could not execute nextsync command");
        return output;
    }

    pub fn add_dir(&mut self, name: &str) -> std::io::Result<()> {
        let mut path = self.volume.clone();
        path.push_str("/");
        path.push_str(name);
        let _ = fs::create_dir_all(path)?;
        Ok(())
    }

    pub fn add_file(&mut self, name: &str, content: &str) -> std::io::Result<()> {
        let mut path = self.volume.clone();
        path.push_str("/");
        path.push_str(name);

        let mut file = File::create(path)?;
        file.write_all(content.as_bytes())?;
        Ok(())
    }

    pub fn remove_file(&mut self, name: &str) -> std::io::Result<()> {
        let mut path = self.volume.clone();
        path.push_str("/");
        path.push_str(name);
        fs::remove_file(path)?;
        Ok(())
    }

    pub fn remove_dir(&mut self, name: &str) -> std::io::Result<()> {
        let mut path = self.volume.clone();
        path.push_str("/");
        path.push_str(name);
        fs::remove_dir_all(path)?;
        Ok(())
    }

    // pub fn has_file(&mut self, file: &str, content: &str) -> bool {
    //     let full_path = PathBuf::from(self.volume.clone()).join(file);

    //     // has_files(full_path, file, content, self.test_id.clone())
    // }
}