use crate::*;


pub struct SyntacticToken {
    pub source: SourceSpan,
    pub variant: SyntacticTokenVariant,
}

pub enum SyntacticTokenVariant {
    LabelDefinition(String),
    MacroDefinition(String),
    MacroDefinitionTerminator,

    IntegerLiteral(isize),
    PackedBinaryLiteral(PackedBinaryLiteral),
    PinnedAddress(usize),

    Expression(Expression),

    String(TrackedString),

    BlockOpen,
    BlockClose,
    Separator,

    Symbol(String),

    Error(SyntacticParseError),
}

#[derive(Clone)]
pub struct TrackedString {
    pub source: SourceSpan,
    pub string: String,
    pub chars: Vec<Tracked<char>>,
}

impl std::fmt::Display for TrackedString {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        self.string.fmt(f)
    }
}

#[derive(Debug)]
pub enum SyntacticParseError {
    InvalidHexadecimalLiteral(String),
    InvalidDecimalLiteral(String),
    InvalidSymbolIdentifier(String),
    UnterminatedComment,
    UnterminatedString,
    UnterminatedExpression,
    LabelInMacroDefinition,
}


impl std::fmt::Debug for SyntacticToken {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        use SyntacticTokenVariant::*;
        let start = &self.source.in_merged;
        let name = match &self.variant {
            LabelDefinition(name) => format!("LabelDefinition({name})"),
            MacroDefinition(name) => format!("MacroDefinition({name})"),
            MacroDefinitionTerminator => format!("MacroDefinitionTerminator"),

            IntegerLiteral(value) => format!("IntegerLiteral({value})"),
            PackedBinaryLiteral(pbl) => format!("PackedBinaryLiteral({pbl})"),
            PinnedAddress(value) => format!("PinnedAddress({value})"),

            Expression(expr) => format!("Expression({expr:?})"),

            String(string) => format!("String('{string}')"),

            BlockOpen => format!("BlockOpen"),
            BlockClose => format!("BlockClose"),
            Separator => format!("Separator"),

            Symbol(name) => format!("Symbol({name})"),

            Error(error) => format!("Error({error:?})"),
        };

        write!(f, "{start} {name}")
    }
}