use crate::ast::*;
use crate::parser::*;
use nom::branch::*;
use nom::bytes::complete::*;
use nom::character::complete::*;
use nom::combinator::*;
use nom::multi::*;
use nom::sequence::*;
use nom::IResult;

// -----------------------------------------------------------------------------

#[derive(Debug, Node)]
pub enum Number<'a> {
    IntegralNumber(IntegralNumber<'a>),
    RealNumber(RealNumber<'a>),
}

#[derive(Debug, Node)]
pub enum IntegralNumber<'a> {
    DecimalNumber(DecimalNumber<'a>),
    OctalNumber(OctalNumber<'a>),
    BinaryNumber(BinaryNumber<'a>),
    HexNumber(HexNumber<'a>),
}

#[derive(Debug, Node)]
pub enum DecimalNumber<'a> {
    UnsignedNumber(UnsignedNumber<'a>),
    BaseUnsigned(DecimalNumberBaseUnsigned<'a>),
    BaseXNumber(DecimalNumberBaseXNumber<'a>),
    BaseZNumber(DecimalNumberBaseZNumber<'a>),
}

#[derive(Debug, Node)]
pub struct DecimalNumberBaseUnsigned<'a> {
    pub nodes: (Option<Size<'a>>, DecimalBase<'a>, UnsignedNumber<'a>),
}

#[derive(Debug, Node)]
pub struct DecimalNumberBaseXNumber<'a> {
    pub nodes: (Option<Size<'a>>, DecimalBase<'a>, XNumber<'a>),
}

#[derive(Debug, Node)]
pub struct DecimalNumberBaseZNumber<'a> {
    pub nodes: (Option<Size<'a>>, DecimalBase<'a>, ZNumber<'a>),
}

#[derive(Debug, Node)]
pub struct BinaryNumber<'a> {
    pub nodes: (Option<Size<'a>>, BinaryBase<'a>, BinaryValue<'a>),
}

#[derive(Debug, Node)]
pub struct OctalNumber<'a> {
    pub nodes: (Option<Size<'a>>, OctalBase<'a>, OctalValue<'a>),
}

#[derive(Debug, Node)]
pub struct HexNumber<'a> {
    pub nodes: (Option<Size<'a>>, HexBase<'a>, HexValue<'a>),
}

#[derive(Debug, Node)]
pub enum Sign<'a> {
    Plus(Symbol<'a>),
    Minus(Symbol<'a>),
}

#[derive(Debug, Node)]
pub struct Size<'a> {
    pub nodes: (NonZeroUnsignedNumber<'a>,),
}

#[derive(Debug, Node)]
pub struct NonZeroUnsignedNumber<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub enum RealNumber<'a> {
    FixedPointNumber(FixedPointNumber<'a>),
    Floating(RealNumberFloating<'a>),
}

#[derive(Debug, Node)]
pub struct RealNumberFloating<'a> {
    pub nodes: (
        UnsignedNumber<'a>,
        Option<(Symbol<'a>, UnsignedNumber<'a>)>,
        Exp<'a>,
        Option<Sign<'a>>,
        UnsignedNumber<'a>,
    ),
}

#[derive(Debug, Node)]
pub struct FixedPointNumber<'a> {
    pub nodes: (UnsignedNumber<'a>, Symbol<'a>, UnsignedNumber<'a>),
}

#[derive(Debug, Node)]
pub struct Exp<'a> {
    pub nodes: (Symbol<'a>,),
}

#[derive(Debug, Node)]
pub struct UnsignedNumber<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct BinaryValue<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct OctalValue<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct HexValue<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct DecimalBase<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct BinaryBase<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct OctalBase<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct HexBase<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct XNumber<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct ZNumber<'a> {
    pub nodes: (Span<'a>, Vec<WhiteSpace<'a>>),
}

#[derive(Debug, Node)]
pub struct UnbasedUnsizedLiteral<'a> {
    pub nodes: (Symbol<'a>,),
}

// -----------------------------------------------------------------------------

pub fn number(s: Span) -> IResult<Span, Number> {
    alt((
        map(real_number, |x| Number::RealNumber(x)),
        map(integral_number, |x| Number::IntegralNumber(x)),
    ))(s)
}

pub fn integral_number(s: Span) -> IResult<Span, IntegralNumber> {
    alt((
        map(octal_number, |x| IntegralNumber::OctalNumber(x)),
        map(binary_number, |x| IntegralNumber::BinaryNumber(x)),
        map(hex_number, |x| IntegralNumber::HexNumber(x)),
        map(decimal_number, |x| IntegralNumber::DecimalNumber(x)),
    ))(s)
}

pub fn decimal_number(s: Span) -> IResult<Span, DecimalNumber> {
    alt((
        decimal_number_base_unsigned,
        decimal_number_base_x_number,
        decimal_number_base_z_number,
        map(unsigned_number, |x| DecimalNumber::UnsignedNumber(x)),
    ))(s)
}

pub fn decimal_number_base_unsigned(s: Span) -> IResult<Span, DecimalNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = decimal_base(s)?;
    let (s, c) = unsigned_number(s)?;
    Ok((
        s,
        DecimalNumber::BaseUnsigned(DecimalNumberBaseUnsigned { nodes: (a, b, c) }),
    ))
}

pub fn decimal_number_base_x_number(s: Span) -> IResult<Span, DecimalNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = decimal_base(s)?;
    let (s, c) = x_number(s)?;
    Ok((
        s,
        DecimalNumber::BaseXNumber(DecimalNumberBaseXNumber { nodes: (a, b, c) }),
    ))
}

pub fn decimal_number_base_z_number(s: Span) -> IResult<Span, DecimalNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = decimal_base(s)?;
    let (s, c) = z_number(s)?;
    Ok((
        s,
        DecimalNumber::BaseZNumber(DecimalNumberBaseZNumber { nodes: (a, b, c) }),
    ))
}

pub fn binary_number(s: Span) -> IResult<Span, BinaryNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = binary_base(s)?;
    let (s, c) = binary_value(s)?;
    Ok((s, BinaryNumber { nodes: (a, b, c) }))
}

pub fn octal_number(s: Span) -> IResult<Span, OctalNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = octal_base(s)?;
    let (s, c) = octal_value(s)?;
    Ok((s, OctalNumber { nodes: (a, b, c) }))
}

pub fn hex_number(s: Span) -> IResult<Span, HexNumber> {
    let (s, a) = opt(size)(s)?;
    let (s, b) = hex_base(s)?;
    let (s, c) = hex_value(s)?;
    Ok((s, HexNumber { nodes: (a, b, c) }))
}

pub fn sign(s: Span) -> IResult<Span, Sign> {
    alt((
        map(symbol("+"), |x| Sign::Plus(x)),
        map(symbol("-"), |x| Sign::Minus(x)),
    ))(s)
}

pub fn size(s: Span) -> IResult<Span, Size> {
    let (s, a) = non_zero_unsigned_number(s)?;
    Ok((s, Size { nodes: (a,) }))
}

pub fn non_zero_unsigned_number(s: Span) -> IResult<Span, NonZeroUnsignedNumber> {
    let (s, a) = ws(non_zero_unsigned_number_impl)(s)?;
    Ok((s, NonZeroUnsignedNumber { nodes: a }))
}

pub fn non_zero_unsigned_number_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = is_a("123456789")(s)?;
    fold_many0(alt((tag("_"), digit1)), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn real_number(s: Span) -> IResult<Span, RealNumber> {
    alt((
        real_number_floating,
        map(fixed_point_number, |x| RealNumber::FixedPointNumber(x)),
    ))(s)
}

pub fn real_number_floating(s: Span) -> IResult<Span, RealNumber> {
    let (s, a) = unsigned_number(s)?;
    let (s, b) = opt(pair(symbol("."), unsigned_number))(s)?;
    let (s, c) = exp(s)?;
    let (s, d) = opt(sign)(s)?;
    let (s, e) = unsigned_number(s)?;
    Ok((
        s,
        RealNumber::Floating(RealNumberFloating {
            nodes: (a, b, c, d, e),
        }),
    ))
}

pub fn fixed_point_number(s: Span) -> IResult<Span, FixedPointNumber> {
    let (s, a) = unsigned_number(s)?;
    let (s, b) = map(tag("."), |x| Symbol { nodes: (x, vec![]) })(s)?;;
    let (s, c) = unsigned_number(s)?;
    Ok((s, FixedPointNumber { nodes: (a, b, c) }))
}

pub fn exp(s: Span) -> IResult<Span, Exp> {
    let (s, a) = alt((symbol("e"), symbol("E")))(s)?;
    Ok((s, Exp { nodes: (a,) }))
}

pub fn unsigned_number(s: Span) -> IResult<Span, UnsignedNumber> {
    let (s, a) = ws(unsigned_number_impl)(s)?;
    Ok((s, UnsignedNumber { nodes: a }))
}

pub fn unsigned_number_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = digit1(s)?;
    fold_many0(alt((tag("_"), digit1)), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn binary_value(s: Span) -> IResult<Span, BinaryValue> {
    let (s, a) = ws(binary_value_impl)(s)?;
    Ok((s, BinaryValue { nodes: a }))
}

pub fn binary_value_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = is_a("01xXzZ?")(s)?;
    fold_many0(alt((tag("_"), is_a("01xXzZ?"))), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn octal_value(s: Span) -> IResult<Span, OctalValue> {
    let (s, a) = ws(octal_value_impl)(s)?;
    Ok((s, OctalValue { nodes: a }))
}

pub fn octal_value_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = is_a("01234567xXzZ?")(s)?;
    fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn hex_value(s: Span) -> IResult<Span, HexValue> {
    let (s, a) = ws(hex_value_impl)(s)?;
    Ok((s, HexValue { nodes: a }))
}

pub fn hex_value_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?;
    fold_many0(
        alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))),
        a,
        |acc, item| concat(acc, item).unwrap(),
    )(s)
}

pub fn decimal_base(s: Span) -> IResult<Span, DecimalBase> {
    let (s, a) = ws(decimal_base_impl)(s)?;
    Ok((s, DecimalBase { nodes: a }))
}

pub fn decimal_base_impl(s: Span) -> IResult<Span, Span> {
    alt((tag_no_case("'d"), tag_no_case("'sd")))(s)
}

pub fn binary_base(s: Span) -> IResult<Span, BinaryBase> {
    let (s, a) = ws(binary_base_impl)(s)?;
    Ok((s, BinaryBase { nodes: a }))
}

pub fn binary_base_impl(s: Span) -> IResult<Span, Span> {
    alt((tag_no_case("'b"), tag_no_case("'sb")))(s)
}

pub fn octal_base(s: Span) -> IResult<Span, OctalBase> {
    let (s, a) = ws(octal_base_impl)(s)?;
    Ok((s, OctalBase { nodes: a }))
}

pub fn octal_base_impl(s: Span) -> IResult<Span, Span> {
    alt((tag_no_case("'o"), tag_no_case("'so")))(s)
}

pub fn hex_base(s: Span) -> IResult<Span, HexBase> {
    let (s, a) = ws(hex_base_impl)(s)?;
    Ok((s, HexBase { nodes: a }))
}

pub fn hex_base_impl(s: Span) -> IResult<Span, Span> {
    alt((tag_no_case("'h"), tag_no_case("'sh")))(s)
}

pub fn x_number(s: Span) -> IResult<Span, XNumber> {
    let (s, a) = ws(x_number_impl)(s)?;
    Ok((s, XNumber { nodes: a }))
}

pub fn x_number_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = tag_no_case("x")(s)?;
    fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn z_number(s: Span) -> IResult<Span, ZNumber> {
    let (s, a) = ws(z_number_impl)(s)?;
    Ok((s, ZNumber { nodes: a }))
}

pub fn z_number_impl(s: Span) -> IResult<Span, Span> {
    let (s, a) = alt((tag_no_case("z"), tag("?")))(s)?;
    fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| {
        concat(acc, item).unwrap()
    })(s)
}

pub fn unbased_unsized_literal(s: Span) -> IResult<Span, UnbasedUnsizedLiteral> {
    let (s, a) = alt((symbol("'0"), symbol("'1"), symbol("'z"), symbol("'x")))(s)?;
    Ok((s, UnbasedUnsizedLiteral { nodes: (a,) }))
}

// -----------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_number() {
        parser_test!(
            number,
            "659",
            Ok((_, Number::IntegralNumber(IntegralNumber::DecimalNumber(_))))
        );
        parser_test!(
            number,
            "'h 837FF",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(
            number,
            "'h 837FF",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(
            number,
            "'o7460",
            Ok((_, Number::IntegralNumber(IntegralNumber::OctalNumber(_))))
        );
        parser_test!(number, "'4af", Err(_));
        parser_test!(
            number,
            "4'b1001",
            Ok((_, Number::IntegralNumber(IntegralNumber::BinaryNumber(_))))
        );
        parser_test!(
            number,
            "5 'D 3",
            Ok((_, Number::IntegralNumber(IntegralNumber::DecimalNumber(_))))
        );
        parser_test!(
            number,
            "3'b01x",
            Ok((_, Number::IntegralNumber(IntegralNumber::BinaryNumber(_))))
        );
        parser_test!(
            number,
            "12'hx",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(
            number,
            "16'hz",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(number, "8 'd -6", Err(_));
        parser_test!(
            number,
            "4 'shf",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(
            number,
            "16'sd?",
            Ok((_, Number::IntegralNumber(IntegralNumber::DecimalNumber(_))))
        );
        parser_test!(
            number,
            "27_195_000",
            Ok((_, Number::IntegralNumber(IntegralNumber::DecimalNumber(_))))
        );
        parser_test!(
            number,
            "16'b0011_0101_0001_1111",
            Ok((_, Number::IntegralNumber(IntegralNumber::BinaryNumber(_))))
        );
        parser_test!(
            number,
            "32 'h 12ab_f001",
            Ok((_, Number::IntegralNumber(IntegralNumber::HexNumber(_))))
        );
        parser_test!(
            number,
            "1.2",
            Ok((_, Number::RealNumber(RealNumber::FixedPointNumber(_))))
        );
        parser_test!(
            number,
            "0.1",
            Ok((_, Number::RealNumber(RealNumber::FixedPointNumber(_))))
        );
        parser_test!(
            number,
            "2394.26331",
            Ok((_, Number::RealNumber(RealNumber::FixedPointNumber(_))))
        );
        parser_test!(
            number,
            "1.2E12",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(
            number,
            "1.30e-2",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(
            number,
            "0.1e-0",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(
            number,
            "23E10",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(
            number,
            "29E-2",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(
            number,
            "236.123_763_e-12",
            Ok((_, Number::RealNumber(RealNumber::Floating(_))))
        );
        parser_test!(number, ".12", Err(_));
        parser_test!(number, "9.", Err(_));
        parser_test!(number, "4.E3", Err(_));
        parser_test!(number, ".2e-7", Err(_));
    }

    #[test]
    fn test_unbased_unsized_literal() {
        parser_test!(unbased_unsized_literal, "'0", Ok((_, _)));
        parser_test!(unbased_unsized_literal, "'1", Ok((_, _)));
        parser_test!(unbased_unsized_literal, "'x", Ok((_, _)));
        parser_test!(unbased_unsized_literal, "'z", Ok((_, _)));
    }

    #[test]
    fn test_node() {
        if let Ok((_, x)) = all_consuming(number)(Span::new_extra("10.00", 0)) {
            //assert_eq!(x.test(), "aaaa");
            //let y: AnyNode = (&x).into();
            for a in &x {
                dbg!(a);
                //assert_eq!(format!("{:?}", a), "aaa");
            }
        }
    }
}