use serde::Deserialize;
use std::{fs, path::PathBuf};

use glob::glob;
use minify_html::{minify, Cfg};
use std::{fs::File, io::Write, path::Path};

use crate::template::Template;

/// Store the configuration of config/config.toml
#[derive(Deserialize, Clone, Default)]
pub struct FileConfig {
    /// http/https
    pub scheme: Option<String>,
    /// Port used
    pub port: Option<u16>,
    /// Mail of owner
    pub mail: Option<String>,
    /// Lang used
    pub lang: Option<String>,
    /// Adress .onion for Tor
    pub onion: Option<String>,
    /// App name
    pub app_name: Option<String>,
}

impl FileConfig {
    /// Initialize with default values
    fn new() -> Self {
        Self {
            scheme: Some("http".to_owned()),
            port: Some(8080),
            app_name: Some("EWP".to_owned()),
            ..FileConfig::default()
        }
    }

    /// Complete default structure with an existing one
    fn complete(a: Self) -> Self {
        // Default config
        let d = FileConfig::new();

        /// Return the default value if nothing is value is none
        fn test<T>(val: Option<T>, default: Option<T>) -> Option<T> {
            if val.is_some() {
                val
            } else {
                default
            }
        }

        Self {
            scheme: test(a.scheme, d.scheme),
            port: test(a.port, d.port),
            mail: test(a.mail, d.mail),
            lang: test(a.lang, d.lang),
            onion: test(a.onion, d.onion),
            app_name: test(a.app_name, d.app_name),
        }
    }
}

/// Configuration used internally in the app
#[derive(Clone)]
pub struct Config {
    /// Information given in the config file
    pub fc: FileConfig,
    /// Location where the static files are stored
    pub static_location: String,
    /// Informations about templates
    pub tmpl: Template,
}

/// Load the config file
fn get_file_config(file_path: &str) -> FileConfig {
    match fs::read_to_string(file_path) {
        Ok(file) => match toml::from_str(&file) {
            Ok(stored_config) => FileConfig::complete(stored_config),
            Err(file_error) => {
                panic!("Error in config file: {file_error}");
            }
        },
        Err(_) => {
            // No config file
            FileConfig::new()
        }
    }
}

/// Build the configuration
pub fn get_config(file_path: &str) -> Config {
    let internal_config = get_file_config(file_path);

    let static_dir = "static".to_owned();
    let templates_dir = "templates".to_owned();
    let files_root = init("dist".to_owned(), static_dir.clone(), templates_dir.clone());

    Config {
        fc: internal_config.clone(),
        static_location: format!("{}/{}", files_root, static_dir),
        tmpl: Template {
            directory: format!("{}/{}", files_root, templates_dir),
            app_name: internal_config.app_name.unwrap(),
        },
    }
}

/// Preparation before running the http server
fn init(dist_dir: String, static_dir: String, templates_dir: String) -> String {
    // The static folder is minimized only in release mode
    if cfg!(debug_assertions) {
        ".".to_owned()
    } else {
        let cfg = Cfg {
            keep_closing_tags: true,
            minify_css: true,
            minify_js: true,
            ..Cfg::spec_compliant()
        };

        // Static files
        for entry in glob(&format!("{static_dir}/**/*.*")).unwrap() {
            let path = entry.unwrap();
            let path_with_dist = path
                .to_string_lossy()
                .replace(&static_dir, &format!("{dist_dir}/{static_dir}"));

            minify_and_copy(&cfg, path, path_with_dist);
        }

        // Template files
        for entry in glob(&format!("{templates_dir}/**/*.*")).unwrap() {
            let path = entry.unwrap();
            let path_with_dist = path
                .to_string_lossy()
                .replace(&templates_dir, &format!("{dist_dir}/{templates_dir}"));

            minify_and_copy(&cfg, path, path_with_dist);
        }

        dist_dir
    }
}

/// Minify some assets for production
fn minify_and_copy(cfg: &Cfg, path: PathBuf, path_with_dist: String) {
    // Create folders
    let new_path = Path::new(&path_with_dist);
    fs::create_dir_all(new_path.parent().unwrap()).unwrap();

    let mut copy = true;
    if let Some(ext) = path.extension() {
        // List of files who should be minified
        if ["html", "css", "js", "svg", "webmanifest", "xml"]
            .iter()
            .any(|item| ext.to_string_lossy().to_lowercase().contains(item))
        {
            // We won't copy, we'll minify
            copy = false;

            // Minify
            let data = fs::read(&path).unwrap();
            let minified = minify(&data, cfg);

            // Write files
            let file = File::create(&path_with_dist);
            file.expect("Error when minify the file")
                .write_all(&minified)
                .unwrap();
        }
    }

    if copy {
        // If no minification is needed
        fs::copy(path, path_with_dist).unwrap();
    }
}