// (C) Copyright 2019 Hewlett Packard Enterprise Development LP

extern crate prometheus_parser;

use prometheus_parser::*;

#[test]
fn parse_greater_than() -> Result<()> {
    assert_eq!(
        parse_expr("foo > bar")?,
        Operator::new(
            OperatorKind::GreaterThan,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    assert_ne!(
        parse_expr("foo < bar")?,
        Operator::new(
            OperatorKind::GreaterThan,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_whitespace() -> Result<()> {
    assert_eq!(
        parse_expr(
            r#"
      foo
      >
      bar
    "#
        )?,
        Operator::new(
            OperatorKind::GreaterThan,
            Selector::new().metric("foo").span((7, 10)).wrap(),
            Selector::new().metric("bar").span((25, 28)).wrap()
        )
        .span((10, 25))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_less_than() -> Result<()> {
    assert_ne!(
        // set to assert not equal
        parse_expr("foo > bar")?,
        Operator::new(
            OperatorKind::LessThan,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    assert_eq!(
        parse_expr("foo < bar")?,
        Operator::new(
            OperatorKind::LessThan,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_add() -> Result<()> {
    assert_eq!(
        parse_expr("foo + bar")?,
        Operator::new(
            OperatorKind::Add,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_equal() -> Result<()> {
    assert_eq!(
        parse_expr("foo == bar")?,
        Operator::new(
            OperatorKind::Equal,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("bar").span((7, 10)).wrap()
        )
        .span((3, 7))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_not_equal() -> Result<()> {
    assert_eq!(
        parse_expr("foo != foo")?,
        Operator::new(
            OperatorKind::NotEqual,
            Selector::new().metric("foo").span((0, 3)).wrap(),
            Selector::new().metric("foo").span((7, 10)).wrap()
        )
        .span((3, 7))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_power() -> Result<()> {
    assert_eq!(
        parse_expr("check ^ taco")?,
        Operator::new(
            OperatorKind::Power,
            Selector::new().metric("check").span((0, 5)).wrap(),
            Selector::new().metric("taco").span((8, 12)).wrap()
        )
        .span((5, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_multiply() -> Result<()> {
    assert_eq!(
        parse_expr("check * value")?,
        Operator::new(
            OperatorKind::Multiply,
            Selector::new().metric("check").span((0, 5)).wrap(),
            Selector::new().metric("value").span((8, 13)).wrap()
        )
        .span((5, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_divide() -> Result<()> {
    assert_eq!(
        parse_expr("check / value")?,
        Operator::new(
            OperatorKind::Divide,
            Selector::new().metric("check").span((0, 5)).wrap(),
            Selector::new().metric("value").span((8, 13)).wrap()
        )
        .span((5, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_modulo() -> Result<()> {
    assert_eq!(
        parse_expr("check % value")?,
        Operator::new(
            OperatorKind::Modulo,
            Selector::new().metric("check").span((0, 5)).wrap(),
            Selector::new().metric("value").span((8, 13)).wrap()
        )
        .span((5, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_subtract() -> Result<()> {
    assert_eq!(
        parse_expr("check - value")?,
        Operator::new(
            OperatorKind::Subtract,
            Selector::new().metric("check").span((0, 5)).wrap(),
            Selector::new().metric("value").span((8, 13)).wrap()
        )
        .span((5, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_less_than_equal() -> Result<()> {
    assert_eq!(
        parse_expr("this <= that")?,
        Operator::new(
            OperatorKind::LessThanEqual,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    assert_ne!(
        parse_expr("this >= that")?,
        Operator::new(
            OperatorKind::LessThanEqual,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_greater_than_equal() -> Result<()> {
    assert_eq!(
        parse_expr("this >= that")?,
        Operator::new(
            OperatorKind::GreaterThanEqual,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    assert_ne!(
        parse_expr("this <= that")?,
        Operator::new(
            OperatorKind::GreaterThanEqual,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_and() -> Result<()> {
    assert_eq!(
        parse_expr("this and that")?,
        Operator::new(
            OperatorKind::And,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((9, 13)).wrap()
        )
        .span((4, 9))
        .wrap()
    );

    assert_eq!(
        parse_expr("this And that")?,
        Operator::new(
            OperatorKind::And,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((9, 13)).wrap()
        )
        .span((4, 9))
        .wrap()
    );

    assert_eq!(
        parse_expr("this AND that")?,
        Operator::new(
            OperatorKind::And,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((9, 13)).wrap()
        )
        .span((4, 9))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_or() -> Result<()> {
    assert_eq!(
        parse_expr("this or that")?,
        Operator::new(
            OperatorKind::Or,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    assert_eq!(
        parse_expr("this Or that")?,
        Operator::new(
            OperatorKind::Or,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    assert_eq!(
        parse_expr("this OR that")?,
        Operator::new(
            OperatorKind::Or,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((8, 12)).wrap()
        )
        .span((4, 8))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_unless() -> Result<()> {
    assert_eq!(
        parse_expr("this unless that")?,
        Operator::new(
            OperatorKind::Unless,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((12, 16)).wrap()
        )
        .span((4, 12))
        .wrap()
    );

    assert_eq!(
        parse_expr("this Unless that")?,
        Operator::new(
            OperatorKind::Unless,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((12, 16)).wrap()
        )
        .span((4, 12))
        .wrap()
    );

    assert_eq!(
        parse_expr("this UNLESS that")?,
        Operator::new(
            OperatorKind::Unless,
            Selector::new().metric("this").span((0, 4)).wrap(),
            Selector::new().metric("that").span((12, 16)).wrap()
        )
        .span((4, 12))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_parentheses() -> Result<()> {
    assert_eq!(
        parse_expr("(f) > bar")?, // "()" need .group() and to be removed from the .span() item
        Operator::new(
            OperatorKind::GreaterThan,
            Group::new(Selector::new().metric("f").span((1, 2)).wrap())
                .span((0, 3))
                .wrap(),
            Selector::new().metric("bar").span((6, 9)).wrap()
        )
        .span((3, 6))
        .wrap()
    );

    assert_eq!(
        parse_expr("(some)+(more)")?,
        Operator::new(
            OperatorKind::Add,
            Group::new(Selector::new().metric("some").span((1, 5)).wrap())
                .span((0, 6))
                .wrap(),
            Group::new(Selector::new().metric("more").span((8, 12)).wrap())
                .span((7, 13))
                .wrap(),
        )
        .span((6, 7))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_colon() -> Result<()> {
    assert_eq!(
        parse_expr("t::s and that")?,
        Operator::new(
            OperatorKind::And,
            Selector::new().metric("t::s").span((0, 4)).wrap(),
            Selector::new().metric("that").span((9, 13)).wrap()
        )
        .span((4, 9))
        .wrap()
    );

    assert_eq!(
        parse_expr("this:or:that:+:this:or:that")?,
        Operator::new(
            OperatorKind::Add,
            Selector::new().metric("this:or:that:").span((0, 13)).wrap(),
            Selector::new()
                .metric(":this:or:that")
                .span((14, 27))
                .wrap()
        )
        .span((13, 14))
        .wrap()
    );

    assert_eq!(
        parse_expr("this:+:that")?,
        Operator::new(
            OperatorKind::Add,
            Selector::new().metric("this:").span((0, 5)).wrap(),
            Selector::new().metric(":that").span((6, 11)).wrap()
        )
        .span((5, 6))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_missing_quotation() -> std::result::Result<(), ()> {
    match parse_expr(r#"hello{world="jupiter",type="gas}"#) {
        Err(_) => Ok(()),
        _ => Err(()),
    }
}

#[test]
fn parse_missing_rhs() -> std::result::Result<(), ()> {
    match parse_expr(r#"hello{world="jupiter",type="gas"} !="#) {
        Err(_) => Ok(()),
        _ => Err(()),
    }
}

#[test]
fn parse_trailing_comma() -> Result<()> {
    assert_eq!(
        parse_expr(r#"hello{world="jupiter",type="gas",}"#)?,
        Selector::new()
            .metric("hello")
            .label(Label::equal("world", "jupiter").span((6, 21)))
            .label(Label::equal("type", "gas").span((22, 32)))
            .span((0, 34))
            .wrap()
    );

    Ok(())
}

#[test]
fn parse_comment() -> Result<()> {
    assert_eq!(
        parse_expr(
            r#"
      foo # lorem
      +   # ipsum
      bar # dolor
    "#
        )?,
        Operator::new(
            OperatorKind::Add,
            Selector::new().metric("foo").span((7, 10)).wrap(),
            Selector::new().metric("bar").span((43, 46)).wrap()
        )
        .span((10, 43))
        .wrap()
    );

    Ok(())
}

#[test]
fn parse_weird_floats() -> Result<()> {
    // nan != nan, so gotta check in a roundabout way
    match parse_expr("NaN + 1")? {
        Expression::Operator(o) => match *o.lhs {
            Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
            _ => assert!(false, "must be float"),
        },
        _ => assert!(false, "must be operator"),
    }

    match parse_expr("+NaN + +1")? {
        Expression::Operator(o) => {
            match *o.lhs {
                Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
                _ => assert!(false, "must be float"),
            }

            match *o.rhs {
                Expression::Float(f) => assert_eq!(f, 1.0),
                _ => assert!(false, "must be float"),
            }
        }
        _ => assert!(false, "must be operator"),
    }

    match parse_expr("Inf + -1")? {
        Expression::Operator(o) => {
            match *o.lhs {
                Expression::Float(f) => {
                    assert!(f.is_infinite() && f.is_sign_positive(), "must be +inf")
                }
                _ => assert!(false, "must be float"),
            }

            match *o.rhs {
                Expression::Float(f) => assert_eq!(f, -1.0),
                _ => assert!(false, "must be float"),
            }
        }
        _ => assert!(false, "must be operator"),
    }

    match parse_expr("+Inf + -.1")? {
        Expression::Operator(o) => {
            match *o.lhs {
                Expression::Float(f) => {
                    assert!(f.is_infinite() && f.is_sign_positive(), "must be +inf")
                }
                _ => assert!(false, "must be float"),
            }

            match *o.rhs {
                Expression::Float(f) => assert_eq!(f, -0.1),
                _ => assert!(false, "must be float"),
            }
        }
        _ => assert!(false, "must be operator"),
    }

    match parse_expr("-Inf + 1")? {
        Expression::Operator(o) => match *o.lhs {
            Expression::Float(f) => assert!(f.is_infinite() && f.is_sign_negative()),
            _ => assert!(false, "must be float"),
        },
        _ => assert!(false, "must be operator"),
    }

    Ok(())
}

#[test]
fn parse_scientific_notation_floats() -> Result<()> {
    match parse_expr("1e1")? {
        Expression::Float(f) => assert_eq!(f, (1e1 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("1e-1")? {
        Expression::Float(f) => assert_eq!(f, (1e-1 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("-1e1")? {
        Expression::Float(f) => assert_eq!(f, (-1e1 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("-1e-1")? {
        Expression::Float(f) => assert_eq!(f, (-1e-1 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("1.0e1")? {
        Expression::Float(f) => assert_eq!(f, (1.0e1 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("1e01")? {
        Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
        _ => assert!(false, "must be a float"),
    };

    match parse_expr("1E01")? {
        Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
        _ => assert!(false, "must be a float"),
    };

    Ok(())
}