use crate::node::script::NodeScript::*;
use crate::node::script::NodeTest;

use lib_ot::core::{placeholder_node, NodeData, NodeDataBuilder, NodeOperation, Path};

#[test]
fn operation_insert_op_transform_test() {
  let node_1 = NodeDataBuilder::new("text_1").build();
  let node_2 = NodeDataBuilder::new("text_2").build();
  let op_1 = NodeOperation::Insert {
    path: Path(vec![0, 1]),
    nodes: vec![node_1],
  };

  let mut insert_2 = NodeOperation::Insert {
    path: Path(vec![0, 1]),
    nodes: vec![node_2],
  };

  // let mut node_tree = NodeTree::new("root");
  // node_tree.apply_op(insert_1.clone()).unwrap();

  op_1.transform(&mut insert_2);
  let json = serde_json::to_string(&insert_2).unwrap();
  assert_eq!(
    json,
    r#"{"op":"insert","path":[0,2],"nodes":[{"type":"text_2"}]}"#
  );
}

#[test]
fn operation_insert_one_level_path_test() {
  let node_data_1 = NodeDataBuilder::new("text_1").build();
  let node_data_2 = NodeDataBuilder::new("text_2").build();
  let node_data_3 = NodeDataBuilder::new("text_3").build();
  let node_3 = node_data_3.clone();
  //  0: text_1
  //  1: text_2
  //
  //  Insert a new operation with rev_id 2 to index 1,but the index was already taken, so
  //  it needs to be transformed.
  //
  //  0: text_1
  //  1: text_2
  //  2: text_3
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: node_data_1.clone(),
      rev_id: 1,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_2.clone(),
      rev_id: 2,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_3.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: 2.into(),
      expected: Some(node_3.clone()),
    },
  ];
  NodeTest::new().run_scripts(scripts);

  //  If the rev_id of the node_data_3 is 3. then the tree will be:
  //  0: text_1
  //  1: text_3
  //  2: text_2
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: node_data_1,
      rev_id: 1,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_2,
      rev_id: 2,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_3,
      rev_id: 3,
    },
    AssertNode {
      path: 1.into(),
      expected: Some(node_3),
    },
  ];
  NodeTest::new().run_scripts(scripts);
}

#[test]
fn operation_insert_with_multiple_level_path_test() {
  let mut test = NodeTest::new();
  let node_data_1 = NodeDataBuilder::new("text_1")
    .add_node_data(NodeDataBuilder::new("text_1_1").build())
    .add_node_data(NodeDataBuilder::new("text_1_2").build())
    .build();

  let node_data_2 = NodeDataBuilder::new("text_2")
    .add_node_data(NodeDataBuilder::new("text_2_1").build())
    .add_node_data(NodeDataBuilder::new("text_2_2").build())
    .build();

  let node_data_3 = NodeDataBuilder::new("text_3").build();
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: node_data_1,
      rev_id: 1,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_2,
      rev_id: 2,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_data_3.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: 2.into(),
      expected: Some(node_data_3),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_out_of_bound_test() {
  let mut test = NodeTest::new();
  let image_a = NodeData::new("image_a");
  let image_b = NodeData::new("image_b");
  let image = NodeDataBuilder::new("image_1")
    .add_node_data(image_a)
    .add_node_data(image_b)
    .build();
  let text_node = NodeDataBuilder::new("text_1").add_node_data(image).build();
  let image_c = NodeData::new("image_c");

  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_node,
      rev_id: 1,
    },
    // 0:text_1
    //      0:image_1
    //             0:image_a
    //             1:image_b
    InsertNode {
      path: vec![0, 0, 3].into(),
      node_data: image_c.clone(),
      rev_id: 2,
    },
    // 0:text_1
    //      0:image_1
    //             0:image_a
    //             1:image_b
    //             2:placeholder node
    //             3:image_c
    AssertNode {
      path: vec![0, 0, 2].into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: vec![0, 0, 3].into(),
      expected: Some(image_c),
    },
    AssertNode {
      path: vec![0, 0, 10].into(),
      expected: None,
    },
  ];
  test.run_scripts(scripts);
}
#[test]
fn operation_insert_node_when_parent_is_not_exist_test1() {
  let mut test = NodeTest::new();
  let text_1 = NodeDataBuilder::new("text_1").build();
  let text_2 = NodeDataBuilder::new("text_2").build();
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_1,
      rev_id: 1,
    },
    // The node at path 1 is not existing when inserting the text_2 to path 2.
    InsertNode {
      path: 2.into(),
      node_data: text_2.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: 1.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 2.into(),
      expected: Some(text_2),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_when_parent_is_not_exist_test2() {
  let mut test = NodeTest::new();
  let text_1 = NodeDataBuilder::new("text_1").build();
  let text_2 = NodeDataBuilder::new("text_2").build();
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_1,
      rev_id: 1,
    },
    // The node at path 1 is not existing when inserting the text_2 to path 2.
    InsertNode {
      path: 3.into(),
      node_data: text_2.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: 1.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 2.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 3.into(),
      expected: Some(text_2),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_when_its_parent_is_not_exist_test3() {
  let mut test = NodeTest::new();
  let text_1 = NodeDataBuilder::new("text_1").build();
  let text_2 = NodeDataBuilder::new("text_2").build();

  let mut placeholder_node = placeholder_node();
  placeholder_node.children.push(text_2.clone());

  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_1,
      rev_id: 1,
    },
    // The node at path 1 is not existing when inserting the text_2 to path 2.
    InsertNode {
      path: vec![1, 0].into(),
      node_data: text_2.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: 1.into(),
      expected: Some(placeholder_node),
    },
    AssertNode {
      path: vec![1, 0].into(),
      expected: Some(text_2),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_to_the_end_when_parent_is_not_exist_test() {
  let mut test = NodeTest::new();
  let node_0 = NodeData::new("0");
  let node_1 = NodeData::new("1");
  let node_1_1 = NodeData::new("1_1");
  let text_node = NodeData::new("text");
  let mut ghost = placeholder_node();
  ghost.children.push(text_node.clone());
  // 0:0
  // 1:1
  //      0:1_1
  //      1:ghost
  //              0:text
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: node_0,
      rev_id: 1,
    },
    InsertNode {
      path: 1.into(),
      node_data: node_1,
      rev_id: 2,
    },
    InsertNode {
      path: vec![1, 0].into(),
      node_data: node_1_1.clone(),
      rev_id: 3,
    },
    InsertNode {
      path: vec![1, 1, 0].into(),
      node_data: text_node.clone(),
      rev_id: 4,
    },
    AssertNode {
      path: vec![1, 0].into(),
      expected: Some(node_1_1),
    },
    AssertNode {
      path: vec![1, 1].into(),
      expected: Some(ghost),
    },
    AssertNode {
      path: vec![1, 1, 0].into(),
      expected: Some(text_node),
    },
  ];
  test.run_scripts(scripts);
}
#[test]
fn operation_insert_node_when_multiple_parent_is_not_exist_test() {
  let mut test = NodeTest::new();
  let text_1 = NodeDataBuilder::new("text_1").build();
  let text_2 = NodeDataBuilder::new("text_2").build();

  let path = vec![1, 0, 0, 0, 0, 0];
  let mut auto_fill_node = placeholder_node();
  let mut iter_node: &mut NodeData = &mut auto_fill_node;
  let insert_path = path.split_at(1).1;
  for (index, _) in insert_path.iter().enumerate() {
    if index == insert_path.len() - 1 {
      iter_node.children.push(text_2.clone());
    } else {
      iter_node.children.push(placeholder_node());
      iter_node = iter_node.children.last_mut().unwrap();
    }
  }

  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_1,
      rev_id: 1,
    },
    InsertNode {
      path: path.clone().into(),
      node_data: text_2.clone(),
      rev_id: 2,
    },
    AssertNode {
      path: vec![1].into(),
      expected: Some(auto_fill_node),
    },
    AssertNode {
      path: path.into(),
      expected: Some(text_2),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_when_multiple_parent_is_not_exist_test2() {
  let mut test = NodeTest::new();
  // 0:ghost
  //        0:ghost
  //        1:ghost
  //               0:text
  let mut text_node_parent = placeholder_node();
  let text_node = NodeDataBuilder::new("text").build();
  text_node_parent.children.push(text_node.clone());

  let mut ghost = placeholder_node();
  ghost.children.push(placeholder_node());
  ghost.children.push(text_node_parent.clone());

  let path = vec![1, 1, 0];
  let scripts = vec![
    InsertNode {
      path: path.into(),
      node_data: text_node.clone(),
      rev_id: 1,
    },
    // 0:ghost
    // 1:ghost
    //        0:ghost
    //        1:ghost
    //               0:text
    AssertNode {
      path: 0.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 1.into(),
      expected: Some(ghost),
    },
    AssertNumberOfChildrenAtPath {
      path: Some(1.into()),
      expected: 2,
    },
    AssertNode {
      path: vec![1, 1].into(),
      expected: Some(text_node_parent),
    },
    AssertNode {
      path: vec![1, 1, 0].into(),
      expected: Some(text_node),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_insert_node_when_multiple_parent_is_not_exist_test3() {
  let mut test = NodeTest::new();
  let text_node = NodeDataBuilder::new("text").build();
  let path = vec![3, 3, 0];
  let scripts = vec![
    InsertNode {
      path: path.clone().into(),
      node_data: text_node.clone(),
      rev_id: 1,
    },
    // 0:ghost
    // 1:ghost
    // 2:ghost
    // 3:ghost
    //        0:ghost
    //        1:ghost
    //        2:ghost
    //        3:ghost
    //               0:text
    AssertNode {
      path: 0.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 1.into(),
      expected: Some(placeholder_node()),
    },
    AssertNode {
      path: 2.into(),
      expected: Some(placeholder_node()),
    },
    AssertNumberOfChildrenAtPath {
      path: Some(3.into()),
      expected: 4,
    },
    AssertNode {
      path: path.into(),
      expected: Some(text_node),
    },
  ];
  test.run_scripts(scripts);
}
