//! Bytecode and related structures
// all bytecode should fit within a u32, so
// all instructions look like:
// - INST (8bits) A (24bits) (shape A)
// - INST (8bits) A (8bits) B (16bits) (shape B)
// - INST (8bits) A (8bits) B (8bits) C (8bits) (shape C)
// NOTE Endianness is undefined for now as this is not meant to be serialized.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum OpCode {
    NoOp,
}
impl From<OpCode> for u8 {
    fn from(value: OpCode) -> Self {
        match value {
            OpCode::NoOp => 0,
        }
    }
}
impl TryFrom<u8> for OpCode {
    // There is only 1 possible error: the u8 doesn't represent a valid op-code
    type Error = ();
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::NoOp),
            _ => Err(()),
        }
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpArguments {
    A(u32), // first 8 bits are ignored
    B(u8, u16),
    C(u8, u8, u8),
}
impl OpArguments {
    const ARGUMENT_MASK: u32 = 0x00ff_ffff;
    // Private cuz
    fn stitch(self) -> u32 {
        match self {
            Self::A(a) => a & Self::ARGUMENT_MASK,
            Self::B(a, b) => ((a as u32) << 16) | (b as u32),
            Self::C(a, b, c) => ((a as u32) << 16) | ((b as u32) << 8) | (c as u32),
        }
    }
    fn parse_a(n: u32) -> Self {
        let masked = n & Self::ARGUMENT_MASK;
        Self::A(masked)
    }
    fn parse_b(n: u32) -> Self {
        let masked = n & Self::ARGUMENT_MASK;
        Self::B((masked >> 16) as u8, masked as u16)
    }
    fn parse_c(n: u32) -> Self {
        let masked = n & Self::ARGUMENT_MASK;
        Self::C((masked >> 16) as u8, (masked >> 8) as u8, masked as u8)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ByteCode {
    op_code: OpCode,
    arguments: OpArguments,
}
impl ByteCode {
    /// Produces a single number representing this code
    pub fn stitch(self) -> u32 {
        ((self.op_code as u32) << 24) | self.arguments.stitch()
    }
    pub fn parse(n: u32) -> Option<Self> {
        // Get the op code
        let op_code = (((n & !OpArguments::ARGUMENT_MASK) >> 24) as u8)
            .try_into()
            .ok()?;
        // The only fallible part is getting the opcode. All other operations are infallible
        Some(match op_code {
            OpCode::NoOp => Self {
                op_code,
                arguments: OpArguments::parse_a(n),
            },
        })
    }
}
impl TryFrom<u32> for ByteCode {
    type Error = ();
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        Self::parse(value).ok_or(())
    }
}
#[cfg(test)]
mod tests {
    use super::{ByteCode, OpArguments, OpCode};
    use assert2::assert;
    #[test]
    fn bytecode_parse() {
        let code = 0x00debeef;
        let op = ByteCode::parse(code);
        assert!(
            op == Some(ByteCode {
                op_code: OpCode::NoOp,
                arguments: OpArguments::A(0xdebeef)
            })
        );
        let code = 0x01adbeef;
        let op = ByteCode::parse(code);
        assert!(op == None);
    }
    #[test]
    fn bytecode_stitch() {
        let bc = ByteCode {
            op_code: OpCode::NoOp,
            arguments: OpArguments::C(0xca, 0xbe, 0xef),
        };
        assert!(bc.stitch() == 0x00cabeef);
    }
}

    fn symbol_element_parse(input: &mut &str) -> PResult<Vec<char>> {
        repeat(
            0..,
            alt((
                delimited(r"\x", hex_digit1, r";").try_map(|s: &str| {
                    Ok::<_, ParseIntError>(
                        char::from_u32(u32::from_str_radix(s, 16)?)
                            .unwrap_or(char::REPLACEMENT_CHARACTER),
                    )
                }),
                preceded(r"\", one_of(['a', 'b', 't', 'n', 'r'])).map(|c| match c {
                    'a' => 7 as char,
                    'b' => 8 as char,
                    't' => 9 as char,
                    'n' => 0xa as char,
                    'r' => 0xd as char,
                    _ => unreachable!(r"Scheme R7RS only handles \a, \b, \t, \n, and \r"),
                }),
                any,
            )),
        )
        .parse_next(input)
    }
    fn parse_to_symbol_elements(lex: &mut Lexer<Token>) -> Result<String, LexError> {
        let slice = lex.slice();
        let target = &slice[1..slice.len() - 1];
        symbol_element_parse
            .parse(target)
            .map(|vc| vc.into_iter().collect())
            .map_err(|e| {
                // TODO A proper lex error (for ident symbols!)
                dbg!(std::any::type_name_of_val(&e));
                LexError::Unknown
            })
    }
    fn string_element_parse(input: &mut &str) -> PResult<Vec<char>> {
        repeat(
            0..,
            alt((
                delimited(r"\x", hex_digit1, r";")
                    .try_map(|s: &str| {
                        Ok::<_, ParseIntError>(
                            char::from_u32(u32::from_str_radix(s, 16)?)
                                .unwrap_or(char::REPLACEMENT_CHARACTER),
                        )
                    })
                    .map(Some),
                preceded(r"\", one_of(['a', 'b', 't', 'n', 'r', '"', '\\', '|']))
                    .map(|c| match c {
                        'a' => 7 as char,
                        'b' => 8 as char,
                        't' => 9 as char,
                        'n' => 0xa as char,
                        'r' => 0xd as char,
                        '"' => 0x22 as char,
                        '\\' => 0x5c as char,
                        '|' => 0x7c as char,
                        _ => unreachable!(
                            r#"Scheme R7RS strings only handle \a, \b, \t, \n, \r, \", \\, and \|"#
                        ),
                    })
                    .map(Some),
                delimited(
                    repeat::<_, _, (), _, _>(0.., one_of([' ', '\t', '\r'])),
                    '\n'.void(),
                    repeat::<_, _, (), _, _>(0.., one_of([' ', '\t', '\r'])),
                )
                .map(|_| None),
                any.map(Some),
            )),
        )
        .map(|vc: Vec<Option<char>>| vc.into_iter().flatten().collect())
        .parse_next(input)
    }
    fn parse_to_string(lex: &mut Lexer<Token>) -> Result<String, LexError> {
        let slice = lex.slice();
        let target = &slice[1..slice.len() - 1];
        string_element_parse
            .parse(target)
            .map(|vc| vc.into_iter().collect())
            .map_err(|e| {
                // TODO A proper lex error
                dbg!(std::any::type_name_of_val(&e));
                LexError::Unknown
            })
    }
    fn integer_number_parser(input: &mut &str) -> PResult<(i64, u32)> {
        let sign = opt(one_of(['-', '+']));
        let digits_with_underscores = || {
            repeat(1.., alt((digit1.map(Some), '_'.map(|_| None))))
                .map(|vd: Vec<Option<&str>>| vd.into_iter().flatten().collect::<Vec<_>>().join(""))
        };
        let signed_digits_with_underscores =
            (sign, digits_with_underscores()).map(|(sign, digits): (_, String)| {
                if let Some(sign) = sign {
                    format!("{sign}{digits}")
                } else {
                    digits
                }
            });
        let exponent = preceded("e", (opt('+').void(), digits_with_underscores()));
        (signed_digits_with_underscores, opt(exponent))
            .try_map(|(base, maybe_exp)| {
                let base = base.parse::<i64>()?;
                let exponent = if let Some((_, exponent)) = maybe_exp {
                    exponent.parse::<u32>()?
                } else {
                    0
                };
                Ok::<_, ParseIntError>((base, exponent))
            })
            .parse_next(input)
    }
    fn parse_integer(lexer: &mut Lexer<Token>) -> Result<(i64, u32), LexError> {
        let target = lexer.slice();
        integer_number_parser.parse(target).map_err(|e| {
            // TODO A proper lex error
            dbg!(std::any::type_name_of_val(&e));
            LexError::Unknown
        })
    }
    #[derive(thiserror::Error, Debug)]
    pub enum DecimalParseError {
        #[error(transparent)]
        FloatError(#[from] ParseFloatError),
        #[error(transparent)]
        IntError(#[from] ParseIntError),
    }
    fn decimal_number_parser(input: &mut &str) -> PResult<(f64, i32)> {
        let sign = || opt(one_of(['-', '+']));
        let digits_with_underscores = || {
            repeat(1.., alt((digit1.map(Some), '_'.map(|_| None))))
                .map(|vd: Vec<Option<&str>>| vd.into_iter().flatten().collect::<Vec<_>>().join(""))
        };
        let float_digits = || {
            (
                opt(digits_with_underscores()),
                '.',
                digits_with_underscores(),
            )
                .map(|(maybe_predot, _, postdot)| {
                    maybe_predot
                        .map(|predot| format!("{predot}.{postdot}"))
                        .unwrap_or_else(|| format!(".{postdot}"))
                })
        };
        let signed_base = (sign(), alt((float_digits(), digits_with_underscores()))).map(
            |(sign, digits): (_, String)| {
                if let Some(sign) = sign {
                    format!("{sign}{digits}")
                } else {
                    digits
                }
            },
        );
        let exponent = preceded("e", (sign(), digits_with_underscores()));
        (signed_base, opt(exponent))
            .try_map(|(base, maybe_exp)| {
                let base = base.parse::<f64>()?;
                let exponent = if let Some((sign, exponent)) = maybe_exp {
                    let signed = if let Some(sign) = sign {
                        format!("{sign}{exponent}")
                    } else {
                        exponent
                    };
                    signed.parse::<i32>()?
                } else {
                    0
                };
                Ok::<_, DecimalParseError>((base, exponent))
            })
            .parse_next(input)
    }
    fn parse_float(lexer: &mut Lexer<Token>) -> Result<(f64, i32), LexError> {
        let target = lexer.slice();
        decimal_number_parser.parse(target).map_err(|e| {
            // TODO A proper lex error
            dbg!(std::any::type_name_of_val(&e));
            LexError::Unknown
        })
    }
    #[derive(Debug, Clone, PartialEq, Logos)]
    #[logos(error = LexError)]
    pub enum Token {
        #[token("(")]
        LParen,
        #[token(")")]
        RParen,
        #[regex(r"[ \t\r]+")]
        Whitespace,
        #[regex(r"[A-Za-z!$%&*+\-./:<=>?@^_-][A-Za-z0-9!$%&*+\-./:<=>?@^_-]*", |lex| lex.slice().to_string())]
        #[regex(r"\|(?:\\x[0-9a-fA-F]+;|\\[abtnr]|[^|])*\|", parse_to_symbol_elements)]
        Identifier(String),
        #[regex(
            r#""(?:\\x[0-9a-fA-F]+;|\\[abtnr"\\|]|\\[ \t\r]*\n[ \t\r]*|[^"])*""#,
            parse_to_string
        )]
        String(String),
        // TODO lexers for num, complex, real
        #[regex(r"[+-]?[0-9][0-9_]*", priority = 3, callback = parse_integer)]
        #[regex(r"[+-]?[0-9][0-9_]*e\+?[0-9_]+", callback = parse_integer)]
        Integer((i64, u32)),
        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9][0-9_]*", parse_float)]
        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9][0-9_]*e[+-]?[0-9_]+", parse_float)]
        #[regex(r"[+-]?\.[0-9][0-9_]*", parse_float)]
        #[regex(r"[+-]?\.[0-9][0-9_]*e[+-]?[0-9_]+", parse_float)]
        #[regex(r"[+-]?[0-9][0-9_]*e\-[0-9_]+", parse_float)] // Negative exponent
        Decimal((f64, i32)),
        #[token("+inf.0")]
        InfinityPos,
        #[token("-inf.0")]
        InifinityNeg,
        #[token("+nan.0")]
        NotANumberPos,
        #[token("-nan.0")]
        NotANumberNeg,
        #[token("+i")]
        ImaginaryPos,
        #[token("-i")]
        ImaginaryNeg,
        #[token(".", priority = 3)]
        Dot,
        #[token("'")]
        QuoteSymbol,
        #[token("`")]
        QuasiquoteSymbol,
        #[token(",")]
        UnquoteSymbol,
        #[token(",@")]
        UnquoteSplicingSymbol,
        #[token(";")]
        LineCommentStart,
        #[regex(r"\n+")]
        LineEnd,
        #[token("#;")]
        DatumCommentStart,
        #[token("#|")]
        BlockCommentStart,
        #[token("|#")]
        BlockCommentEnd,
    }
    pub fn lexer(input: &str) -> Lexer<'_, Token> {
        Token::lexer(input)
    }
    #[cfg(test)]
    mod tests {
        use super::Token;
        use assert2::assert;
        use logos::Logos;
        #[test]
        fn lex_decimal() {
            let source = r"0.0 -0.0e0 -.0 .0e0 0e-1";
            let data = [
                ((0.0, 0), (0..3), "0.0"),
                ((-0.0, 0), (4..10), "-0.0e0"),
                ((-0.0, 0), (11..14), "-.0"),
                ((0.0, 0), (15..19), ".0e0"),
                ((0.0, -1), (20..24), "0e-1"),
            ];
            let lexer = Token::lexer(source);
            for ((_, (tok, span)), (parsed, tspan, tslice)) in lexer
                .spanned()
                .enumerate()
                // Skip all odd-indexed tokens (it's whitespace)
                .filter(|(idx, _)| idx % 2 == 0)
                .zip(data.into_iter())
            {
                let slice = &source[span.clone()];
                assert!(tok == Ok(Token::Decimal(parsed)));
                assert!(span == tspan);
                assert!(slice == tslice);
            }
        }
        #[test]
        fn literal_identfier_equivalence() {
            let source = r"|\t\t||\x9;\x9;|";
            let mut lexer = Token::lexer(source);
            let tok1 = lexer.next();
            let tok1_slice = lexer.slice();
            let tok2 = lexer.next();
            let tok2_slice = lexer.slice();
            assert!(tok1 == tok2);
            assert!(tok1_slice != tok2_slice);
        }
        #[test]
        fn lex_literal_identifier() {
            let source = r"|H\x65;llo|";
            let mut lexer = Token::lexer(source);
            assert!(lexer.next() == Some(Ok(Token::Identifier("Hello".to_string()))));
            assert!(lexer.span() == (0..source.len()));
            assert!(lexer.slice() == "|H\\x65;llo|");
        }
        #[test]
        fn lex_identifier_or_number() {
            let source = "3let -i";
            let mut lexer = Token::lexer(source);
            assert!(lexer.next() == Some(Ok(Token::Integer((3, 0)))));
            assert!(lexer.span() == (0..1));
            assert!(lexer.slice() == "3");
            assert!(lexer.next() == Some(Ok(Token::Identifier("let".to_string()))));
            assert!(lexer.span() == (1..4));
            assert!(lexer.slice() == "let");
            assert!(lexer.next() == Some(Ok(Token::Whitespace)));
            assert!(lexer.span() == (4..5));
            assert!(lexer.slice() == " ");
            assert!(lexer.next() == Some(Ok(Token::ImaginaryNeg)));
            assert!(lexer.span() == (5..7));
            assert!(lexer.slice() == "-i");
        }
        #[test]
        fn lex_identifier() {
            let source = "+soup+ $?bama";
            let mut lexer = Token::lexer(source);
            assert!(lexer.next() == Some(Ok(Token::Identifier("+soup+".to_string()))));
            assert!(lexer.span() == (0..6));
            assert!(lexer.slice() == "+soup+");
            assert!(lexer.next() == Some(Ok(Token::Whitespace)));
            assert!(lexer.span() == (6..7));
            assert!(lexer.slice() == " ");
            assert!(lexer.next() == Some(Ok(Token::Identifier("$?bama".to_string()))));
            assert!(lexer.span() == (7..13));
            assert!(lexer.slice() == "$?bama");
        }
    }
}

pub mod bytecode;