#![crate_type = "rlib"]
#![crate_type = "dylib"]
extern crate regex;

pub use self::ParserResult::{Succ, Fail, Error};
use std::cmp::{min, Ordering};
use std::fmt;

pub use re::re;
pub use chainl::chainl;
pub use chainr::chainr;
pub use choice::choice;
pub use until::until;
pub use many::many;
pub use many1::many1;
pub use keyword::keyword;
pub use try::try;
pub use skip::skip;
pub use cond::cond;
pub use opt::opt;
pub use wrapper::wrap;
pub use split::split;
pub use many_until::many_until;

pub mod re;
pub mod chainl;
pub mod chainr;
pub mod choice;
pub mod until;
pub mod many;
pub mod many1;
pub mod keyword;
pub mod try;
pub mod skip;
pub mod cond;
pub mod opt;
pub mod wrapper;
pub mod split;
pub mod many_until;
mod macros;


pub struct CharSeq<'a> {
    pub pos: usize,
    pub text: String,
    pub place: String,
    hooks: Vec<&'a (ParserHook+'a)>,
    pub enable_hook: bool,
    pub trace: bool
}

#[derive(Clone)]
pub struct LocationInfo {
    pub col: usize,
    pub row: usize,
    pub pos: usize,
    pub place: String
}

impl Ord for LocationInfo {
    fn cmp(&self, other: &LocationInfo) -> Ordering {
        if self.row == other.row {
            self.col.cmp(&other.col)
        } else {
            self.row.cmp(&other.row)
        }
    }
}

impl PartialOrd for LocationInfo {
    fn partial_cmp(&self, other: &LocationInfo) -> Option<Ordering> {
        Some(self.pos.cmp(&other.pos))
    }
    fn lt(&self, other: &LocationInfo) -> bool {
        self.pos < other.pos
    }
    fn le(&self, other: &LocationInfo) -> bool {
        self.pos <= other.pos
    }
    fn gt(&self, other: &LocationInfo) -> bool {
        self.pos > other.pos
    }
    fn ge(&self, other: &LocationInfo) -> bool {
        self.pos >= other.pos
    }
}


impl PartialEq for LocationInfo {
    fn eq(&self, other: &LocationInfo) -> bool {
        self.pos == other.pos
    }
}

impl Eq for LocationInfo {
}

impl fmt::Display for LocationInfo {
    fn fmt(&self, f:&mut fmt::Formatter) -> fmt::Result {
        f.write_str(format!("Col: {}, Row: {} at {}", self.col, self.row, self.place).as_str())
    }
}

pub enum ParserResult<T> {
    Succ(T),
    Error(String, LocationInfo),
    Fail(String, LocationInfo),
}

impl<T> ParserResult<T> {
    pub fn map<S, F>(self, f: F) -> ParserResult<S> where F: Fn(T) -> S {
        match self {
            Succ(c) => Succ(f(c)),
            Fail(m, l) => Fail(m.clone(), l.clone()),
            Error(m, l) => Error(m.clone(), l.clone())
        }
    }

    pub fn and_then<S, F>(self, mut f: F) -> ParserResult<S> where F: FnMut(T) -> ParserResult<S> {
        match self {
            Succ(c) => f(c),
            Fail(m, l) => Fail(m.clone(), l.clone()),
            Error(m, l) => Error(m.clone(), l.clone())
        }
    }
}

impl<'a> CharSeq<'a> {
    pub fn view(&self) -> &str {
        return &self.text[self.pos..];
    }

    pub fn eof(&self) -> bool {
        return self.text.len() <= self.pos;
    }

    pub fn new(t: &str, l: &str) -> CharSeq<'a> {
        return CharSeq{pos: 0, text: t.to_string(), place: l.to_string(), hooks: Vec::new(), enable_hook: true, trace: false};
    }

    pub fn fail<T>(&self, msg: &str) -> ParserResult<T> {
        return Fail(msg.to_string(), self.get_location());
    }

    pub fn get_location(&self) -> LocationInfo {
        let mut col = 1;
        let mut row = 1;
        let max = self.pos;
        let mut i = 0;
        for c in self.text.chars() {
            if i >= max {
                break;
            }
            col += 1;
            if c == '\n' {
                row += 1;
                col = 1;
            }
            i+=1;
        }
        return LocationInfo{col: col, row:row, pos: self.pos, place: self.place.clone()};
    }

    pub fn current(&self) -> char {
        if self.eof() {
            return '\0';
        } else {
            return self.text.chars().nth(self.pos).unwrap();
        }
    }

    pub fn next(&mut self) {
        if !self.eof() {
            self.pos += 1;
        }
    }

    pub fn add_hook(&mut self, hook: &'a (ParserHook+'a)) {
        self.hooks.push(hook);
    }

    #[allow(unused_variables)]
    pub fn do_hook(&mut self) {
        if !self.enable_hook {
            return ();
        }
        self.enable_hook = false;
        for h in self.hooks.clone().iter() {
            h.hook(self);
        }
        self.enable_hook = true;
        return ();
    }

    pub fn accept<T>(&mut self, p: &Parser<T>) -> ParserResult<T> {
        if self.trace {
            println!("{}", self.get_location());
        }
        return p.parse(self);
    }
}


pub trait Parser<T> {
    fn parse(&self, cs: &mut CharSeq) -> ParserResult<T> {
        cs.do_hook();
        let r = self._parse(cs);
        cs.do_hook();
        return r;
    }

    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<T>;
    
    #[allow(unused_variables)]
    fn lookahead(&self, cs: &mut CharSeq) -> bool {
        let p = cs.pos;
        let result = match self.parse(cs) {
            Succ(c) => true,
            Fail(m, l) => false,
            Error(m, l) => false
        };
        cs.pos = p;
        return result;
    }
}

pub trait ParserHook {
    fn hook(&self, cs: &mut CharSeq);
}

impl<'a> Parser<String> for &'a str {
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<String> {
        if cs.view()[..min(self.len(), cs.view().len())] == **self {
            cs.pos = cs.pos + self.len();
            return Succ(self.to_string().clone());
        } else {
            return cs.fail(*self);
        }
    }
}

#[derive(Clone)]
pub struct EOF;

impl Parser<()> for EOF {
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<()> {
        if cs.eof() {
            Succ(())
        } else {
            cs.fail("not eof")
        }
    }
}


#[cfg(test)]
#[allow(unused_variables)]
#[allow(unused_imports)]
mod tests {
    use super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};
    #[test]
    fn test_s1() {
        let mut cs = CharSeq::new("abcabcdef", "<mem>");
        assert!(cs.pos == 0);
        match cs.accept(&"abc") {
            Succ(a) => assert!(a == "abc"),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 3);
        assert!(cs.view() == "abcdef");

        match cs.accept(&"abc") {
            Succ(a) => assert!(a == "abc"),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 6);
        assert!(cs.view() == "def");
        
        match cs.accept(&"abc") {
            Succ(a) => assert!(false, format!("unexcepted result: {}, pos:{}", a, cs.pos)),
            Fail(a, b) => (),
            Error(a, b) => assert!(false, "error")
        }
        assert!(cs.pos == 6);
     
        match cs.accept(&"def") {
            Succ(a) => assert!(a=="def"),
            _ => assert!(false, "bug")
        }
        assert!(cs.pos == 9);
        assert!(cs.eof());

        match cs.accept(&"def") {
            Succ(a) => assert!(false, format!("unexcepted result: {}, pos: {}", a , cs.pos)),
            Fail(a, b) => (),
            Error(a, b) => assert!(false, "error")
        }
        assert!(cs.pos == 9);
        assert!(cs.eof());
    }

    #[test]
    fn test_s2() {
        let mut cs = CharSeq::new("abcdefghi", "<mem>");
        let r = cs.accept(&"abc").and_then(
            |a| cs.accept(&"def").and_then(
                |b| cs.accept(&"ghi").map(
                    |c| {
                        assert!(a == "abc");
                        assert!(b == "def");
                        assert!(c == "ghi");
                    }
                )
            )
        );
    }

    #[test]
    fn test_s3() {
        let mut cs = CharSeq::new("a", "<mem>");
        match cs.accept(&"abc") {
            Succ(a) => assert!(false, format!("unexcepted result: {}, pos: {}", a , cs.pos)),
            Fail(a, b) => (),
            Error(a, b) => assert!(false, "error")
        }
    }
}