#[cfg(test)]
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
}

#[cfg(test)]
impl ClientTest {
    pub fn new(id: String) -> Self {
        // create a directory in /tmp with the given id
        let mut vol = String::from("/tmp/");
        vol.push_str(&id);
        let _ = fs::create_dir(vol.clone());

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

        // build the client
        ClientTest {
            user: String::from("admin"),
            volume: vol,
            test_id: id,
            exe_path 
        }
    }

    pub fn init(mut self) -> Self {
        self.run_cmd_ok("init");

        // 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 clean(self) -> Self {
        let _ = fs::remove_dir_all(&self.volume);
        self
    }

    pub fn run_cmd_ok(&mut self, args: &str) -> Output {
        let output = self.run_cmd(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 run_cmd(&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())
    }
}