df_ls_debug_structure 0.3.0-rc.1

#![forbid(unsafe_code)]
#![deny(clippy::all)]

mod debug_raw;
mod unary_token_multiple_arguments;

pub use debug_raw::DebugRaw;
use df_ls_core::{
    AllowEmpty, Any, ArgN, BangArgNSequence, Choose, Clamp, DFChar, PipeArguments, Reference,
    ReferenceTo, Referenceable,
};
use df_ls_syntax_analysis::TokenDeserialize;
pub use unary_token_multiple_arguments::DebugUnaryTokenEnum;

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq)]
pub struct RefToken {
    /// Argument 1
    #[token_de(token = "REF")]
    pub reference: Option<Reference>,
    /// Token `NAME`
    #[token_de(token = "NAME")]
    pub name: Vec<String>,
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq)]
#[token_de(second_par_check, token = "MAIN")]
pub struct MainToken {
    #[token_de(token = "TYPE1")]
    pub type_1: Vec<Type1Token>,
    #[token_de(token = "TYPE2")]
    pub type_2: Vec<Type2Token>,
    #[token_de(token = "TYPE3")]
    pub type_3: Vec<String>,
    #[token_de(token = "TYPE4")]
    pub type_4: Vec<Type4Token>,
    #[token_de(token = "PROFESSION")]
    pub professions: Vec<ProfessionToken>,

    #[token_de(token = "DEBUG")]
    pub debug: Vec<DebugTokens>,
}

/// List for easy debug
#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq)]
pub struct DebugTokens {
    #[token_de(token = "ALLOW_EMPTY")]
    pub allow_empty: Vec<AllowEmpty<Any>>,
    #[token_de(token = "ANY")]
    pub any: Vec<Any>,
    #[token_de(token = "ARG_N")]
    pub arg_n: Vec<ArgN>,
    #[token_de(token = "ARG_N_2")]
    pub arg_n_2: Option<ArgN>,
    #[token_de(token = "ARG_N_CLAMP")]
    pub arg_n_clamp: Vec<Clamp<ArgN, 1, 5>>,
    #[token_de(token = "BOOL")]
    pub ref_bool: Vec<bool>,
    #[token_de(token = "CHAR")]
    pub ref_char: Vec<char>,
    #[token_de(token = "CHOOSE")]
    pub choose: Vec<Choose<i32, String>>,
    #[token_de(token = "DF_CHAR")]
    pub df_char: Vec<DFChar>,
    #[token_de(token = "INT_1")]
    pub int_1: Vec<i32>,
    #[token_de(token = "INT_2")]
    pub int_2: Vec<u32>,
    #[token_de(token = "OPTION")]
    pub option: Vec<Option<u32>>,
    #[token_de(token = "REF_TO")]
    pub reference_to: Vec<ReferenceTo<ProfessionToken>>,
    #[token_de(token = "REF")]
    pub reference: Vec<Reference>,
    #[token_de(token = "STRING")]
    pub string: Vec<String>,
    #[token_de(token = "TUPLE")]
    pub tuple: Vec<(i32, u32, String)>,
    #[token_de(token = "VEC")]
    pub vec: Vec<(Vec<u32>,)>,
    #[token_de(token = "PIPE_ARG")]
    pub pipe_arg: Vec<PipeArguments>,
    #[token_de(token = "TUPLE_PIPE_ARG")]
    pub tuple_pipe_arg: Vec<(i32, PipeArguments, i32)>,
    #[token_de(token = "BANG_ARG_N_SEQ")]
    pub bang_arg_n_seq: Vec<BangArgNSequence>,
    #[token_de(token = "BANG_ARG_N_SEQ_CLAMP")]
    pub bang_arg_n_seq_clamp: Vec<Clamp<BangArgNSequence, 1, 5>>,
    #[token_de(token = "ENUM_VALUE_VEC")]
    pub enum_value: Vec<(Vec<DebugEnum>,)>,
    #[token_de(token = "UNARY_TOKEN_MULTI_ARG")]
    pub unary_token_multi_arg: Vec<DebugUnaryTokenEnum>,
}

#[derive(Clone, Debug, TokenDeserialize, PartialEq, Eq)]
#[token_de(enum_value)]
pub enum DebugEnum {
    #[token_de(token = "ENUM1")]
    Enum1,
    #[token_de(token = "ENUM2")]
    Enum2,
    #[token_de(token = "ENUM3")]
    Enum3,
    #[token_de(token = "ENUM4")]
    Enum4,
}
impl Default for DebugEnum {
    fn default() -> Self {
        Self::Enum1
    }
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq)]
pub struct Type1Token {
    /// Argument 1
    #[token_de(token = "TYPE1", on_duplicate_to_parent, primary_token)]
    pub reference: Option<Reference>,
    /// Token `NAME`
    #[token_de(token = "ITEM")]
    pub list: Vec<Reference>,
}

#[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug, TokenDeserialize, PartialEq, Eq)]
pub enum Type2Token {
    #[token_de(token = "UNIPEDAL")]
    Unipedal(String),
    #[token_de(token = "BIPEDAL")]
    Bipedal(HumanToken),
    #[token_de(token = "TRIPEDAL")]
    Tripedal(RefToken),
    #[token_de(token = "4LEGS")]
    Quadrupedal(RefToken),
}
impl Default for Type2Token {
    fn default() -> Self {
        Self::Unipedal(String::default())
    }
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq, Referenceable)]
pub struct HumanToken {
    /// Argument 1
    #[token_de(token = "BIPEDAL", on_duplicate_to_parent, primary_token)]
    #[referenceable(self_reference)]
    pub reference: Option<ReferenceTo<Self>>,
    /// Token `NAME`
    #[token_de(token = "NAME")]
    pub name: Option<String>,
    #[token_de(token = "DEAD", on_duplicate_error)]
    pub death: Option<()>,
    #[token_de(token = "SYMBOL")]
    pub symbol: Option<AllowEmpty<char>>,
    #[token_de(token = "GENDER")]
    pub gender: Option<GenderEnum>,
    #[token_de(token = "AGE")]
    pub age: Option<u8>,
    #[token_de(token = "JOB")]
    pub jobs: Vec<String>,
    #[token_de(token = "EDUCATION")]
    pub educations: Vec<(String, String, u8)>,
    #[token_de(token = "HOBBY")]
    pub hobbies: Vec<Choose<Reference, String>>,
    #[token_de(token = "MAIN_PROFESSION")]
    pub main_profession: Option<Choose<Reference, String>>,
    #[allow(clippy::type_complexity)]
    #[token_de(token = "MULTI")]
    pub multi_choose: Option<Choose<Reference, Choose<Choose<u32, i32>, DFChar>>>,
    #[token_de(token = "PROFESSION")]
    pub profession: Option<ProfessionToken>,
    #[token_de(token = "PROFESSIONS")]
    pub professions: Vec<(ReferenceTo<ProfessionToken>, u8)>,
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq, Referenceable)]
pub struct ProfessionToken {
    #[token_de(token = "PROFESSION", on_duplicate_to_parent, primary_token)]
    #[referenceable(self_reference)]
    pub reference: Option<ReferenceTo<Self>>,
    #[token_de(token = "NAME", alias = "JOB")]
    pub name: Vec<Reference>,
    #[token_de(token = "GENDER")]
    pub genders: Vec<GenderEnum>,
    #[token_de(token = "HAND")]
    pub handedness: Option<Choose<u8, HandednessEnum>>,
    /// Optional arguments
    #[token_de(token = "ARG")]
    pub argument: Option<(String, Option<String>)>,
    /// Optional arguments
    #[token_de(token = "ARG_VEC")]
    pub arguments: Vec<(String, Option<String>)>,
    #[token_de(token = "SYMBOL")]
    pub symbol: Option<DFChar>,
    #[token_de(token = "DIFFICULTY")]
    pub difficulty: Option<u8>,
    #[token_de(token = "DIFFICULTY_HARD", on_duplicate_error)]
    pub difficulty_hard: Option<u8>,
    #[token_de(token = "TOOL")]
    pub tool: Option<ToolToken>,
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq, Referenceable)]
pub struct ToolToken {
    #[token_de(token = "TOOL", on_duplicate_to_parent, primary_token)]
    #[referenceable(self_reference)]
    pub reference: Option<ReferenceTo<Self>>,
    #[token_de(token = "NAME")]
    pub name: Option<String>,
}

#[derive(Clone, Debug, TokenDeserialize, PartialEq, Eq)]
#[token_de(enum_value)]
pub enum GenderEnum {
    #[token_de(token = "MALE")]
    Male,
    #[token_de(token = "FEMALE")]
    Female,
    #[token_de(token = "OTHER")]
    Other,
}

impl Default for GenderEnum {
    fn default() -> Self {
        Self::Other
    }
}

#[derive(Clone, Debug, TokenDeserialize, PartialEq, Eq)]
#[token_de(enum_value)]
pub enum HandednessEnum {
    #[token_de(token = "LEFT")]
    Left,
    #[token_de(token = "RIGHT")]
    Right,
    #[token_de(token = "AMBIDEXTROUS")]
    Ambidextrous,
    #[token_de(token = "NO_HANDS")]
    NoHands,
}

impl Default for HandednessEnum {
    fn default() -> Self {
        Self::Right
    }
}

#[derive(Clone, Debug, Default, TokenDeserialize, PartialEq, Eq, Referenceable)]
pub struct Type4Token {
    /// Argument 1
    #[token_de(token = "TYPE4", on_duplicate_to_parent, primary_token)]
    #[referenceable(self_reference)]
    pub reference: Option<(String, ReferenceTo<Self>, String, String)>,
    /// Token `NAME`
    #[token_de(token = "NAME")]
    pub name: Option<String>,
}