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: Tree {root: Vertex::Terminal(a)}
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Tree {root: Vertex::Terminal(b)}
  };
  let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(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: Tree {root: Vertex::Terminal(a)}
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Tree {root: Vertex::Terminal(b)}
  };
  let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(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: Tree {root: Vertex::Terminal(a)}
  };
  let edge_b = Edge {
    weight: 1.0,
    destination: Tree {root: Vertex::Terminal(b)}
  };
  let edge_ab = Edge{
    weight: 0.5,
    destination: Tree {
      root: Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b))
    }
  };
  let edge_c = Edge{
    weight: 1.0,
    destination: Tree {root: Vertex::Terminal(c)}
  };
  let root = Vertex::NonTerminal(Box::new(edge_ab), Box::new(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::subtree("([1.0]A[1.0]B)").unwrap();
      b
    },
    simple_symmetric_tree()
  )
}

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

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

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

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

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