use regex::Regex;
use serde_with::{DeserializeFromStr, SerializeDisplay};
use std::str::FromStr;
use std::{fmt, sync::LazyLock};

use crate::{
    fn_suffix::SuffixKind,
    predicate_forms::PredicationMask,
    typekinds::{ToRepr, TypeKind, TypeKindOptions, VectorTupleSize},
};

#[derive(Debug, Clone, PartialEq, Eq, Hash, SerializeDisplay, DeserializeFromStr)]
pub enum Wildcard {
    Type(Option<usize>),
    /// NEON type derivated by a base type
    NEONType(Option<usize>, Option<VectorTupleSize>, Option<SuffixKind>),
    /// SVE type derivated by a base type
    SVEType(Option<usize>, Option<VectorTupleSize>),
    /// Integer representation of bitsize
    Size(Option<usize>),
    /// Integer representation of bitsize minus one
    SizeMinusOne(Option<usize>),
    /// Literal representation of the bitsize: b(yte), h(half), w(ord) or d(ouble)
    SizeLiteral(Option<usize>),
    /// Literal representation of the type kind: f(loat), s(igned), u(nsigned)
    TypeKind(Option<usize>, Option<TypeKindOptions>),
    /// Log2 of the size in bytes
    SizeInBytesLog2(Option<usize>),
    /// Predicate to be inferred from the specified type
    Predicate(Option<usize>),
    /// Predicate to be inferred from the greatest type
    MaxPredicate,

    Scale(Box<Wildcard>, Box<TypeKind>),

    // Other wildcards
    LLVMLink,
    NVariant,
    /// Predicate forms to use and placeholder for a predicate form function name modifier
    PredicateForms(PredicationMask),

    /// User-set wildcard through `substitutions`
    Custom(String),
}

impl Wildcard {
    pub fn is_nonpredicate_type(&self) -> bool {
        matches!(
            self,
            Wildcard::Type(..) | Wildcard::NEONType(..) | Wildcard::SVEType(..)
        )
    }

    pub fn get_typeset_index(&self) -> Option<usize> {
        match self {
            Wildcard::Type(idx) | Wildcard::NEONType(idx, ..) | Wildcard::SVEType(idx, ..) => {
                Some(idx.unwrap_or(0))
            }
            _ => None,
        }
    }
}

impl FromStr for Wildcard {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        static RE: LazyLock<Regex> = LazyLock::new(|| {
            Regex::new(r"^(?P<wildcard>\w+?)(?:_x(?P<tuple_size>[2-4]))?(?:\[(?P<index>\d+)\])?(?:\.(?P<modifiers>\w+))?(?:\s+as\s+(?P<scale_to>.*?))?$").unwrap()
        });

        if let Some(c) = RE.captures(s) {
            let wildcard_name = &c["wildcard"];
            let inputset_index = c
                .name("index")
                .map(<&str>::from)
                .map(usize::from_str)
                .transpose()
                .map_err(|_| format!("{:#?} is not a valid type index", &c["index"]))?;
            let tuple_size = c
                .name("tuple_size")
                .map(<&str>::from)
                .map(VectorTupleSize::from_str)
                .transpose()
                .map_err(|_| format!("{:#?} is not a valid tuple size", &c["tuple_size"]))?;
            let modifiers = c.name("modifiers").map(<&str>::from);

            let wildcard = match (wildcard_name, inputset_index, tuple_size, modifiers) {
                ("type", index, None, None) => Ok(Wildcard::Type(index)),
                ("neon_type", index, tuple, modifier) => {
                    if let Some(str_suffix) = modifier {
                        let suffix_kind = SuffixKind::from_str(str_suffix);
                        return Ok(Wildcard::NEONType(index, tuple, Some(suffix_kind.unwrap())));
                    } else {
                        Ok(Wildcard::NEONType(index, tuple, None))
                    }
                }
                ("sve_type", index, tuple, None) => Ok(Wildcard::SVEType(index, tuple)),
                ("size", index, None, None) => Ok(Wildcard::Size(index)),
                ("size_minus_one", index, None, None) => Ok(Wildcard::SizeMinusOne(index)),
                ("size_literal", index, None, None) => Ok(Wildcard::SizeLiteral(index)),
                ("type_kind", index, None, modifiers) => Ok(Wildcard::TypeKind(
                    index,
                    modifiers.map(|modifiers| modifiers.parse()).transpose()?,
                )),
                ("size_in_bytes_log2", index, None, None) => Ok(Wildcard::SizeInBytesLog2(index)),
                ("predicate", index, None, None) => Ok(Wildcard::Predicate(index)),
                ("max_predicate", None, None, None) => Ok(Wildcard::MaxPredicate),
                ("llvm_link", None, None, None) => Ok(Wildcard::LLVMLink),
                ("_n", None, None, None) => Ok(Wildcard::NVariant),
                (w, None, None, None) if w.starts_with('_') => {
                    // test for predicate forms
                    let pf_mask = PredicationMask::from_str(&w[1..]);
                    if let Ok(mask) = pf_mask {
                        if mask.has_merging() {
                            Ok(Wildcard::PredicateForms(mask))
                        } else {
                            Err("cannot add predication without a Merging form".to_string())
                        }
                    } else {
                        Err(format!("invalid wildcard `{s:#?}`"))
                    }
                }
                (cw, None, None, None) => Ok(Wildcard::Custom(cw.to_string())),
                _ => Err(format!("invalid wildcard `{s:#?}`")),
            }?;

            let scale_to = c
                .name("scale_to")
                .map(<&str>::from)
                .map(TypeKind::from_str)
                .transpose()
                .map_err(|_| format!("{:#?} is not a valid type", &c["scale_to"]))?;

            if let Some(scale_to) = scale_to {
                Ok(Wildcard::Scale(Box::new(wildcard), Box::new(scale_to)))
            } else {
                Ok(wildcard)
            }
        } else {
            Err(format!("## invalid wildcard `{s:#?}`"))
        }
    }
}

impl fmt::Display for Wildcard {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Type(None) => write!(f, "type"),
            Self::Type(Some(index)) => write!(f, "type[{index}]"),
            Self::NEONType(None, None, None) => write!(f, "neon_type"),
            Self::NEONType(None, None, Some(suffix_kind)) => write!(f, "neon_type.{suffix_kind}"),
            Self::NEONType(Some(index), None, None) => write!(f, "neon_type[{index}]"),
            Self::NEONType(Some(index), None, Some(suffix_kind)) => {
                write!(f, "neon_type[{index}].{suffix_kind}")
            }
            Self::NEONType(None, Some(tuple_size), Some(suffix_kind)) => {
                write!(f, "neon_type_x{tuple_size}.{suffix_kind}")
            }
            Self::NEONType(None, Some(tuple_size), None) => write!(f, "neon_type_x{tuple_size}"),
            Self::NEONType(Some(index), Some(tuple_size), None) => {
                write!(f, "neon_type_x{tuple_size}[{index}]")
            }
            Self::NEONType(Some(index), Some(tuple_size), Some(suffix_kind)) => {
                write!(f, "neon_type_x{tuple_size}[{index}].{suffix_kind}")
            }
            Self::SVEType(None, None) => write!(f, "sve_type"),
            Self::SVEType(Some(index), None) => write!(f, "sve_type[{index}]"),
            Self::SVEType(None, Some(tuple_size)) => write!(f, "sve_type_x{tuple_size}"),
            Self::SVEType(Some(index), Some(tuple_size)) => {
                write!(f, "sve_type_x{tuple_size}[{index}]")
            }
            Self::Size(None) => write!(f, "size"),
            Self::Size(Some(index)) => write!(f, "size[{index}]"),
            Self::SizeMinusOne(None) => write!(f, "size_minus_one"),
            Self::SizeMinusOne(Some(index)) => write!(f, "size_minus_one[{index}]"),
            Self::SizeLiteral(None) => write!(f, "size_literal"),
            Self::SizeLiteral(Some(index)) => write!(f, "size_literal[{index}]"),
            Self::TypeKind(None, None) => write!(f, "type_kind"),
            Self::TypeKind(None, Some(opts)) => write!(f, "type_kind.{opts}"),
            Self::TypeKind(Some(index), None) => write!(f, "type_kind[{index}]"),
            Self::TypeKind(Some(index), Some(opts)) => write!(f, "type_kind[{index}].{opts}"),
            Self::SizeInBytesLog2(None) => write!(f, "size_in_bytes_log2"),
            Self::SizeInBytesLog2(Some(index)) => write!(f, "size_in_bytes_log2[{index}]"),
            Self::Predicate(None) => write!(f, "predicate"),
            Self::Predicate(Some(index)) => write!(f, "predicate[{index}]"),
            Self::MaxPredicate => write!(f, "max_predicate"),
            Self::LLVMLink => write!(f, "llvm_link"),
            Self::NVariant => write!(f, "_n"),
            Self::PredicateForms(mask) => write!(f, "_{mask}"),

            Self::Scale(wildcard, ty) => write!(f, "{wildcard} as {}", ty.rust_repr()),
            Self::Custom(cw) => write!(f, "{cw}"),
        }
    }
}