//! This module contains the cache manager.

use std::path::PathBuf;
use std::fs::File;
use std::io::{Write, BufRead, BufReader};
use walkdir::WalkDir;
use crate::{Result, GCLONE_PATH};

/// The cache of gclone.
///
/// When running the command `cdg`, if the computer just booted, finding all the directories can be
/// quite slow. The cache contains the list of entries in the git directory to avoid re-finding
/// them every time.
pub struct Cache(Vec<String>);

impl Cache {

    /// Generates the cache by traversing the files in the git directory.
    pub fn generate() -> Cache {
        Cache(WalkDir::new(&*GCLONE_PATH)
            .max_depth(3)
            .into_iter()
            .filter_map(|x| x.ok())
            .map(|x| x.path().display().to_string())
            .collect())
    }

    /// Reads the cache file.
    pub fn read() -> Result<Cache> {

        let mut path = PathBuf::from(&*GCLONE_PATH);
        path.push(".cdgcache");

        let file = File::open(&path)?;
        let file = BufReader::new(file);

        let mut values = vec![];

        for line in file.lines() {
            if let Ok(l) = line {
                values.push(l);
            }
        }

        Ok(Cache(values))
    }

    /// Reads the cache file, and if it failed, generate a new cache.
    pub fn read_or_generate() -> Cache {
        match Cache::read() {
            Ok(c) => c,
            Err(_) => Cache::generate(),
        }
    }

    /// Writes the current content of the cache to the cache file.
    pub fn write(&self) -> Result<()> {
        let mut path = PathBuf::from(&*GCLONE_PATH);
        path.push(".cdgcache");
        let mut file = File::create(path)?;

        for line in &self.0 {
            writeln!(file, "{}", line)?;
        }

        Ok(())
    }

    /// Search a directory in the cache, and returns all matching directories.
    pub fn find(&self, dirname: &str) -> Vec<String> {
        let dirname = &format!("/{}", dirname);
        let mut matches = vec![];
        for line in &self.0 {
            if line.ends_with(dirname) {
                matches.push(line.clone());
            }
        }

        matches
    }

    /// Appends a value to the cache.
    pub fn append(&mut self, value: String) {
        self.0.push(value);
    }
}