// Old code that can be thrown out

fn () {
    // Doc(doc![
    //     DocGroup({"tag": "h1"}, [
    //         // DocGroup({"tag": "caret", "client": "left"}, []),
    //         // DocGroup({"tag": "caret", "client": "right"}, []),
    //         DocChars("Hello world!"),
    //     ]),
    //     DocGroup({"tag": "p"}, [
    //         // DocChars("What's "),
    //         // DocGroup({"tag": "span", "class": "bold"}, [DocChars("new and great")]),
    //         // DocChars(" with you?"),
    //         DocChars("This is Mercutio, a rich text editor."),
    //     ]),
    //     // DocGroup({"tag": "ul"}, [
    //     //     DocGroup({"tag": "li"}, [
    //     //         DocGroup({"tag": "p"}, [
    //     //             DocChars("Three adjectives strong."),
    //     //         ]),
    //     //         DocGroup({"tag": "p"}, [
    //     //             DocChars("World!"),
    //     //         ]),
    //     //     ]),
    //     // ])
    // ])
}


// #[derive(Clone)]
// pub struct MoteState {
//     pub body: Arc<Mutex<Doc>>,
// }

// pub fn action_sync(doc: &Doc, ops_a: Vec<Op>, ops_b: Vec<Op>) -> Result<(Doc, Op), Error> {
//     println!(" ---> input ops_a");
//     println!("{:?}", ops_a);
//     println!();

//     // Flatten client A operations.
//     let mut op_a = op_span!([], []);
//     for op in &ops_a {
//         op_a = Op::compose(&op_a, op);
//     }

//     println!(" ---> input ops_b");
//     println!("{:?}", ops_b);
//     println!();

//     // Flatten client B operations.
//     let mut op_b = op_span!([], []);
//     for op in &ops_b {
//         op_b = Op::compose(&op_b, op);
//     }

//     println!("OP A {:?}", op_a);
//     println!("OP B {:?}", op_b);

//     let test = format!(
//         r#"
// doc:   {}

// a_del: {}
// a_add: {}

// b_del: {}
// b_add: {}
// "#,
//         debug_pretty(&doc.0),
//         debug_pretty(&op_a.0),
//         debug_pretty(&op_a.1),
//         debug_pretty(&op_b.0),
//         debug_pretty(&op_b.1)
//     );

//     // TODO dump to document
//     {
//         use std::io::prelude::*;
//         let mut f = ::std::fs::File::create("test.txt").unwrap();
//         f.write_all(&test.as_bytes()).unwrap();
//         f.sync_all().unwrap();
//     }

//     println!();
//     println!("<test>");
//     print!("{}", test);
//     println!("</test>");
//     println!();

//     println!("(!) recreating initial client state...");
//     println!();

//     // TODO remove this validation code if we're performing the check client-side

//     // let mut check_op_a = op_span!([], []);
//     // for (i, op) in ops_a.iter().enumerate() {
//     //     println!("  A: applying {:?}/{:?}", i + 1, ops_a.len());
//     //     check_op_a = Op::compose(&check_op_a, &op);
//     //     println!(" op: {}", debug_pretty(&check_op_a));
//     //     let _ = Op::apply(&doc.clone(), &check_op_a);
//     // }

//     // println!();

//     // let mut check_op_b = op_span!([], []);
//     // for (i, op) in ops_b.iter().enumerate() {
//     //     println!("  B: applying {:?}/{:?}", i + 1, ops_b.len());
//     //     check_op_b = Op::compose(&check_op_b, &op);
//     //     println!(" op: {}", debug_pretty(&check_op_b));
//     //     let _ = Op::apply(&doc.clone(), &check_op_b);
//     // }

//     let doc_a = Op::apply(&doc.clone(), &op_a);
//     let doc_b = Op::apply(&doc.clone(), &op_b);

//     println!("ok");
//     println!();

//     println!("(!) applying transformed operations...");

//     // Tranform
//     let (a_, b_) = transform::<RtfSchema>(&op_a, &op_b);

//     println!("");
//     println!("DOC A {:?}", doc_a);
//     println!("OP A' {:?}", a_);
//     let a_res = Op::apply(&doc_a, &a_);

//     println!("");
//     println!("DOC B {:?}", doc_b);
//     println!("OP B' {:?}", b_);
//     let b_res = Op::apply(&doc_b, &b_);

//     println!("");
//     println!("a res {:?}", a_res);
//     println!("b res {:?}", b_res);

//     println!("equal? {:?}", a_res == b_res);

//     let success = if a_res != b_res { false } else { true };

//     // TODO return error when success is false

//     let new_doc = Doc(a_res.0);
//     validate_doc(&new_doc).expect("Validation error");

//     Ok((new_doc, Op::compose(&op_a, &a_)))
// }
