pub enum Ast {
    AssignVar(AssignVar),
    Pipes(Pipes),
}

pub struct AssignVar {
    pub to: String,
    // TODO: body
}

pub struct Pipes {
    pub cmds: Vec<Command>,
}

pub struct Command {
    pub path: String,
    pub args: Vec<String>,
}

enum ParseError {
    /// "clean" EOF, i.e. not in the middle of something
    Eof,

    /// "unclean" EOF, i.e. EOF after beginning a quoted string
    Incomplete,

    UnexpectedPipe,

    UnknownChar(char),
}

type Result<T> = std::result::Result<T, ParseError>;

pub fn do_parse(x: &str) -> Result<Ast> {
    let chars: Vec<char> = x.chars().collect();
    Ast::parse(&mut &chars[..])
}

trait Parse: Sized {
    fn parse(b: &mut &[char]) -> Result<Self>;
}

#[inline(always)]
fn parse<T: Parse>(b: &mut &[char]) -> Result<T> {
    T::parse(b)
}

fn spaces(b: &mut &[char]) {
    while let Some(' ' | '\t') = b.get(0) {
        *b = &b[1..];
    }
}

#[inline(always)]
fn adv(b: &mut &[char]) {
    *b = &b[1..]
}

fn parse_quoted_string(b: &mut &[char], delim: char) -> Result<String> {
    // TODO: escape sequence stuff

    *b = &b[1..];
    let mut s = String::new();
    while b.len() > 0 {
        if b[0] == delim {
            adv(b);
            return Ok(s);
        }

        s.push(b[0]);
        adv(b);
    }
    Err(ParseError::Incomplete)
}

impl Parse for String {
    fn parse(b: &mut &[char]) -> Result<Self> {
        spaces(b);
        if b.is_empty() {
            return Err(ParseError::Eof);
        }
        let c = b[0];
        if c == '|' {
            Err(ParseError::UnexpectedPipe)
        } else if c == '\'' || c == '"' {
            adv(b);
            parse_quoted_string(b, c)
        } else if c.is_ascii_graphic() {
            parse_quoted_string(b, ' ')
        } else {
            Err(ParseError::UnknownChar(c))
        }
    }
}

impl Parse for Ast {
    fn parse(b: &mut &[char]) -> Result<Self> {
        Ok(Self::Pipes(parse(b)?))
    }
}

impl Parse for Command {
    fn parse(b: &mut &[char]) -> Result<Self> {
        let path: String = parse(b)?;
        let mut args = Vec::new();
        loop {
            let arg: Result<String> = parse(b);
            match arg {
                Ok(arg) => args.push(arg),
                Err(ParseError::Eof | ParseError::UnexpectedPipe) => break,
                Err(e) => Err(e)?,
            }
        }
        Ok(Self { path, args })
    }
}

impl Parse for Pipes {
    fn parse(b: &mut &[char]) -> Result<Self> {
        let cmds: Vec<Command> = vec![parse(b)?];

        loop {
            spaces(b);
            if b.is_empty() {
                return Ok(Pipes { cmds });
            }

            let c = b[0];
            if c == '|' {
                adv(b);
            } else {
                Err(ParseError::UnknownChar(c))?;
            }
        }
    }
}