extern crate nom;
use nom::{space, digit, char};

named!(consume_whitespace, take_while!(is_space));
named!(take_line, take_while!(is_not_line_end));

named!(pub oper_register_gp <Operand>,
       do_parse!(
           opt!(complete!(consume_whitespace)) >>
           alt!(char!('v') | char!('V') ) >>
           num: digit >>
           opt!(complete!(char!(','))) >>
           opt!(complete!(char!('\n'))) >>
           (Operand::RegisterGP(from_dec(str::from_utf8(num).unwrap()).unwrap() as usize))
       )
);

named!(pub oper_register_dt <Operand>,
       do_parse!(
           opt!(complete!(consume_whitespace)) >>
           tag_no_case!("dt") >>
           opt!(complete!(char!(','))) >>
           opt!(complete!(consume_whitespace)) >>
               (Operand::RegisterDT)
       )
);

named!(pub oper_register_st <Operand>,
       do_parse!(
           opt!(complete!(consume_whitespace)) >>
           tag_no_case!("st") >>
           opt!(complete!(char!(','))) >>
           opt!(complete!(consume_whitespace)) >>
               (Operand::RegisterDT)
       )
);

named!(pub oper_register_i <Operand>,
       do_parse!(
           opt!(complete!(consume_whitespace)) >>
           alt!(char!('i') | char!('I')) >>
           opt!(complete!(char!(','))) >>
           opt!(complete!(char!('\n'))) >>
               (Operand::RegisterI)
       )
);

named!(pub parse_operand <Operand>,
       alt_complete!(oper_register_gp | oper_register_i)
);

named!(pub parse_operands <Vec<Operand> >,
   // Getting a 0 length Vec back is fine as some operations do not take
   // operands
   fold_many0!(parse_operand, Vec::new(), |mut acc: Vec<_>, item| {
     acc.push(item);
     acc
}));

named!(pub parse_mnemonic<Mnemonic>,
       alt_complete!(
           tag_no_case!("add")       => { |_| Mnemonic::Add  } |
           tag_no_case!("and")       => { |_| Mnemonic::And  } |
           tag_no_case!("call")      => { |_| Mnemonic::Call } |
           tag_no_case!("cls")       => { |_| Mnemonic::Cls  } |
           tag_no_case!("draw")      => { |_| Mnemonic::Draw } |
           tag_no_case!("jmp")       => { |_| Mnemonic::Jmp  } |
           tag_no_case!("ldb")       => { |_| Mnemonic::Ldb  } |
           tag_no_case!("ld")        => { |_| Mnemonic::Ld   } |
           tag_no_case!("or")        => { |_| Mnemonic::Or   } |
           tag_no_case!("ret")       => { |_| Mnemonic::Ret  } |
           tag_no_case!("rnd")       => { |_| Mnemonic::Rnd  } |
           tag_no_case!("seq")       => { |_| Mnemonic::Seq  } |
           tag_no_case!("shl")       => { |_| Mnemonic::Shl  } |
           tag_no_case!("shr")       => { |_| Mnemonic::Shr  } |
           tag_no_case!("sne")       => { |_| Mnemonic::Sne  } |
           tag_no_case!("snp")       => { |_| Mnemonic::Snp  } |
           tag_no_case!("sp")        => { |_| Mnemonic::Sp   } |
           tag_no_case!("sub")       => { |_| Mnemonic::Sub  } |
           tag_no_case!("subn")      => { |_| Mnemonic::Subn } |
           tag_no_case!("sys")       => { |_| Mnemonic::Sys  } |
           tag_no_case!("wk")        => { |_| Mnemonic::Wk   } |
           tag_no_case!("xor")       => { |_| Mnemonic::Xor  } |
           take_while!(is_not_space) => { |_| Mnemonic::Undefined }
       )
);

named!(pub parse_line<Instruction>,
       do_parse!(
           mnemonic: parse_mnemonic >>
           operands: parse_operands >>
           (Instruction { mnemonic: mnemonic,
                          operands: operands})
       )
);

fn main() {
    println!("Hello, world!");
}