use super::tree::*;
use super::parser;
use assert_approx_eq::assert_approx_eq;

// helper methods for testing parser, return constant heap-allocated value
fn simple_symmetric_tree() -> Tree<String, f64> {
  let a = Alternative {
    name: "A".to_owned()
  };
  let b = Alternative {
    name: "B".to_owned()
  };
  let edge_a = Edge {
    weight: 1.0,
    destination: Box::new(Tree {root: Vertex::Terminal(a)})
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Box::new(Tree {root: Vertex::Terminal(b)})
  };
  let root = Vertex::NonTerminal(edge_a, edge_b);
  Tree {root: root}
}

// helper methods for testing parser, return constant heap-allocated value
fn simple_asymmetric_tree() -> Tree<String, f64> {
  let a = Alternative {
    name: "A".to_owned()
  };
  let b = Alternative {
    name: "B".to_owned()
  };
  let edge_a = Edge {
    weight: 3.0,
    destination: Box::new(Tree {root: Vertex::Terminal(a)})
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Box::new(Tree {root: Vertex::Terminal(b)})
  };
  let root = Vertex::NonTerminal(edge_a, edge_b);
  Tree {root: root}
}

// helper methods for testing parser, return constant heap-allocated value
fn complex_tree() -> Tree<String, f64> {
  let a = Alternative {
    name: "A".to_owned()
  };
  let b = Alternative {
    name: "B".to_owned()
  };
  let c = Alternative {
    name: "C".to_owned()
  };
  let edge_a = Edge {
    weight: 2.5,
    destination: Box::new(Tree {root: Vertex::Terminal(a)})
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Box::new(Tree {root: Vertex::Terminal(b)})
  };
  let edge_ab = Edge{
    weight: 0.5,
    destination: Box::new(Tree {
      root: Vertex::NonTerminal(edge_a, edge_b)
    })
  };
  let edge_c = Edge{
    weight: 1.0,
    destination: Box::new(Tree {root: Vertex::Terminal(c)})
  };
  let root = Vertex::NonTerminal(edge_ab, edge_c);
  Tree {root: root}
}


// A test for the simplest symmetric case
#[test]
fn choice_probability_test_1() {
  assert_eq!(simple_symmetric_tree().choice_probability(&("A".to_owned())), 0.5);
}

// A test for the simplest asymmetric case
#[test]
fn choice_probability_test_2() {
  assert_eq!(simple_asymmetric_tree().choice_probability(&("A".to_owned())), 0.75);
}

// A test for depth higher than 1
#[test]
fn choice_probability_test_3() {
  assert_approx_eq!(
    complex_tree().choice_probability(&("A".to_owned())),
    (2.5/(2.5+1.0))*((2.5+1.0+0.5)/(2.5+1.0+0.5+1.0))
  );
}

// A test for parsing the simplest symmetric case
#[test]
fn parser_test_1() {
  assert_eq!(
    {
      let (_, b) = parser::tree("([1.0]A[1.0]B)").unwrap();
      b
    },
    simple_symmetric_tree()
  )
}

#[test]
fn parser_test_2() {
  assert_eq!(
    {
      let (_, b) = parser::tree("([3.0]A[1.0]B)").unwrap();
      b
    },
    simple_asymmetric_tree()
  )
}

#[test]
fn parser_test_3() {
  assert_eq!(
    {
      let (_, b) = parser::tree("([0.5]([2.5]A[1.0]B)[1.0]C)").unwrap();
      b
    },
    complex_tree()
  )
}

#[test]
fn test_symmetry_positive() {
  let (_, a) = parser::tree("([3.0]A[1.0]B)").unwrap();
  let (_, b) = parser::tree("([1.0]B[3.0]A)").unwrap();
  assert_eq!(a, b)
}

#[test]
fn test_symmetry_negative() {
  let (_, a) = parser::tree("([3.0]A[1.0]B)").unwrap();
  let (_, b) = parser::tree("([1.0]A[3.0]B)").unwrap();
  assert_ne!(a, b)
}

#[test]
fn test_symmetry_complex() {
  let (_, a) = parser::tree("([1.0]C[0.5]([1.0]B[2.5]A))").unwrap();
  let (_, b) = parser::tree("([0.5]([2.5]A[1.0]B)[1.0]C)").unwrap();
  assert_eq!(a, b)
}

#[test]
fn test_menu_simple() {
  let (_, a) = parser::tree("([3.0]A[1.0]B)").unwrap();
  let (_, b) = parser::tree("A").unwrap();
  let Some((a_menu_tree, _)) = a.menu_tree(&["A".to_owned()]) else {
    panic!("Failed to get tree from menu_tree output")
  };
  assert_eq!(a_menu_tree, b)
}

#[test]
fn test_menu_complex() {
  let (_, a) = parser::tree("([1.0]C[0.5]([1.0]B[2.5]A))").unwrap();
  let (_, b) = parser::tree("([1.0]C[1.5]B)").unwrap();
  let Some((a_menu_tree, _)) = a.menu_tree(&[
    "B".to_owned(), "C".to_owned()
      ]) else {
    panic!("Failed to get tree from menu_tree output")
  };
  assert_eq!(a_menu_tree, b)
}