use std::f64::consts::{E, PI, SQRT_2};
use ytbn_graphing_software::symbolic::try_symbolic;

#[test]
fn exact_pi() {
    let result = try_symbolic(PI);
    assert!(result.is_some());
    let sym = result.unwrap();
    assert_eq!(sym.to_string(), "pi");
}

#[test]
fn multiples_of_pi() {
    // 2*pi
    let result = try_symbolic(2.0 * PI);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "2pi");

    // 3*pi
    let result = try_symbolic(3.0 * PI);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "3pi");

    // -pi
    let result = try_symbolic(-PI);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-pi");

    // -2*pi
    let result = try_symbolic(-2.0 * PI);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-2pi");
}

#[test]
fn fractions_of_pi() {
    // pi/2
    let result = try_symbolic(PI / 2.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "pi/2");

    // pi/3
    let result = try_symbolic(PI / 3.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "pi/3");

    // pi/4
    let result = try_symbolic(PI / 4.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "pi/4");

    // pi/6
    let result = try_symbolic(PI / 6.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "pi/6");

    // 2pi/3
    let result = try_symbolic(2.0 * PI / 3.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "2pi/3");

    // 3pi/4
    let result = try_symbolic(3.0 * PI / 4.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "3pi/4");

    // 5pi/6
    let result = try_symbolic(5.0 * PI / 6.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "5pi/6");

    // -pi/2
    let result = try_symbolic(-PI / 2.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-pi/2");
}

#[test]
fn exact_e() {
    let result = try_symbolic(E);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "e");
}

#[test]
fn multiples_of_e() {
    // 2e
    let result = try_symbolic(2.0 * E);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "2e");

    // -e
    let result = try_symbolic(-E);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-e");
}

#[test]
fn sqrt_2() {
    let result = try_symbolic(SQRT_2);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "sqrt(2)");

    // -sqrt(2)
    let result = try_symbolic(-SQRT_2);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-sqrt(2)");

    // 2*sqrt(2)
    let result = try_symbolic(2.0 * SQRT_2);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "2sqrt(2)");
}

#[test]
fn sqrt_3() {
    let sqrt_3 = 3.0_f64.sqrt();
    let result = try_symbolic(sqrt_3);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "sqrt(3)");

    // sqrt(3)/2 - common in trigonometry
    let result = try_symbolic(sqrt_3 / 2.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "sqrt(3)/2");
}

#[test]
fn simple_fractions() {
    // 1/2
    let result = try_symbolic(0.5);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "1/2");

    // 1/3
    let result = try_symbolic(1.0 / 3.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "1/3");

    // 2/3
    let result = try_symbolic(2.0 / 3.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "2/3");

    // 1/4
    let result = try_symbolic(0.25);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "1/4");

    // 3/4
    let result = try_symbolic(0.75);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "3/4");

    // -1/2
    let result = try_symbolic(-0.5);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-1/2");
}

#[test]
fn integers() {
    // 0
    let result = try_symbolic(0.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "0");

    // 1
    let result = try_symbolic(1.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "1");

    // -1
    let result = try_symbolic(-1.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "-1");

    // 5
    let result = try_symbolic(5.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "5");
}

#[test]
fn non_symbolic_values() {
    // Some arbitrary irrational number that isn't special
    let result = try_symbolic(1.234567890123);
    assert!(result.is_none());

    // A number that's close to but not quite pi
    let result = try_symbolic(3.15);
    assert!(result.is_none());
}

#[test]
fn numeric_value() {
    // SymbolicValue should provide the original numeric value
    let sym = try_symbolic(PI).unwrap();
    assert!((sym.numeric_value() - PI).abs() < 1e-10);

    let sym = try_symbolic(PI / 2.0).unwrap();
    assert!((sym.numeric_value() - PI / 2.0).abs() < 1e-10);
}

#[test]
fn zero() {
    let result = try_symbolic(0.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "0");

    // Also test -0.0
    let result = try_symbolic(-0.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "0");
}

#[test]
fn special_trig_values() {
    // Common values that appear in trigonometry
    // sin(pi/4) = cos(pi/4) = sqrt(2)/2
    let result = try_symbolic(SQRT_2 / 2.0);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "sqrt(2)/2");

    // sin(pi/6) = cos(pi/3) = 1/2
    let result = try_symbolic(0.5);
    assert!(result.is_some());
    assert_eq!(result.unwrap().to_string(), "1/2");
}