use crate::asm::error::CrsnError;
use crate::asm::instr::cond::parse_cond;
use crate::asm::instr::Op;
use crate::asm::parse::arg_parser::TokenParser;
use crate::builtin::parse::BuiltinOps;
use crate::module::ParseRes;

pub fn parse_op<'a>(mut keyword: &str, mut arg_tokens: TokenParser<'a>) -> Result<Option<Op>, CrsnError> {
    // Include built-in instructions
    let builtins = [BuiltinOps::new()];
    let mut cond = None;

    if let Some(pos) = keyword.find('.') {
        cond = Some(parse_cond(&keyword[(pos + 1)..])?);
        keyword = &keyword[..pos];
    }

    for p in builtins.iter().chain(arg_tokens.pcx.parsers) {
        arg_tokens = match p.parse_op(keyword, arg_tokens) {
            Ok(ParseRes::Parsed(kind)) => return Ok(Some(Op {
                cond,
                kind,
            })),
            Ok(ParseRes::ParsedNone) => return Ok(None),
            Ok(ParseRes::Unknown(to_reuse)) => {
                if to_reuse.parsing_started() {
                    panic!("Module \"{}\" started parsing {}, but returned Unknown!", p.name(), keyword);
                }
                to_reuse
            }
            Err(err) => {
                return Err(err);
            }
        }
    }

    return Err(CrsnError::Parse(format!("Unknown instruction: {}", keyword).into()));
}