use nom::branch::*;
use nom::bytes::complete::*;
use nom::character::complete::*;
use nom::combinator::*;
use nom::error::*;
use nom::multi::*;
use nom::sequence::*;
///! Locomotive basic parser routines.
use nom::*;

use crate::tokens::*;
use crate::{BasicLine, BasicProgram};

/// Parse complete basic program"],
pub fn parse_basic_program(input: &str) -> IResult<&str, BasicProgram> {
    let (input, lines) = fold_many0(
        parse_basic_inner_line,
        Vec::new(),
        |mut acc: Vec<_>, item| {
            acc.push(item);
            acc
        },
    )(input)?;

    let (input, last) = terminated(opt(parse_basic_line), opt(line_ending))(input)?;

    let mut lines = lines.clone();
    if let Some(line) = last {
        lines.push(line);
    }

    Ok((input, BasicProgram::new(lines)))
}

/// Parse a line
pub fn parse_basic_line(input: &str) -> IResult<&str, BasicLine> {
    let (input, line_number) = dec_u16_inner(input)?;

    let (input, _) = char(' ')(input)?;

    let (input, tokens) = fold_many0(parse_token, Vec::new(), |mut acc: Vec<_>, item| {
        acc.push(item);
        acc
    })(input)?;

    Ok((input, BasicLine::new(line_number, &tokens)))
}

/// Parse a line BUT expect an end of line char
pub fn parse_basic_inner_line(input: &str) -> IResult<&str, BasicLine> {
    terminated(parse_basic_line, line_ending)(input)
}

/// Parse any token
pub fn parse_token(input: &str) -> IResult<&str, BasicToken> {
    alt((
        parse_rem,
        parse_simple_instruction,
        parse_prefixed_instruction,
        parse_basic_value,
        parse_char,
    ))(input)
}

/// Parse a comment"],
pub fn parse_rem(input: &str) -> IResult<&str, BasicToken> {
    let (input, sym) = alt((
        map(tag_no_case("REM"), |_| BasicTokenNoPrefix::Rem),
        map(char('\''), |_| BasicTokenNoPrefix::SymbolQuote),
    ))(input)?;

    let (input, list) = take_till(|ch| ch == ':' || ch == '\n')(input)?;

    Ok((input, BasicToken::Comment(sym, list.as_bytes().to_vec())))
}

/// Parse the instructions that do not need a prefix byte
/// TODO Add all the other variants"
pub fn parse_simple_instruction(input: &str) -> IResult<&str, BasicToken> {
    map(
        alt((
            map(tag_no_case("CALL"), |_| BasicTokenNoPrefix::Call),
            map(tag_no_case("INPUT"), |_| BasicTokenNoPrefix::Input),
            map(tag_no_case("PRINT"), |_| BasicTokenNoPrefix::Print),
        )),
        |token| BasicToken::SimpleToken(token),
    )(input)
}

/// TODO add the missing chars
pub fn parse_char(input: &str) -> IResult<&str, BasicToken> {
    map(
        alt((
            alt((
                map(char(':'), |_| BasicTokenNoPrefix::StatementSeparator),
                map(char(' '), |_| BasicTokenNoPrefix::CharSpace),
                map(char('A'), |_| BasicTokenNoPrefix::CharUpperA),
                map(char('B'), |_| BasicTokenNoPrefix::CharUpperB),
                map(char('C'), |_| BasicTokenNoPrefix::CharUpperC),
                map(char('D'), |_| BasicTokenNoPrefix::CharUpperD),
                map(char('E'), |_| BasicTokenNoPrefix::CharUpperE),
                map(char('F'), |_| BasicTokenNoPrefix::CharUpperF),
                map(char('G'), |_| BasicTokenNoPrefix::CharUpperG),
                map(char('H'), |_| BasicTokenNoPrefix::CharUpperH),
                map(char('I'), |_| BasicTokenNoPrefix::CharUpperI),
                map(char('J'), |_| BasicTokenNoPrefix::CharUpperJ),
                map(char('K'), |_| BasicTokenNoPrefix::CharUpperK),
                map(char('L'), |_| BasicTokenNoPrefix::CharUpperL),
                map(char('M'), |_| BasicTokenNoPrefix::CharUpperM),
                map(char('N'), |_| BasicTokenNoPrefix::CharUpperN),
                map(char('O'), |_| BasicTokenNoPrefix::CharUpperO),
                map(char('P'), |_| BasicTokenNoPrefix::CharUpperP),
                map(char('Q'), |_| BasicTokenNoPrefix::CharUpperQ),
                map(char('R'), |_| BasicTokenNoPrefix::CharUpperR),
            )),
            alt((
                map(char('S'), |_| BasicTokenNoPrefix::CharUpperS),
                map(char('T'), |_| BasicTokenNoPrefix::CharUpperT),
                map(char('U'), |_| BasicTokenNoPrefix::CharUpperU),
                map(char('V'), |_| BasicTokenNoPrefix::CharUpperV),
                map(char('W'), |_| BasicTokenNoPrefix::CharUpperW),
                map(char('X'), |_| BasicTokenNoPrefix::CharUpperX),
                map(char('Y'), |_| BasicTokenNoPrefix::CharUpperY),
                map(char('Z'), |_| BasicTokenNoPrefix::CharUpperZ),
            )),
            alt((
                map(char('a'), |_| BasicTokenNoPrefix::CharLowerA),
                map(char('b'), |_| BasicTokenNoPrefix::CharLowerB),
                map(char('c'), |_| BasicTokenNoPrefix::CharLowerC),
                map(char('d'), |_| BasicTokenNoPrefix::CharLowerD),
                map(char('e'), |_| BasicTokenNoPrefix::CharLowerE),
                map(char('f'), |_| BasicTokenNoPrefix::CharLowerF),
                map(char('g'), |_| BasicTokenNoPrefix::CharLowerG),
                map(char('h'), |_| BasicTokenNoPrefix::CharLowerH),
                map(char('i'), |_| BasicTokenNoPrefix::CharLowerI),
                map(char('j'), |_| BasicTokenNoPrefix::CharLowerJ),
                map(char('k'), |_| BasicTokenNoPrefix::CharLowerK),
                map(char('l'), |_| BasicTokenNoPrefix::CharLowerL),
                map(char('m'), |_| BasicTokenNoPrefix::CharLowerM),
                map(char('n'), |_| BasicTokenNoPrefix::CharLowerN),
                map(char('o'), |_| BasicTokenNoPrefix::CharLowerO),
            )),
            alt((
                map(char('p'), |_| BasicTokenNoPrefix::CharLowerP),
                map(char('q'), |_| BasicTokenNoPrefix::CharLowerQ),
                map(char('r'), |_| BasicTokenNoPrefix::CharLowerR),
                map(char('s'), |_| BasicTokenNoPrefix::CharLowerS),
                map(char('t'), |_| BasicTokenNoPrefix::CharLowerT),
                map(char('u'), |_| BasicTokenNoPrefix::CharLowerU),
                map(char('v'), |_| BasicTokenNoPrefix::CharLowerV),
                map(char('w'), |_| BasicTokenNoPrefix::CharLowerW),
                map(char('x'), |_| BasicTokenNoPrefix::CharLowerX),
                map(char('y'), |_| BasicTokenNoPrefix::CharLowerY),
                map(char('z'), |_| BasicTokenNoPrefix::CharLowerZ),
            )),
        )),
        |token| BasicToken::SimpleToken(token),
    )(input)
}

/// Parse the instructions that do not need a prefix byte
/// TODO Add all the other instructions"],
pub fn parse_prefixed_instruction(input: &str) -> IResult<&str, BasicToken> {
    map(
        alt((
            value(BasicTokenPrefixed::Abs, tag_no_case("ABS")),
            value(BasicTokenPrefixed::Abs, tag_no_case("ABS")), //TODO put the others
        )),
        |token| BasicToken::PrefixedToken(token),
    )(input)
}

/// Parse a basic value
pub fn parse_basic_value(input: &str) -> IResult<&str, BasicToken> {
    alt((parse_hexadecimal_value_16bits, parse_decimal_value_16bits))(input)
}

/// Parse an hexadecimal value
pub fn parse_hexadecimal_value_16bits(input: &str) -> IResult<&str, BasicToken> {
    map(preceded(char('&'), hex_u16_inner), |val| {
        BasicToken::Constant(
            BasicTokenNoPrefix::ValueIntegerHexadecimal16bits,
            BasicValue::new_integer(val),
        )
    })(input)
}

/// ...
pub fn parse_decimal_value_16bits(input: &str) -> IResult<&str, BasicToken> {
    map(dec_u16_inner, |val| {
        BasicToken::Constant(
            BasicTokenNoPrefix::ValueIntegerDecimal16bits,
            BasicValue::new_integer(val),
        )
    })(input)
}

/// XXX stolen to the asm parser
#[inline]
pub fn hex_u16_inner(input: &str) -> IResult<&str, u16> {
    match is_a("0123456789abcdefABCDEF")(input) {
        Err(e) => Err(e),
        Ok((remaining, parsed)) => {
            // Do not parse more than  characters for a u16
            if parsed.input_len() > 4 {
                Err(::nom::Err::Error(error_position!(input, ErrorKind::OneOf)))
            } else {
                let mut res = 0_u32;
                for e in parsed.iter_elements() {
                    let digit = e;
                    let value = digit.to_digit(16).unwrap_or(0);
                    res = value + (res * 16);
                }
                if res > u32::from(u16::max_value()) {
                    Err(::nom::Err::Error(error_position!(input, ErrorKind::OneOf)))
                } else {
                    Ok((remaining, res as u16))
                }
            }
        }
    }
}

/// XXX stolen to the asm parser
#[inline]
pub fn dec_u16_inner(input: &str) -> IResult<&str, u16> {
    match is_a("0123456789")(input) {
        Err(e) => Err(e),
        Ok((remaining, parsed)) => {
            // Do not parse more than 5 characters for a u16
            if parsed.input_len() > 5 {
                Err(::nom::Err::Error(error_position!(input, ErrorKind::OneOf)))
            } else {
                let mut res = 0_u32;
                for e in parsed.iter_elements() {
                    let digit = e;
                    let value = digit.to_digit(10).unwrap_or(0);
                    res = value + (res * 10);
                }
                if res > u32::from(u16::max_value()) {
                    Err(::nom::Err::Error(error_position!(
                        input,
                        ErrorKind::TooLarge /*Custom(0)*/
                    )))
                } else {
                    Ok((remaining, res as u16))
                }
            }
        }
    }
}

#[cfg(test)]
mod test {
    use crate::parser::*;

    #[test]
    fn check_number() {
        assert!(dec_u16_inner("10").is_ok());

        match hex_u16_inner("1234".into()) {
            Ok((res, value)) => {
                println!("{:?}", &res);
                println!("{:x}", &value);
                assert_eq!(0x1234, value);
            }
            Err(e) => {
                panic!("{:?}", e);
            }
        }

        match parse_hexadecimal_value_16bits("&1234".into()) {
            Ok((res, value)) => {
                println!("{:?}", &res);
                println!("{:?}", &value);
                let bytes = value.as_bytes();
                assert_eq!(
                    bytes[0],
                    BasicTokenNoPrefix::ValueIntegerHexadecimal16bits as u8
                );
                assert_eq!(bytes[1], 0x34);
                assert_eq!(bytes[2], 0x12);
            }
            Err(e) => {
                panic!("{:?}", e);
            }
        }
    }

    fn check_line_tokenisation(code: &str) -> BasicLine {
        let res = parse_basic_inner_line(code.into());
        match res {
            Ok((res, line)) => {
                println!("{:?}", &line);
                println!("{:?}", &res);
                assert_eq!(res.len(), 0, "Line as not been completly consummed");
                line
            }
            Err(e) => {
                panic!("{:?}", e);
            }
        }
    }

    fn check_token_tokenisation(code: &str) {
        let res = parse_token(code.into());
        match res {
            Ok((res, line)) => {
                println!("{} => {:?}", code, &line);
                assert_eq!(res.len(), 0, "Line as not been completly consummed");
            }
            Err(e) => {
                panic!("{:?}", e);
            }
        }
    }

    #[test]
    fn test_lines() {
        check_line_tokenisation("10 call &0\n");
        check_line_tokenisation("10 call &0  \n");
        check_line_tokenisation("10 call &0: call &0\n");
    }

    #[test]
    fn test_tokens() {
        check_token_tokenisation("call");
        check_token_tokenisation("abs");
        check_token_tokenisation(":");
    }

    #[test]
    fn test_comment() {
        check_token_tokenisation("REM fldsfksjfksjkg");
        check_token_tokenisation("' fldsfksjfksjkg");

        let line = check_line_tokenisation("10 REM fldsfksjfksjkg:CALL\n");
        assert_eq!(3, line.tokens().len())
    }
}