/*
* Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
*
* Use of this source code is governed by the Apache 2.0 and/or the MIT
* License.
*/
//! Module describing runtime compoenet for fetching modified filenames
//!
//! Add the following tou your program to load the filemap during compiletime:
//!
//! ```no_run
//! use cache_buster::Files;
//!
//! fn main(){
//!    let files = Files::load();
//! }
//! ```

use std::collections::HashMap;
use std::env;

use serde::{Deserialize, Serialize};

const ENV_VAR_NAME: &str = "CACHE_BUSTER_FILE_MAP";

/// Filemap struct
///
/// maps original names to generated names
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct Files {
    /// filemap<original-path, modified-path>
    pub map: HashMap<String, String>,
    base_dir: String,
}

impl Files {
    /// Initialize map
    pub fn new(base_dir: &str) -> Self {
        Files {
            map: HashMap::default(),
            base_dir: base_dir.into(),
        }
    }

    /// Get relative file path
    ///
    /// If the modified filename path is './prod/test.randomhash.svg`, it will
    /// output `/test.randomhash.svg`. For full path, see [get_full_path]
    pub fn get<'a>(&'a self, path: &'a str) -> Option<&'a str> {
        if let Some(path) = self.map.get(path) {
            Some(&path[self.base_dir.len()..])
        } else {
            None
        }
    }

    /// Get file path
    ///
    /// If the modified filename path is './prod/test.randomhash.svg`, it will
    /// output `/prod/test.randomhash.svg`. For relative path, see [get]
    pub fn get_full_path<'a>(&'a self, path: &'a str) -> Option<&'a String> {
        self.map.get(path)
    }

    /// Create file map: map original path to modified paths
    pub fn add(&mut self, k: String, v: String) -> Result<(), &'static str> {
        if self.map.contains_key(&k) {
            Err("key exists")
        } else {
            self.map.insert(k, v);
            Ok(())
        }
    }

    /// This crate uses compile-time environment variables to transfer
    /// data to the main program. This funtction sets that variable
    pub fn to_env(&self) {
        println!(
            "cargo:rustc-env={}={}",
            ENV_VAR_NAME,
            serde_json::to_string(&self).unwrap()
        );

        // needed for testing load()
        // if the above statement fails(println), then something's broken
        // with the rust compiler. So not really worried about that.
        #[cfg(test)]
        env::set_var(ENV_VAR_NAME, serde_json::to_string(&self).unwrap());
    }

    /// Load filemap in main program. Should be called from main program
    pub fn load() -> Self {
        let env = env::var(ENV_VAR_NAME)
            .expect("unable to read env var, might be a bug in lib. Please report on GitHub");
        let res: Files = serde_json::from_str(&env).unwrap();
        res
    }
}

#[cfg(test)]
mod tests {
    use crate::processor::tests::cleanup;
    use crate::processor::*;

    use super::*;
    use std::path::Path;

    #[test]
    fn get_full_path_works() {
        let types = vec![
            mime::IMAGE_PNG,
            mime::IMAGE_SVG,
            mime::IMAGE_JPEG,
            mime::IMAGE_GIF,
        ];

        let config = BusterBuilder::default()
            .source("./dist")
            .result("/tmp/prod2")
            .mime_types(types)
            .copy(true)
            .follow_links(true)
            .build()
            .unwrap();

        let files = config.process().unwrap();

        assert!(get_full_path_runner("./dist/log-out.svg", &files));
        assert!(get_full_path_runner(
            "./dist/a/b/c/d/s/d/svg/credit-card.svg",
            &files
        ));

        assert!(!get_full_path_runner("dist/log-out.svg", &files));
        assert!(!get_full_path_runner(
            "dist/a/b/c/d/s/d/svg/credit-card.svg",
            &files
        ));
        cleanup(&config);
    }

    fn get_full_path_runner(path: &str, files: &Files) -> bool {
        if let Some(file) = files.get_full_path(path) {
            Path::new(file).exists()
        } else {
            false
        }
    }

    #[test]
    fn load_works() {
        let types = vec![
            mime::IMAGE_PNG,
            mime::IMAGE_SVG,
            mime::IMAGE_JPEG,
            mime::IMAGE_GIF,
        ];

        let config = BusterBuilder::default()
            .source("./dist")
            .result("/tmp/prod3")
            .mime_types(types)
            .copy(true)
            .follow_links(true)
            .build()
            .unwrap();

        let files = config.process().unwrap();

        files.to_env();

        let x = Files::load();

        assert_eq!(files, x);

        cleanup(&config);
    }

    #[test]
    fn get_works() {
        let types = vec![
            mime::IMAGE_PNG,
            mime::IMAGE_SVG,
            mime::IMAGE_JPEG,
            mime::IMAGE_GIF,
        ];

        let config = BusterBuilder::default()
            .source("./dist")
            .result("/tmp/prod5")
            .mime_types(types)
            .copy(true)
            .follow_links(true)
            .build()
            .unwrap();

        let files = config.process().unwrap();

        assert!(get_runner("./dist/log-out.svg", &files));
        assert!(get_runner("./dist/a/b/c/d/s/d/svg/credit-card.svg", &files));

        assert!(!get_runner("dist/log-out.svg", &files));
        assert!(!get_runner("dist/a/b/c/d/s/d/svg/credit-card.svg", &files));
        cleanup(&config);
    }

    fn get_runner(path: &str, files: &Files) -> bool {
        if let Some(file) = files.get(path) {
            let path = Path::new(&files.base_dir).join(&file[1..]);
            path.exists()
        } else {
            false
        }
    }
}