//! Parse the query language for the CLI and other tools
//!
//! The `cargo-ws2` query language (`ws2ql`) allows users to specify a
//! set of inputs, and an operation to execute on it.
//!
//! ## Basic rules
//!
//! * Inside `[]` are sets (meaning items de-dup) that don't require
//!   reparations
//! * IF `[]` contains a `/` anywhere _but_ the beginning AND end,
//!   query becomes a path glob
//! * IF `[]` contains `/` at start and end, query becomes a regex
//! * An operation is parsed in the order of the fields in it's struct
//!   (so publish order is `type mod devel`, etc)
//! * Inside `{}` you can create dependency maps with arrows.
//! * `{ foo < }` represents all crates that depend on `foo`
//! * `{ foo < bar < }` represents all crates that depend on `foo` AND `bar`
//! * `{ foo < bar |< }` represents all crates that depend on `foo` but NOT on `bar`
//!
//! ... etc.

use crate::models::{CrateId, DepGraph};

mod executor;

/// A query on the dependency graph
#[derive(Debug)]
pub enum Query {
    /// Simple set of names `[ a b c ]`
    Set(Vec<String>),
    /// Simple path glob query `./foo/*`
    Path(String),
    /// Regular expression done on paths in tree `/foo\$/`
    Regex(String),
    /// A dependency graph query (see documentation for rules)
    DepGraph(Vec<DepConstraint>),
}

impl Query {
    /// Parse an argument iterator (provided by `std::env::args`)
    pub fn parse<'a>(line: impl Iterator<Item = String>) -> (Self, Vec<String>) {
        let parser = QueryParser::new(line.skip(1).collect());
        match parser.run() {
            Some((q, rest)) => (q, rest),
            None => {
                eprintln!("Failed to parse query!");
                std::process::exit(2);
            }
        }
    }

    /// Execute a query with a dependency graph
    pub fn execute(self, g: &DepGraph) -> Vec<CrateId> {
        match self {
            Self::Set(ref crates) => executor::set(crates, g),
            Self::DepGraph(deps) => executor::deps(deps, g),
            _ => todo!(),
        }
    }
}

/// Express a dependency constraint
#[derive(Debug)]
pub struct DepConstraint {
    pub _crate: String,
    pub constraint: Constraint,
}

/// All constraints can be negated
#[derive(Debug)]
pub enum Constraint {
    Initial(bool),
    And(bool),
    Or,
}

struct QueryParser {
    line: Vec<String>,
}

impl QueryParser {
    fn new(line: Vec<String>) -> Self {
        Self { line }
    }

    /// Run the parser until it yields an error or finished query
    fn run(mut self) -> Option<(Query, Vec<String>)> {
        let line: Vec<String> =
            std::mem::replace(&mut self.line, vec![])
                .into_iter()
                .fold(vec![], |mut vec, line| {
                    line.split(" ").for_each(|seg| {
                        vec.push(seg.into());
                    });
                    vec
                });

        // This is here to get around infinately sized enums
        #[derive(Debug)]
        enum Brace {
            Block,
            Curly,
        }

        // Track the state of the query braces
        #[derive(Debug)]
        enum BraceState {
            Missing,
            BlockOpen,
            CurlyOpen,
            Done(Brace),
        }
        use {Brace::*, BraceState::*};
        let mut bs = Missing;
        let mut buf = vec![];
        let mut cbuf = String::new(); // Store a single crate name as a buffer
        let mut skip = 1;

        // Parse the crate set
        for elem in &line {
            match (&bs, elem.as_str()) {
                // The segment starts with a [
                (Missing, e) if e.starts_with("[") => {
                    bs = BlockOpen;
                    // Handle the case where we need to grab the crate from this segment
                    if let Some(_crate) = e.strip_prefix("[") {
                        if _crate != "" {
                            buf.push(_crate.to_string());
                        }
                    }
                }
                // The segment starts with a {
                (Missing, e) if e.starts_with("{") => {
                    bs = CurlyOpen;

                    if let Some(_crate) = e.strip_prefix("{") {
                        if _crate != "" {
                            cbuf = _crate.into();
                        }
                    }
                }
                (BlockOpen, e) if e.ends_with("]") => {
                    if let Some(_crate) = e.strip_suffix("]") {
                        if _crate != "" {
                            buf.push(_crate.to_string());
                        }
                    }

                    bs = Done(Block);
                    break;
                }
                (BlockOpen, _crate) => buf.push(_crate.to_string()),
                (CurlyOpen, e) if e.ends_with("}") && cbuf == "" => {
                    bs = Done(Curly);
                    break;
                }
                (CurlyOpen, e) if e.ends_with("}") && cbuf != "" => {
                    eprintln!("[ERROR]: Out of place `}}`, expected operand!");
                    std::process::exit(2);
                }
                (CurlyOpen, op) if cbuf != "" => {
                    buf.push(format!("{} $ {}", cbuf, op));
                    cbuf = "".into();
                }
                (CurlyOpen, _crate) => {
                    cbuf = _crate.into();
                }
                (_, _) => {}
            }
            skip += 1;
        }

        let rest = line.into_iter().skip(skip).collect();
        match bs {
            Done(Block) => Some((Query::Set(buf), rest)),
            Done(Curly) => {
                let mut init = true;

                let c: Vec<_> = buf
                    .into_iter()
                    .map(|val| {
                        let mut s: Vec<_> = val.split("$").collect();
                        let _crate = s.remove(0).trim().to_string();
                        let c = s.remove(0).trim().to_string();

                        DepConstraint {
                            _crate,
                            constraint: match c.as_str() {
                                "<" if init => {
                                    init = false;
                                    Constraint::Initial(true)
                                }
                                "!<" if init => {
                                    init = false;
                                    Constraint::Initial(false)
                                }
                                "&<" => Constraint::And(true),
                                "!&<" => Constraint::And(false),
                                "|<" => Constraint::Or,
                                c => {
                                    eprintln!("[ERROR]: Invalid constraint: `{}`", c);
                                    std::process::exit(2);
                                }
                            },
                        }
                    })
                    .collect();

                if c.len() < 1 {
                    eprintln!("[ERROR]: Provided an empty graph set: {{ }}.  At least one dependency required!");
                    std::process::exit(2);
                }

                Some((Query::DepGraph(c), rest))
            }
            _ if rest.len() < 1 => crate::cli::render_help(2),
            _line => {
                eprintln!("[ERROR]: You reached some unimplemented code in cargo-ws2! \
                           This might be a bug, or it might be a missing feature.  Contact me with your query, \
                           and we can see which one it is :)");
                std::process::exit(2);
            }
        }
    }
}

#[test]
fn block_parser_spaced() {
    let _ = QueryParser::new(
        vec!["", "[", "foo", "bar", "baz", "]", "publish", "minor"]
            .into_iter()
            .map(Into::into)
            .collect(),
    )
    .run();
}

#[test]
fn block_parser_offset_front() {
    let _ = QueryParser::new(
        vec!["my-program", "[foo", "bar", "baz", "]", "publish", "minor"]
            .into_iter()
            .map(Into::into)
            .collect(),
    )
    .run();
}

#[test]
fn block_parser_offset_back() {
    let _ = QueryParser::new(
        vec!["my-program", "[", "foo", "bar", "baz]", "publish", "minor"]
            .into_iter()
            .map(Into::into)
            .collect(),
    )
    .run();
}

#[test]
fn block_parser_offset_both() {
    let _ = QueryParser::new(
        vec!["my-program", "[foo", "bar", "baz]", "publish", "minor"]
            .into_iter()
            .map(Into::into)
            .collect(),
    )
    .run();
}

#[test]
fn curly_parser_simple() {
    let _ = QueryParser::new(
        vec!["my-program", "{ foo < bar &< }", "print"]
            .into_iter()
            .map(Into::into)
            .collect(),
    )
    .run();
}