use super::flat::{Mono, Poly};
use super::var::StaticVar;

#[test]
fn test_mono_contains() {
    let a: Mono<StaticVar> = [("x", 2), ("y", 1)].into();

    // Lower exponent of same variable is contained
    assert!(a.contains(&Mono::from([("x", 1)])));

    // Higher exponent of same variable is not contained
    assert!(!a.contains(&Mono::from([("x", 3)])));

    // Identical monomial is contained
    assert!(a.contains(&Mono::from([("x", 2), ("y", 1)])));

    // Variable absent from self is not contained
    assert!(!a.contains(&Mono::from([("x", 2), ("z", 1)])));

    // Subset of variables with lower exponents is contained
    assert!(a.contains(&Mono::from([("x", 1), ("y", 1)])));

    // Single variable with exact exponent is contained
    assert!(a.contains(&Mono::from([("x", 2)])));

    // Insufficient exponent in self means not contained
    assert!(!Mono::<StaticVar>::from([("x", 1)]).contains(&Mono::from([("x", 2)])));

    // Missing variable in self means not contained
    assert!(!Mono::<StaticVar>::from([("x", 1), ("y", 1)]).contains(&Mono::from([("x", 2)])));
    assert!(!Mono::<StaticVar>::from([("x", 1)]).contains(&Mono::from([("x", 1), ("y", 1)])));
}

#[test]
fn test_mono_mul() {
    // Same variable: exponents add
    let a: Mono<StaticVar> = [("x", 2)].into();
    let b: Mono<StaticVar> = [("x", 3)].into();
    assert_eq!(a * b, Mono::from([("x", 5)]));

    // Disjoint variables: both appear in result
    let a: Mono<StaticVar> = [("x", 2)].into();
    let b: Mono<StaticVar> = [("y", 3)].into();
    assert_eq!(a * b, Mono::from([("x", 2), ("y", 3)]));

    // Mixed: shared and disjoint variables
    let a: Mono<StaticVar> = [("x", 1), ("y", 2)].into();
    let b: Mono<StaticVar> = [("y", 1), ("z", 3)].into();
    assert_eq!(a * b, Mono::from([("x", 1), ("y", 3), ("z", 3)]));

    // Commutativity
    let a: Mono<StaticVar> = [("x", 2), ("z", 1)].into();
    let b: Mono<StaticVar> = [("y", 3)].into();
    assert_eq!(a.clone() * b.clone(), b * a);

    // Multiply by constant monomial (empty term vec = 1)
    let a: Mono<StaticVar> = [("x", 4)].into();
    let one: Mono<StaticVar> = Mono { term: vec![] };
    assert_eq!(a.clone() * one, a);
}

#[test]
fn test_poly_add() {
    // Distinct monomials are collected as separate terms
    let a: Poly<StaticVar> = [(1, [("x", 2)]), (2, [("y", 1)])].into();
    let b: Poly<StaticVar> = [(3, [("z", 1)])].into();
    let expected: Poly<StaticVar> = [(1, [("x", 2)]), (2, [("y", 1)]), (3, [("z", 1)])].into();
    assert_eq!(a + b, expected);

    // Coefficients of matching monomials are summed
    let a: Poly<StaticVar> = [(2, [("x", 1)])].into();
    let b: Poly<StaticVar> = [(3, [("x", 1)])].into();
    let expected: Poly<StaticVar> = [(5, [("x", 1)])].into();
    assert_eq!(a + b, expected);

    // Terms that cancel sum to zero are dropped
    let a: Poly<StaticVar> = [(1, [("x", 1)])].into();
    let b: Poly<StaticVar> = [(-1, [("x", 1)])].into();
    let expected: Poly<StaticVar> = Poly::default();
    assert_eq!(a + b, expected);
}

#[test]
fn test_poly_sub() {
    // Distinct monomials are collected as separate terms with negated rhs coefficients
    let a: Poly<StaticVar> = [(3, [("x", 2)])].into();
    let b: Poly<StaticVar> = [(1, [("y", 1)])].into();
    let expected: Poly<StaticVar> = [(3, [("x", 2)]), (-1, [("y", 1)])].into();
    assert_eq!(a - b, expected);

    // Coefficients of matching monomials are subtracted
    let a: Poly<StaticVar> = [(5, [("x", 1)])].into();
    let b: Poly<StaticVar> = [(3, [("x", 1)])].into();
    let expected: Poly<StaticVar> = [(2, [("x", 1)])].into();
    assert_eq!(a - b, expected);

    // Subtracting equal polynomials yields zero
    let a: Poly<StaticVar> = [(4, [("x", 2)]), (1, [("y", 1)])].into();
    let b: Poly<StaticVar> = [(4, [("x", 2)]), (1, [("y", 1)])].into();
    assert_eq!(a - b, Poly::default());
}