use std::fmt::{self, Display, Formatter};

use sexp::SourcePosition;

use crate::asm::error::CrsnError;
use crate::asm::patches::ErrWithPos;

/// Register name
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub enum Register {
    /// Argument register, read-only
    Arg(u8),
    /// Result register, read-only
    Res(u8),
    /// General purpose register
    Gen(u8),
    /// Global register
    Global(u8),
}

impl Register {
    pub fn is_global(self) -> bool {
        match self {
            Register::Global(_) => true,
            _ => false,
        }
    }
}

impl Display for Register {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Register::Arg(n) => write!(f, "arg{}", n),
            Register::Res(n) => write!(f, "res{}", n),
            Register::Gen(n) => write!(f, "r{}", n),
            Register::Global(n) => write!(f, "g{}", n),
        }
    }
}

pub fn parse_reg(name: &str, at: &SourcePosition) -> Result<Register, CrsnError> {
    // TODO deduplicate code
    if let Some(rn) = name.strip_prefix("arg") {
        if rn.chars().find(|c: &char| !c.is_ascii_digit()).is_some() {
            return Err(CrsnError::Parse(format!("Bad register: {}", name).into(), at.clone()))?;
        }
        let val: u8 = rn.parse().err_pos(at)?;
        Ok(Register::Arg(val))
    } else if let Some(rn) = name.strip_prefix("res") {
        if rn.chars().find(|c: &char| !c.is_ascii_digit()).is_some() {
            return Err(CrsnError::Parse(format!("Bad register: {}", name).into(), at.clone()))?;
        }
        let val: u8 = rn.parse().err_pos(at)?;
        Ok(Register::Res(val))
    } else if let Some(rn) = name.strip_prefix("r") {
        if rn.chars().find(|c: &char| !c.is_ascii_digit()).is_some() {
            return Err(CrsnError::Parse(format!("Bad register: {}", name).into(), at.clone()))?;
        }
        let val: u8 = rn.parse().err_pos(at)?;
        Ok(Register::Gen(val))
    } else if let Some(rn) = name.strip_prefix("g") {
        if rn.chars().find(|c: &char| !c.is_ascii_digit()).is_some() {
            return Err(CrsnError::Parse(format!("Bad register: {}", name).into(), at.clone()))?;
        }
        let val: u8 = rn.parse().err_pos(at)?;
        Ok(Register::Global(val))
    } else {
        Err(CrsnError::Parse(format!("Bad reg name: {}", name).into(), at.clone()))?
    }
}