use crate::poem::{read::Readable, recite::Reciteable, Poem};
pub mod environment;
pub use environment::Environment;
use std::env;
use std::fs;
use std::path::PathBuf;

/// Setup the global shell environment
///
/// Sets up the shell's environment via configuration files. In order:
/// * `/etc/dwvshrc`
/// * `~/.dwvshrc`
///
/// For debug builds, all files will instead be sourced from
/// `./dist/...` with the exception of `~/.dwvshrc`.
pub fn env() -> Environment {
    // Create a new Environment object, to store some extra shell info
    let mut env = Environment::new();

    // Try to get paths for default run command file locations
    let paths = vec![
        // -> ./dist/etc/dwvshrc
        // -> /etc/dwvshrc
        if cfg!(debug_assertions) {
            let mut base = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
            base.push("dist/etc/dwvshrc");
            Some(base)
        } else {
            Some(PathBuf::from("/etc/dwvshrc"))
        },
        // -> ./dist/etc/linuxrc
        // -> /etc/dwvshrc
        if cfg!(debug_assertions) && std::env::consts::OS == "linux" {
            let mut base = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
            base.push("dist/etc/linuxrc");
            Some(base)
        } else {
            None
        },
        // -> $HOME/.dwvshrc
        match env::var("HOME") {
            Ok(home) => {
                let mut base = PathBuf::from(home);
                base.push(".dwvshrc");
                Some(base)
            }
            Err(_) => None,
        },
    ];

    // Read, read, and recite
    rrr(paths, &mut env);

    // Return the new environment
    env
}

/// Read, read, and recite
///
/// Small, reusable function used to do the heavy lifting in regards to
/// sourcing configuration files. [Read][fs::read_to_string]s a file
/// from disk, then [read][crate::poem::read]s (parses) a [Poem],
/// then [recite][crate::poem::recite]s that [Poem].
/// Configuration files are just shell scripts.
fn rrr(paths: Vec<Option<PathBuf>>, env: &mut Environment) {
    for path in paths {
        let path = match path {
            Some(path) => path,
            None => continue,
        };

        let poetry = match fs::read_to_string(&path) {
            Ok(poetry) => poetry,
            Err(_) => continue,
        };

        let poem = match Poem::read(poetry, &mut Environment::new()) {
            Ok(poem) => poem,
            Err(e) => {
                eprintln!(
                    "dwvsh: error in {}: {}",
                    path.display(),
                    e.to_string().to_lowercase()
                );
                continue;
            }
        };

        match poem.recite(env) {
            Ok(_) => {}
            Err(e) => {
                eprintln!("dwvsh: {}", e.to_string().to_lowercase());
                continue;
            }
        }
    }
}