stanhope/

main.rs

#![doc(html_logo_url = "https://images.squarespace-cdn.com/content/v1/60416644b68a5453a868e856/1628206791960-M61IU1QP850NRLI9CE07/Stanhope+Etching.jpg?format=2500w")]
//! **Stanhope**, named after the Stanhope Printing Press that improved upon Gutenberg's design by using sturdy iron and steel parts and hand levers to increase printing speed and quality.
//! 
//! This application takes an input argument file in a specific markup and produces a static, printable HTML page based on the markup file's contents.
//! 
//! The real power in this application is the markup language, which has these features:
//! * Single-purpose: just for writing processes that can be printed as documents
//! * General: suitable for writing any process
//! * Consistent: output branding and style is centrally controlled for 100% consistent processes in an organization's library
//! * *Visually* flexible: custom templates can mold the look/feel of the HTML produced
//! * *Format* rigid: we want process authors to think carefully to help operators in the field, and Stanhope forces authors to conform to pre-thought out process language and structure that solves this

mod read_csv;
mod read_xlsx;
mod read_ebml;
mod write_ebml;
mod write_html;
mod write_script;
mod write_webmenu;

//use std::process::Command; // needed for current implementation of PDF generation
use std::{
    process::Command,
    //fs::{self, File},
    //io::{self, BufRead, BufReader},
    fs::{self},
    io::{self, Error, ErrorKind, Result},
    path::Path,
};
use chrono::prelude::*;
use read_ebml::Process;

use clap::Parser; // used for command line parameters and --help generation
use read_csv::read_csv; // 
use read_xlsx::read_xlsx;
use write_ebml::get_process_folder_name;
use write_ebml::write_ebml;
use read_ebml::read_ebml;
use crate::read_ebml::SubStep;
use write_html::generate_complete_html;
use write_webmenu::generate_complete_webmenu;
use glob::glob;

/// Command Line Interface (CLI) argument structure
#[derive(Parser, Debug)]
#[command(version, about =
"\n\n\x1b[1;30;47mStanope\x1b[0m\x1b[30;47m, the Easy Button process generation engine.\x1b[0m

Arguments passed into the options should be surrounded by single or double quotes, e.g.
% ./stanhope -p \"EB-WI-0010\"    \x1b[36m<< double quotes are accepted\x1b[0m
% ./stanhope -a 'EB-WI-*'       \x1b[36m<< single quotes are accepted\x1b[0m",
author = "Strativus Group <contact@strativusgroup.com>",
long_about = None,
after_help = 
"
")]
struct StanhopeArgs {
    /// Read a spreadsheet (Excel or CSV) to pre-populate a process library
    /// 
    /// - SPREADSHEET-FILE
    ///   - Excel (.xlsx) or Comma-separated text file that strictly conforms to the template below
    ///   - Exception: _TFlag_ columns (7th column and beyond) are user-defined
    ///   - Free Excel file to use as a template: <https://stanhope.strativusgroup.com/latest/DocumentList.xlsx>
    /// 
    /// | "Document Number" | "Title" | "Subject" | "Product" | "Author" | "Reviewer" | _TFlag_ | _TFlag_ | ... |
    /// | ----------------- | ------- | --------- | --------- | -------- | ---------- | ------- | ------- | --- |
    /// | ...               | ...     | ...       | ...       | ...      | ...        |    x    |         | ... |
    /// | ...               | ...     | ...       | ...       | ...      | ...        |         |    x    | ... |
    /// | ...               | ...     | ...       | ...       | ...      | ...        |         |         | ... |
    /// | ...               | ...     | ...       | ...       | ...      | ...        |    x    |    x    | ... |
    #[arg(short, long, value_name = "SPREADSHEET-FILE", default_value_t = String::from(""), verbatim_doc_comment)]
    listgen: String,

    /// Generate (or overwrite) a menu that indexes useful information for every process in a library
    /// 
    /// WebMenu.html is generated in the Process Library root folder
    #[arg(short, long, default_value_t = false, verbatim_doc_comment)]
    webmenu: bool,

    /// Report missing graphics in the library, or (verbose) report all graphics, indicating missing ones
    /// 
    /// The report is printed to stdout
    #[arg(short, long, default_value_t = false, verbatim_doc_comment)]
    graphics_audit: bool,

    /// Report naming discrepancies in the library among {folder, EBML file, Document Number + Title}
    /// 
    /// The report is printed to stdout
    #[arg(short, long, default_value_t = false, verbatim_doc_comment)]
    filename_audit: bool,

    /// Report how well the entire library is portion-marked.
    /// 
    /// Portion-marking checks assume EBML lines start with a parenthetical code, e.g. (XYZ)
    /// Everything is checked: the file name, number, title, sections, steps, substeps...
    /// 
    /// The report is printed to stdout
    #[arg(short, long, default_value_t = false, verbatim_doc_comment)]
    marking_audit: bool,

    /// Read a single EBML and produce an HTML file as well as a PDF of that process
    /// 
    /// - DOCUMENT-NUMBER should be surrounded by quotes, particularly if wildcards are used
    ///   - Wildcards are accepted, e.g. *, ?, [0-9]
    ///   - Wildcards follow "glob" formatting: <https://docs.rs/glob/0.3.3/glob/struct.Pattern.html>
    #[arg(short, long, value_name = "DOCUMENT-NUMBER", default_value_t = String::from(""), verbatim_doc_comment)]
    process_ebml: String,

    /// Export every "Command" line from a single process into a script with a defined language/format
    /// 
    /// - DOCUMENT-NUMBER should be surrounded by quotes, particularly if wildcards are used
    /// - SCRIPT-FORMAT currently accepts
    ///     ActionScript, AppleScript, bash, CoffeeScript, Dart,
    ///     Elixir, JavaScript, Julia, Lua, MATLAB, Perl, PHP,
    ///     PowerShell, Python, R, Ruby, TypeScript, VB.NET
    ///         Full list and backlog:  <https://stanhope.strativusgroup.com/doc/stanhope/write_script/fn.learn.html>
    /// - PAUSE-AFTER-EACH is true or false, true meaning "pause after each command"
    #[arg(short, long, use_value_delimiter = true, value_delimiter = ' ', num_args = 3, value_names = ["DOCUMENT-NUMBER","SCRIPT-FORMAT","PAUSE-AFTER-EACH"], verbatim_doc_comment)] 
    scriptify_process: Vec<String>,

    /// Only perform the archiving process, i.e. create a new archive in "previous"
    /// 
    /// Note: this operation is performed at the end of every "Process EBML" action
    /// This option _only_ performs the archiving, not the processing.
    /// - DOCUMENT-NUMBER should be surrounded by quotes, particularly if wildcards are used
    ///   - Wildcards are accepted, e.g. *, ?, [0-9]
    ///   - Wildcards follow "glob" formatting: <https://docs.rs/glob/0.3.3/glob/struct.Pattern.html>
    #[arg(short, long, value_name = "DOCUMENT-NUMBER", default_value_t = String::from(""), verbatim_doc_comment)]
    archive_process: String,

    /// Inspect a document by reading its EBML and returning information (no file generation)
    /// 
    /// - DOCUMENT-NUMBER should be surrounded by quotes, particularly if wildcards are used
    ///   - Wildcards are accepted, e.g. *, ?, [0-9]
    ///   - Wildcards follow "glob" formatting: <https://docs.rs/glob/0.3.3/glob/struct.Pattern.html>
    #[arg(short, long, value_name = "DOCUMENT-NUMBER", default_value_t = String::from(""), verbatim_doc_comment)]
    inspect_process: String,

    /// Delete all but one "previous" version for each Revision for a given process
    /// 
    ///   For example, for a document that has many "previous" copies across four
    ///   Revisions (-,A,B,C), then this option deletes all subdirectories except
    ///   four: the one with the latest timestamp for each Revision variant
    #[arg(short, long, value_name = "DOCUMENT-NUMBER", default_value_t = String::from(""), verbatim_doc_comment)]
    cleanup_previous: String,

    /// Output more information to stdout as Stanhope executes (flag)
    #[arg(short, long, default_value_t = false,)]
    verbose: bool,

    /// Display syntax help for Easy Button Markup Language (EBML)
    #[arg(short, long, default_value_t = false,)]
    ebml_help: bool,
}

/// Recursive copy of all contents in one folder to another
fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
    fs::create_dir_all(&dst)?;
    for entry in fs::read_dir(src)? {
        let entry = entry?;
        let ty = entry.file_type()?;
        if ty.is_dir() {
            copy_dir_all(entry.path(), dst.as_ref().join(entry.file_name()))?;
        } else {
            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
        }
    }
    Ok(())
}

/// Copy everything that ISN'T a directory... just the files
fn copy_files_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
    fs::create_dir_all(&dst)?;
    for entry in fs::read_dir(src)? {
        let entry = entry?;
        let ty = entry.file_type()?;
        if ty.is_dir() {
            ();
        } else {
            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
        }
    }
    Ok(())
}

/// Perform OS functions to stash a copy of all working material for a process
fn archive_single_process(new_proc: Process, verbose: &bool) {
    // if it doesn't already exist, make a new folder called "previous"
    //let previous_folder = new_proc.get_number().to_string()+"/previous"; // Old convention: process number is the process folder name. Now it's ( NUMBER - TITLE )
    let previous_folder = get_process_folder_name(&new_proc).to_owned() + "/previous";
    match Path::new(&previous_folder).exists() {
        true => (),
        false => { let _ = fs::create_dir(&previous_folder); },
    };
    let root_assets_folder = "./assets";
    let previous_assets_folder = previous_folder.clone() + "/assets";
    match Path::new(&previous_assets_folder).exists() {
        true => (),
        false => { let _ = fs::create_dir(&previous_assets_folder); },
    };

    // make a new folder to archive everything we just did in "previous"
    let rev_string = new_proc.get_revision();
    let right_now_string = Utc::now().format("UTC-%Y-%m-%d-T%H-%M-%S").to_string();
    let timestamp_folder = previous_folder.clone() + "/Rev_" + new_proc.get_revision() + "_" + &right_now_string;
    if *verbose { 
        println!("Revision: {}",&rev_string);
        println!("SystemTime::now() ...ish: {}",right_now_string);
        println!("Trying to create this folder: {:?}",timestamp_folder);
    }
    let _ = fs::create_dir(&timestamp_folder);
    // copy assets
    let _ = copy_dir_all(root_assets_folder,previous_assets_folder);
    // copy EBML, HTML, and PDF plus any other non-folder files in the process directory
    let _ = copy_files_all(get_process_folder_name(&new_proc),timestamp_folder.clone());
}

/// File management: return a vector of directories eligible to delete as a "cleanup" operation
/// 
/// Eligibility criterion: any directory that *isn't* the most recent for its revision.
/// 
/// Example: If the contents of "previous" is the following list of directories:
/// 1. Rev_-_UTC-2025-01-01-T00-00-00
/// 1. Rev_-_UTC-2025-01-01-T00-00-01
/// 1. Rev_A_UTC-2025-01-01-T00-05-00
/// 
/// The only eligible directory for deletion would be #1, because #2 is the latest Rev -, and #3 is the latest (only) Rev A.
fn list_directories_to_cleanup(prev:String) -> Vec<String> {

    let mut all_revs:Vec<String> = vec![];
    let mut directories_to_cleanup:Vec<String> = vec![];
    let all_archives = glob(&(prev.clone() + "/Rev_*_UTC-*-*-*-T*-*-*")).expect("Failed to read glob pattern");

    for entry in all_archives {
        match entry {
            Ok(path) => {
                let archive = path.file_name().expect("huh?").to_str().expect("huh?");
                let pos = archive.find("_UTC-").expect("rust is hard");
                let rev = String::from(&archive[4..pos]); 
                all_revs.push(rev);
            },
            Err(e) => println!("{:?}",e),
        }
    }

    all_revs.dedup();
    println!("For this process, these are all the revisions: {:?}",&all_revs);

    for rev in all_revs {
        println!("\nHere are all of the archive folders for Rev {}:",rev);
        let these = glob(&(prev.clone() + "/Rev_" + &rev + "_UTC-*-*-*-T*-*-*")).expect("Failed to read glob pattern");
        let mut vec:Vec<String> = vec![];
        for this in these {
            match this {
                Ok(path) => vec.push(path.file_name().expect("huh?").to_str().expect("huh?").to_string()),
                Err(e) => println!("{:?}",e),    
            }
        }
        vec.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
        let keeper = vec.pop().expect("pop?");
        for d in &vec {
            println!("      {} \x1b[93mDELETE\x1b[0m",&d);
        }
        println!("   💾 {} 💾  << only one to be saved...",&keeper);
        directories_to_cleanup.append(&mut vec);
    }
    directories_to_cleanup
}

/// Accept wildcard statements describing a subset of process folders, and return all matches
pub fn globify_document_number(input:&String) -> Vec<String> {
    let all_results = match input.chars().last().unwrap() {
        '*' => glob(&(input.to_owned())).expect("Failed to read glob pattern"),
        _ => glob(&(input.to_owned()+"*")).expect("Failed to read glob pattern"),
    };
    let mut matching_process_folders:Vec<String> = vec![];

    for entry in all_results {
        match entry {
            Ok(path) => {
                let process_folder = path.file_name().expect("huh?").to_str().expect("huh?");
                matching_process_folders.push(String::from(process_folder));
            },
            Err(e) => println!("{:?}",e),
        }
    }
    matching_process_folders
}

/// Gracefully cycle through ordered OS commands until one of them works
fn attempt_fallbacks(fallbacks: Vec<Box<dyn Fn() -> Result<i32>>>) -> Result<i32> {
    let mut last_error = None;

    for fallback in fallbacks {
        match fallback() {
            Ok(value) => return Ok(value),
            Err(e) => {
                println!("Call failed, trying next... (Error: {})", e);
                last_error = Some(e);
            }
        }
    }

    Err(last_error.unwrap_or_else(|| Error::new(ErrorKind::Other, "No fallbacks provided")))
}

/// Look into each process folder, read the EBML, find the images, and check to see if they exist, print findings to stdout
/// 
/// This function finds all images that the EBML will use in its HTML output when processed:
/// - "Image" lines in the EBML
/// - "Image" lines in followed "Section Reference" links to other processes
/// - "Subject Image" line
/// - "Product Image" line
/// 
/// Verbose version lists all images, not just the missing ones
fn print_graphics_audit_to_stdout(v:&bool) {
    let list_of_process_folders = write_webmenu::find_all_process_folders(".");
    //println!("{:?}",list_of_process_folders);
    print_title_block_to_stdout("Library Graphics Audit");
    for folder in list_of_process_folders {
        let folder_string = folder.file_name().expect("No bueno?").to_str().expect("Really bueno?").to_string();
        let new_ebml_str = folder_string.clone() + "/" + &folder_string + ".ebml";
        let new_process = read_ebml(&("./".to_owned()+&new_ebml_str));

        if new_process.get_missing_image_count() == 0 {
            println!(" [ No missing images! ]    {}",&folder_string);
        } else {
            println!(" ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒    {}",&folder_string);
        }
        if new_process.get_missing_image_count() > 0 {
            println!("            ▒▒▒▒▒▒▒▒▒▒▒      -> Missing Images");
            for image in new_process.get_missing_images() {
            println!("               ▒▒▒▒▒▒▒▒        {}",image);
            }
        }
        if *v {
            if new_process.get_all_images().len() > 0 {
                println!("                             -> All Images");
                for image in new_process.get_all_images() {
                    println!("                               {}",image.0);
                } 
            } else { println!("                             -> No images at all, in fact..."); }
        }
    }
}

/// Look into each process folder, read the EBML, find the Number and Title, check consistency, print findings to stdout
/// 
/// The fundamental assumption is that stanhope will find any given EBML file in this location:
/// ./<DOCUMENT NUMBER> - <DOCUMENT TITLE>/<DOCUMENT NUMBER> - <DOCUMENT TITLE>.ebml
/// 
/// That is,
/// - a process's folder is named "<DOCUMENT NUMBER> - <DOCUMENT TITLE>"
/// - the EBML file is named "<DOCUMENT NUMBER> - <DOCUMENT TITLE>.ebml"
/// 
/// This function attempts to traverse the library, checking these assumptions as it goes, and printing to stdout
/// 
/// Verbose version lists all diagnostic information about every process, not just the issues it finds
fn print_filename_audit_to_stdout(v:&bool) {
    let list_of_process_folders = write_webmenu::find_all_process_folders(".");
    print_title_block_to_stdout("Library Filename Audit");
    for folder in list_of_process_folders {
        let expected_folder_string = folder.file_name().expect("No bueno?").to_str().expect("Really bueno?").to_string();
        let expected_ebml_str = expected_folder_string.clone() + "/" + &expected_folder_string + ".ebml";
        println!("{}→ {}",if *v {"\n"}else{""},expected_folder_string);
        match Path::new(&expected_ebml_str).exists() {
            true => {
                if *v { println!(" ↳ {}",expected_ebml_str); }
                let new_proc = read_ebml(&("./".to_owned()+&expected_ebml_str));
                if *v { println!(" ↳ EBML file exists as named above."); }
                if *v { println!("   ↳ EBML Contents 'Number' : {}",new_proc.get_number()); }
                if *v { println!("   ↳ EBML Contents 'Title'  : {}",new_proc.get_title()); }
                if expected_folder_string == (new_proc.get_number().to_owned() + " - " + new_proc.get_title()).to_string() {
                    if *v { println!(" ↳ CLEAN AUDIT: EBML CONTENTS MATCH FOLDER AND FILE NAMES"); }
                } else {
                    println!(" ↳ \x1b[31mWARNING: SOMETHING IS MISMATCHED BETWEEN FOLDER NAME, FILE NAME, AND EBML CONTENTS\x1b[0m");
                    println!(" ↳ \x1b[33mSpecial characters in EBML title converted to '_' in folder/file names might be OK\x1b[0m");
                }
            },
            false => {
                println!(" ↳ \x1b[31m{}\x1b[0m",expected_ebml_str);
                println!(" ↳ \x1b[31mWARNING: LIKELY FOLDER NAME MISMATCH WITH EBML NAME\x1b[0m");
            },
        };
    }
}

/// Look into each process folder, read the EBML as well as the HTML!
/// 
/// The function tries to understand how a process is portion-marked, and report results
/// 
/// Verbose version lists all diagnostic information about every process, not just the issues it finds
fn print_marking_audit_to_stdout(v:&bool) {
    let list_of_process_folders = write_webmenu::find_all_process_folders(".");
    print_title_block_to_stdout("(Portion) Marking Audit");

    println!("{} folders...",list_of_process_folders.len());
    
    for folder in list_of_process_folders {
        if *v {print!("\n================================================================================");}
        let mut numer:u16 = 0;
        let mut denom:u16 = 0;

        let folder_string = folder.file_name().expect("No bueno?").to_str().expect("Really bueno?").to_string();

        let new_ebml_str = folder_string.clone() + "/" + &folder_string + ".ebml";
        let new_process = read_ebml(&("./".to_owned()+&new_ebml_str));

        let classification_header = get_classification_header(new_process.get_all_templates());

        print!("\n");
        println!("{}",&folder_string);
        println!("\x1b[1;37;44m{}\x1b[0m",classification_header);
        
        (numer,denom) = tally_portion_marking_check(&folder_string,numer,denom,&true);

        //(numer,denom) = tally_portion_marking_check(new_process.get_process_file(),numer,denom,v);
        (numer,denom) = tally_portion_marking_check(new_process.get_title(),numer,denom,v);
        (numer,denom) = tally_portion_marking_check(new_process.get_subject(),numer,denom,v);
        (numer,denom) = tally_portion_marking_check(new_process.get_product(),numer,denom,v);
        for rev in new_process.get_all_revisions() {
            (numer,denom) = tally_portion_marking_check(&rev.1,numer,denom,v);
        }
        for sec in new_process.get_all_sections() {
            (numer,denom) = tally_portion_marking_check(&sec.get_title(),numer,denom,v);
            for stp in sec.get_all_steps() {
                (numer,denom) = tally_portion_marking_check(&stp.get_text(),numer,denom,v);
                for sub in stp.get_all_sub_steps() {
                    match sub {
                        SubStep::Objective(s)      => (numer,denom) = tally_portion_marking_check(&s,numer,denom,v),
                        SubStep::OutOfScope(s)     => (numer,denom) = tally_portion_marking_check(&s,numer,denom,v),
                        SubStep::ActionSequence(vec) => for a in vec {
                            (numer,denom) = tally_portion_marking_check(a.get_perform(),numer,denom,v);
                            (numer,denom) = tally_portion_marking_check(a.get_expect(),numer,denom,v);
                        },
                        SubStep::Command(_)        => (),
                        SubStep::Image(_,s)        => (numer,denom) = tally_portion_marking_check(&s,numer,denom,v),
                        SubStep::Warning(s)        => (numer,denom) = tally_portion_marking_check(&s,numer,denom,v),
                        SubStep::Verification(r)   => (numer,denom) = tally_portion_marking_check(r.get_text(),numer,denom,v),
                        SubStep::Resource(r)       => (numer,denom) = tally_portion_marking_check(r.get_name(),numer,denom,v),
                        SubStep::Context(s)        => (numer,denom) = tally_portion_marking_check(&s,numer,denom,v),
                        SubStep::Table(t)          => (numer,denom) = tally_portion_marking_check(t.get_caption(),numer,denom,v),
                    };
                }
            }
        }
        println!("📗 Properly Portion-Marked: {:4}",numer);
        println!("📕 Total lines checked:     {:4}",denom);
        println!("📚 Success percentage:      {:4.0}%",(f32::from(numer)/f32::from(denom)*100.0));
    }

    /// For a [Process]'s list of applied templates, this function predicts what will be displayed in the classification header
    /// 
    /// Assumptions:
    /// - the base CSS file is "assets/stanhope.css"
    /// - the input Vec<String> is a return value from Process::get_all_templates()
    /// - template strings correspond to files in "assets/TEMPLATE.css"
    fn get_classification_header(v:&Vec<String>) -> String {
        let mut classy:String; // temporary value of whatever the subfunction finds
        let mut classification:String = String::from("UNKNOWN, OR NOT FOUND ANYWHERE..."); // The actual thing we'll return
        let mut success:bool;

        // First thing: check assets/stanhope.css (the base CSS file)
        (classy,success) = get_header_from_css_file("assets/stanhope.css");
        // When we call this funciton, we'll commit the temp value only if it was actually found (success) vs. default return
        if success { classification = classy; }

        // Now we'll read the Process struct itself to get all of the different templates applied (each is an assets/*.css file)
        for template in v {
            (classy,success) = get_header_from_css_file(&("assets/".to_owned()+template));
            if success { classification = classy; }
        }
        return classification;
        // Note: we know that stanhope.css applies "UNCLASSIFIED" so classification should never be returned with the default above...
    }

    
    fn get_header_from_css_file(f:&str) -> (String,bool) {
        use std::fs::File;
        use std::io::{BufRead, BufReader};
        
        let mut header:String = String::from("UNKNOWN, OR NOT FOUND ANYWHERE...");
        let mut success:bool = false;

        //println!("Trying '{}'...",f);
        //print!("Trying '{}' ... ",f);
        match Path::new(f).exists() {
            true => {
                //print!("found file ... ");
                let file = File::open(f).unwrap();
                let reader = BufReader::new(file);
                let mut flag:bool = false;

                for line in reader.lines() {
                    let line = line.unwrap(); // Unwrap the Result for each line

                    match flag {
                        true => {
                            if line.contains("content:") {
                                //print!("found the right text!");
                                if line.contains("'") {
                                    header = line.split("'").nth(1).expect("?").to_string();
                                    success = true;
                                } else if line.contains('\"') {
                                    header = line.split('\"').nth(1).expect("?").to_string();
                                    success = true;
                                }
                            }
                            flag = false;
                        },
                        false => {
                            if line.contains(".classification p::before") {
                                flag = true;
                                if line.contains("content:") {
                                    //print!("found the right text!");
                                    if line.contains("'") {
                                        header = line.split("'").nth(1).expect("?").to_string();
                                        success = true;
                                    } else if line.contains('\"') {
                                        header = line.split('\"').nth(1).expect("?").to_string();
                                        success = true;
                                    }
                                    flag = false;
                                }
                            }
                        },
                    }
                }

                if !success {
                    //print!("text pattern not found in this file.");
                }
            },
            false => (),//print!("file not found!"),
        };
        //print!("\n");
        return (header,success)
    }

    fn tally_portion_marking_check(s:&str,mut n:u16,mut d:u16,v:&bool) -> (u16,u16) {
        d = d + 1;
        if s.len() == 0 || probably_portion_marked(s) {
            n = n + 1;
            if *v {
                println!("✅ {}",s.trim());
            }
        } else {
            if *v {
                println!("❌ {}",s.trim());
            }
        }
        return (n,d);
    }

    fn probably_portion_marked(s:&str) -> bool {
        s.trim().starts_with('(') && s.contains(')')
    }

    // Summary statistics
}

/// Utility function to print a box outline around text in stdout, perhaps for a title
/// 
/// Example for "Beep Boop"
/// ╭───────────╮
/// │ Beep Boop │
/// ╰───────────╯
fn print_title_block_to_stdout(s:&str) {
    let to_print = s.trim();
    print!("╭─"); print!("{:─<1$}", "", to_print.len()); print!("─╮\n");
    print!("│ "); print!("{}",&to_print); print!(" │\n");
    print!("╰─"); print!("{:─<1$}", "", to_print.len());print!("─╯\n");
}

/// Run Stanhope in one of (or more!) of its modes
/// 
/// _Examples:_
/// >    stanhope -vl "DocumentList.csv"
/// >    stanhope --verbose --listgen "DocumentList.csv"
/// >    stanhope -w
/// >    stanhope --webmenu
/// >    stanhope -vp "EB-WI-00*"
/// >    stanhope --verbose --process-ebml "EB-WI-00*"
/// >    stanhope -vs "EB-WI-0?00"
/// >    stanhope --verbose --scriptify-process "EB-WI-0?00"
fn main() {

    let args = StanhopeArgs::parse();

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified a Spreadsheet file to import, then process it appropriately 
    if !(&args.listgen=="") {

        let Some((_, last_part)) = &args.listgen.rsplit_once('.') else { todo!() };
        let needed_processes_list = match *last_part {
            "csv" => {
                // Read each line of the CSV file
                read_csv(&args.listgen,args.verbose.clone())
                
            },
            "xlsx" => {
                // Read each line of the Excel file
                read_xlsx(&args.listgen,args.verbose.clone())
            },
            _ => {
                vec!(Process::new())
            },
        };

        if args.verbose { println!("Stanhope found {} EBML files to create in the spreadsheet.",needed_processes_list.len()); }
        
        // Write to new files
        for new_proc_to_create in needed_processes_list {
            if args.verbose { new_proc_to_create.display_process_to_stdout() };
            write_ebml(&new_proc_to_create,args.verbose.clone());
        }

    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified a single process to "scriptify" along with a scripting format
    if !(args.scriptify_process.len()==0) {
        // First, we'll allow wildcards and look into every matching Document Number
        let matching_processes = globify_document_number(&args.scriptify_process[0]);
        if args.verbose { println!("{:?}",&matching_processes) };

        if matching_processes.len() > 0 {

            for process in matching_processes {


                let file_to_read = "./".to_owned() + &process + "/" + &process + ".ebml";

                if args.verbose {
                    println!("");
                    println!("=== Stanhope Scriptification =========================================================");
                    println!("===");
                    println!("=== >> Process:          {}",&process);
                    println!("=== >> Script Format:    {}",&args.scriptify_process[1]);
                    println!("=== >> Pause after each? {}",&args.scriptify_process[2]);
                    println!("===");
                    println!("======================================================================================");
                    println!("");
                }
                
                if args.verbose { print!("[A] Attempting to read EBML -> {} ...",&file_to_read); }
                let new_proc = read_ebml(&file_to_read);
                if args.verbose { print!("success!\n"); }
                
                let all_commands = new_proc.get_all_command_lines();
                if args.verbose { print!("[B] Stanhope found {} lines of type \"Command\" in the file.\n",all_commands.len()); }

                if args.verbose { print!("[C] Processing script format \"{}\"\n",&args.scriptify_process[1]); }
                

                let wait:bool = match args.scriptify_process[2].to_uppercase().as_str() {
                    "F" | "FALSE" | "N" | "NO" => false,
                    _ => true,
                };
                write_script::script_file_from_process(new_proc,write_script::learn(&args.scriptify_process[1]),wait)

            } // End For loop through matching_processes
        }; // End conditional to check that more than zero processes are requested
    } // End Scriptify Process(es)

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified an EBML file, then convert it to HTML and subsequently PDF 
    if !(&args.process_ebml=="") {
        // First, we'll allow wildcards and look into every matching Document Number
        let matching_processes = globify_document_number(&args.process_ebml);
        if args.verbose { println!("{:?}",&matching_processes) };

        if matching_processes.len() > 0 {

            for process in matching_processes {

                let file_to_read = "./".to_owned() + &process + "/" + &process + ".ebml";
                if args.verbose { println!("Attempting to process this file: {}",&file_to_read) };

                let new_proc = read_ebml(&file_to_read);
                if args.verbose { new_proc.display_process_to_stdout() }; 

                // first, delete old html file, then generate a new one
                if args.verbose { println!("Attempting to delete old HTML file: {:?}",fs::remove_file(&file_to_read.replace(".ebml",".html"))); } else { let _ = fs::remove_file(&file_to_read.replace(".ebml",".html")); }
                
                generate_complete_html(&String::from(&file_to_read.replace(".ebml",".html")),&new_proc);

                //windows chrome
                let win_chrome_path = "& 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' --headless --no-pdf-header-footer --print-to-pdf=\"";
                let win_process_library = "$PWD\\";
                let win_chrome_string_to_throw = &(win_chrome_path.to_string() + win_process_library + &file_to_read.replace(".ebml",".pdf") + "\" \"" + win_process_library + &file_to_read.clone().replace(".ebml",".html\""));
                //posix chrome
                let posix_chrome = "chrome --headless --print-to-pdf=\"".to_string() + &file_to_read.clone().replace(".ebml",".pdf") + "\" \"" + &file_to_read.clone().replace(".ebml",".html") + "\" --no-pdf-header-footer";
                //posix chromium
                let posix_chromium = "chromium --headless --print-to-pdf=\"".to_string() + &file_to_read.clone().replace(".ebml",".pdf") + "\" \"" + &file_to_read.clone().replace(".ebml",".html") + "\" --no-pdf-header-footer";

                let _output = if cfg!(target_os = "windows") {

                    let mut fallbacks: Vec<Box<dyn Fn() -> Result<i32>>> = Vec::new();
                    fallbacks.push(Box::new(move || {
                        
                        if args.verbose { println!("Here's my command string to chrome:\n\n{}\n\n",win_chrome_string_to_throw); }
                        Command::new("powershell.exe")
                            .args(["-Command", win_chrome_string_to_throw])
                            .output()
                            .expect("failed to execute process");
                        
                        Err(Error::new(ErrorKind::Other, "Chrome call to OS attempted."))
                    }));

                } else {

                    // Create a sequence of commands to try
                    let mut fallbacks: Vec<Box<dyn Fn() -> Result<i32>>> = Vec::new();
                    fallbacks.push(Box::new(move || {
            
                        Command::new("sh")
                            .arg("-c")
                            .arg(&(posix_chrome))
                            .output()
                            .expect("failed to execute process");

                        Err(Error::new(ErrorKind::Other, "Chrome call to OS attempted."))
                    }));
                    fallbacks.push(Box::new(move || {
                        
                        Command::new("sh")
                            .arg("-c")
                            .arg(&(posix_chromium))
                            .output()
                            .expect("failed to execute process");
                        
                        Err(Error::new(ErrorKind::Other, "Chromium call to OS attempted."))
                    }));
                    let _result = attempt_fallbacks(fallbacks);
                    
                };

                archive_single_process(new_proc,&args.verbose);

            } // End For loop through matching_processes
        } // End If condition for length of matching_processes
    } // End PROCESS EBML

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified a single process to archive, just do the archiving
    if !(&args.archive_process=="") {
        // First, we'll allow wildcards and look into every matching Document Number
        let matching_processes = globify_document_number(&args.archive_process);
        if args.verbose { println!("{:?}",&matching_processes) };

        if matching_processes.len() > 0 {

            for process in matching_processes {

                let file_to_read = "./".to_owned() + &process + "/" + &process + ".ebml";

                let new_proc = read_ebml(&file_to_read);
                archive_single_process(new_proc,&args.verbose);
            }
        }
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified to clean up a single process
    if !(&args.cleanup_previous=="") {
        // First, we'll allow wildcards and look into every matching Document Number
        let matching_processes = globify_document_number(&args.cleanup_previous);
        if args.verbose { println!("{:?}",&matching_processes) };

        if matching_processes.len() > 0 {

            for process in matching_processes {

                let prevs = "./".to_owned() + &process + "/previous";

                let delete_these = list_directories_to_cleanup(prevs);

                for dir in delete_these {
                    println!("Attempting to delete {} ... ",&dir);
                    let delete_this = "./".to_owned() + &process + "/previous/" + &dir;
                    let _ = fs::remove_dir_all(delete_this);
                }
            }
        }
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user specified a single process to inspect
    if !(&args.inspect_process=="") {
        // First, we'll allow wildcards and look into every matching Document Number
        let matching_processes = globify_document_number(&args.inspect_process);
        if args.verbose { println!("{:?}",&matching_processes) };

        if matching_processes.len() > 0 {

            for process in matching_processes {

                let file_to_read = "./".to_owned() + &process + "/" + &process + ".ebml";

                let new_proc = read_ebml(&file_to_read);
                new_proc.display_process_to_stdout();
            }
        }
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user requested WebMenu generation
    if args.webmenu {
        generate_complete_webmenu(&args.verbose);
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user runs a graphics audit
    if args.graphics_audit {
        print_graphics_audit_to_stdout(&args.verbose);
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user requested Filename Audit generation
    if args.filename_audit {
        print_filename_audit_to_stdout(&args.verbose);
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user requested (Portion) Marking Audit generation
    if args.marking_audit {
        print_marking_audit_to_stdout(&args.verbose);
    }

    // /////////////////////////////////////////////////////////////////////////////////////////////
    // If user requested EBML help, show some text to stdout
    if args.ebml_help {
        println!("{}",format!("

Note: Process files passed into --process-ebml are specifically-formatted EBML files (Easy Button Markup Language).

\x1b[36m
=================================================
==   Easy Button Markup Language Cheat Sheet   ==
==                                             ==
==  Everything below this block is valid EBML  ==
=================================================
\x1b[0m

// <COMMENT>
Template | <CSS FILENAME FOUND IN ASSETS FOLDER>

Title        | <PROCESS TITLE>
Number       | <PROCESS NUMBER>
Author       | <PROCESS AUTHOR>
Reviewer     | <PROCESS REVIEWER>
Process Type | <CATEGORY>, e.g. Test Procedure

Subject       | <THING TO WHICH THE PROCESS APPLIES> 
Subject Image | <FILENAME OF IMAGE OF SUBJECT>
Product       | <THING PRODUCED BY THIS PROCESS> - optional
Product Image | <FILENAME OF IMAGE OF PRODUCT> - optional

Revision | <LATEST REV NUM>       | <DESCRIPTION OF CHANGE>
Revision | <INTERMEDIATE REV NUM> | <DESCRIPTION OF CHANGE>
Revision | <FIRST REV NUM>        | <INITIAL DESCTIPTION>

Section  | <TITLE OF SECTION>
    Step | <TITLE OF STEP>
        
        // These all must occur within a STEP
        
        Context      | <PLAIN TEXT STATEMENTS FOR CONTEXT>
        Command      | <VERBATIM COMPUTER CODE>
        Warning      | <BIG BOLD TEXT TO CAPTURE ATTENTION>
        Image        | <FILENAME> | <CAPTION TEXT>
        Resource     | <THING YOU NEED TO COMPLETE THIS STEP> | <CALIBRATED?>
        Objective    | <ACHIEVED PURPOSE OF THIS PROCESS>
        Out of Scope | <NOTE ABOUT WHAT NOT TO DO HERE>

        // Verification methods can be single letter: A, I, D, T, S
        // They can also be full words: Analysis, Inspection, Demonstration, Test, Sampling
        Verification | <REQUIREMENT ID> | <FULL TEXT OF REQUIREMENT> | <VERIFICATION METHOD>

        // Action lines can be grouped together to form consecutive table rows
        // To optionally include Two-Party Verification, <TPV> can be \"TPV\" 
        // To NOT make an action Two-Party Verified, stop at the <EXPECTED RESULT>
        Action   | <THING TO DO> | <EXPECTED RESULT> | <TPV?> - optional
        Action   | <THING TO DO> | <EXPECTED RESULT> | <TPV?> - optional

// You can reference a different process's section and stanhope will fetch it for you
Section Reference | <OTHER PROCESS> | <TITLE OF SECTION>


// Alternate Aliases for EBML lines are below
// Everything here continues to be valid EBML
// Note: the EBML line designators (left of the first pipe) are NOT case sensitive
// 'section' is the same as 'SECTION'
// 'rev' is the same as 'REV'

REV | C | 'Revision' has a new alias!
rev | B | EBML line indicators are NOT case sensitive!
ReV | A | I mean, you *could* do that...
Rev | - | This is revision 'dash'

SEC | Section Alias 'SEC' (or 'sec' etc.) works!
    STP | Step Alias 'STP' (or 'stp' etc.) works!

        // 'Context' has several new aliases
        Comment | Context alias
        TXT | Context alias
        CMT | Context alias, perhaps short for 'comment'

        // 'Command' has a new alias
        CMD | Command alias
        > | Command alias
        % | Command alias
        $ | Command alias
        # | Command alias

        // 'Image' has a new alias
        IMG | image.ext | This caption appears under the image
        PICTURE | image.ext | This caption appears under the image
        PIC | image.ext | This caption appears under the image
        Figure | image.ext | This caption appears under the image
        FIG | image.ext | This caption appears under the image

        // 'Action' has a new alias
        // The Two-Party Verification flag has some aliases as well
        DO | Do this action | Expect this result
        DO | Do this action | Expect this result | TPV
        DO | Do this action | Expect this result | T
        DO | Do this action | Expect this result | TRUE
        DO | Do this action | Expect this result | Y
        DO | Do this action | Expect this result | YES
        DO | Do this action | Expect this result | Two Party Verification
        DO | Do this action | Expect this result | Two-Party Verification
        // That makes an eight-row Action table, with TPVs for the last seven actions

        // 'Warning' has new aliases
        WARN | Warning text
        WRN | Warning text
        WAR | Warning text
        Alert | Warning text
        ! | Warning text

        // 'Verification' has new aliases
        VER | ReqID | Verification Text | Method
        REQUIREMENT | ReqID | Verification Text | Method
        REQ | ReqID | Verification Text | Method
        // The methods of verification have a few aliases as well
        REQ | ReqID | Verification Text | Demonstration
        REQ | ReqID | Verification Text | Demo
        REQ | ReqID | Verification Text | D
        REQ | ReqID | Verification Text | Inspection
        REQ | ReqID | Verification Text | I
        REQ | ReqID | Verification Text | Analysis
        REQ | ReqID | Verification Text | A
        REQ | ReqID | Verification Text | Sampling
        REQ | ReqID | Verification Text | Sample
        REQ | ReqID | Verification Text | S
        REQ | ReqID | Verification Text | Test
        REQ | ReqID | Verification Text | T

        // 'Resource' has a new alias
        // There are several ways to indicate if a resource needs calibration, too!
        RES | Name of resource
        RES | Name of calibrated resource | C
        RES | Name of calibrated resource | CAL
        RES | Name of calibrated resource | CALIB
        RES | Name of calibrated resource | CALIBRATE
        RES | Name of calibrated resource | CALIBRATED
        RES | Name of calibrated resource | CALIBRATION
        RES | Name of calibrated resource | Y
        RES | Name of calibrated resource | YES
        RES | Name of calibrated resource | T
        RES | Name of calibrated resource | TRUE
        
        // 'Objective' has a new alias
        OBJ | Objective achieved!

        // 'Out of Scope' has a new alias
        OOS | Description of what is not in this process scope

// 'Section Reference' has a new alias
SECREF | Process-Number | Title of Section to Fetch

\x1b[36m
=================================================
==  Everything above this block is valid EBML  ==
==                                             ==
==   Easy Button Markup Language Cheat Sheet   ==
=================================================
\x1b[0m

For extensive examples of EBML in action, see https://stanhope.strativusgroup.com/latest/stylesheetviewer.html"));
    }

}