mod util;

use otvec::Operation;
use util::test_transform_sym;

// MOV - INS

#[test]
fn transform_mov_ins_mult_below() {
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 2,
    };
    let b = Operation::Ins {
        pos: 1,
        val: vec![8, 9],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 8, 9, 2, 4, 5, 3]);
}

#[test]
fn transform_mov_ins_mult_above() {
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 5,
    };
    let b = Operation::Ins {
        pos: 3,
        val: vec![8, 9],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 8, 9, 4, 5, 2, 3]);
}

#[test]
fn transform_mov_ins_mult_split() {
    // [1, (2, 3), 4, 5] => [1, 4, 5, (2, 3)]
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 5,
    };

    // [1, 2, 3, 4, 5] => [1, 2, (7, 8, 9), 3, 4, 5]

    // [1,(2),7, 8, 9,(3),4, 5]

    // [1, 2,(7, 8, 9),3, 4, 5]
    // [1, 2, 3, 4,(7, 8, 9) 5] move inserted range n_mov to right, joining moved range
    // [1, 4, 7, 8, 9, 5,(2, 3)] move moved range to target

    let b = Operation::Ins {
        pos: 2,
        val: vec![7, 8, 9],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 4, 5, 2, 7, 8, 9, 3]);
}

#[test]
fn transform_mov_ins_mult_split2() {
    // [1, (2, 3), 4, 5, 6, 0] => [1, 4, 5, 6, (2, 3), 0]
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 6,
    };
    // [1, 2, 3, 4, 5, 6, 0] => [1, 2, (7, 8, 9), 3, 4, 5, 6, 0]

    // [1, 2,(7, 8, 9),3, 4, 5, 6, 0]
    // [1, 2, 3, 4,(7, 8, 9) 5, 6, 0] move inserted range n_mov to right, joining moved range
    // [1, 4, 5, 7, 8, 9, 5,(2, 3),0] move moved range to target

    let b = Operation::Ins {
        pos: 2,
        val: vec![7, 8, 9],
    };
    test_transform_sym(
        &a,
        &b,
        &[1, 2, 3, 4, 5, 6, 0],
        &[1, 4, 5, 6, 2, 7, 8, 9, 3, 0],
    );
}

#[test]
fn transform_mov_ins_mult_split3() {
    // [1, (2, 3, 4), 5, 6, 0] => [1, 5, 6, (2, 3, 4), 0]
    let a = Operation::Mov {
        pos: 1,
        n: 3,
        to: 6,
    };
    // [1, 2, 3, 4, 5, 6, 0] => [1, 2, (7, 8, 9), 3, 4, 5, 6, 0]

    // [1, 2,(7, 8, 9),3, 4, 5, 6, 0]
    // [1, 2, 3, 4, 5,(7, 8, 9),6, 0] move inserted range n_mov to right, joining moved range
    // [1, 4, 5, 7, 8, 9, 5,(2, 3),0] move moved range to target

    let b = Operation::Ins {
        pos: 2,
        val: vec![7, 8, 9],
    };
    test_transform_sym(
        &a,
        &b,
        &[1, 2, 3, 4, 5, 6, 0],
        &[1, 5, 6, 2, 7, 8, 9, 3, 4, 0],
    );
}

#[test]
fn transform_mov_ins_mult_split4() {
    // [1, 2, 3, 4, 5, (6, 0)] => [1, (6, 0), 2, 3, 4, 5]
    let a = Operation::Mov {
        pos: 5,
        n: 2,
        to: 1,
    };
    // [1, 2, 3, 4, 5, 6, 0] => [1, 2, 3, 4, 5, 6, (7, 8, 9), 0]

    // [1, 2, 3, 4, 5, 6,(7, 8, 9),0]
    // [1, 2, 3, 4,(7, 8, 9) 5, 6, 0] move inserted range n_mov to left, joining moved range
    // [1,(6, 0),2, 3, 4, 7, 8, 9, 5] move moved range to target

    let b = Operation::Ins {
        pos: 6,
        val: vec![7, 8, 9],
    };
    test_transform_sym(
        &a,
        &b,
        &[1, 2, 3, 4, 5, 6, 0],
        &[1, 6, 7, 8, 9, 0, 2, 3, 4, 5],
    );
}

#[test]
fn transform_mov_ins_mult_same() {
    let a = Operation::Mov {
        pos: 0,
        n: 2,
        to: 5,
    };
    let b = Operation::Ins {
        pos: 0,
        val: vec![1, 2],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 2, 3, 4, 5, 1, 2]);
}

#[test]
fn transform_mov_ins_mult_within() {
    // [1, 2, 3, 4, 5] => [4, 5, 1, 2, 3]
    let a = Operation::Mov {
        pos: 0,
        n: 3,
        to: 5,
    };
    // [1, 2, 3, 4, 5] => [1, 8, 9, 2, 3, 4, 5]
    let b = Operation::Ins {
        pos: 1,
        val: vec![8, 9],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[4, 5, 1, 8, 9, 2, 3]);
}

#[test]
fn transform_mov_ins_mult_over() {
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 4,
    };
    let b = Operation::Ins {
        pos: 1,
        val: vec![6, 7, 8],
    };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 6, 7, 8, 4, 2, 3, 5]);
}

/*
// MOV - DEL

#[test]
fn transform_mov_del_mult_same() {
    let a = Operation::Mov {
        pos: 0,
        n: 2,
        to: 3,
    };
    let b = Operation::Del { pos: 0, n: 2 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[3, 4, 5]);
}

#[test]
fn transform_mov_del_within_r_aft() {
    // [0, (1, 2), 3, 4, 5] => [0, 3, 4, (1, 2), 5]
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 4,
    };
    // [0, (1, 2, 3), 4, 5] => [0, 4, 5]
    let b = Operation::Del { pos: 1, n: 3 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5], &[0, 4, 5]);
}

#[test]
fn transform_mov_del_within_r_bef() {
    // [1, 2, 3, (4), 5, 6] => [1, 2, 3, 5, (4), 6]
    let a = Operation::Mov {
        pos: 3,
        n: 1,
        to: 4,
    };
    // [1, 2, (3, 4), 5, 6] => [1, 2, 5, 6]
    let b = Operation::Del { pos: 2, n: 2 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[1, 2, 5, 6]);
}

#[test]
fn transform_mov_del_within_l_bef() {
    // [1, 2, 3, (4, 5), 6] => [(4, 5), 1, 2, 3, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 0,
    };
    // [1, 2, (3, 4, 5), 6] => [1, 2, 6]
    let b = Operation::Del { pos: 2, n: 3 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[1, 2, 6]);
}

#[test]
fn transform_mov_del_within_l_to_within() {
    // [0, 1, 2, (3), 4, 5] => [0, 1, (3), 2, 4, 5]
    let a = Operation::Mov {
        pos: 3,
        n: 1,
        to: 2,
    };
    // [0, (1, 2, 3), 4, 5] => [0, 4, 5]
    let b = Operation::Del { pos: 1, n: 3 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5], &[0, 4, 5]);
}

#[test]
fn transform_mov_del_within_l_to_within2() {
    // [0, 1, 2, (3, 4), 5, 6, 7] => [0, 1, (3, 4), 2, 5, 6, 7]
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 2,
    };
    // [0, (1, 2, 3, 4, 5), 6, 7] => [0, 6, 7]
    let b = Operation::Del { pos: 1, n: 5 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6, 7], &[0, 6, 7]);
}

#[test]
fn transform_mov_del_within_l_to_abover() {
    // [0, 1, 2, (3, 4), 5, 6, 7] => [(3, 4), 0, 1, 2, 5, 6, 7]
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 0,
    };
    // [0, (1, 2, 3, 4, 5), 6, 7] => [0, 6, 7]
    let b = Operation::Del { pos: 1, n: 5 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6, 7], &[0, 6, 7]);
}

#[test]
fn transform_mov_del_within_l_aft() {
    // [1, 2, 3, (4, 5), 6] => [(4, 5), 1, 2, 3, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 0,
    };
    // [1, 2, 3, (4, 5, 6)] => [1, 2, 3]
    let b = Operation::Del { pos: 3, n: 3 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[1, 2, 3]);
}

#[test]
fn transform_mov_del_over_r() {
    // [0, (1, 2, 3), 4, 5, 6] => [0, 4, 5, (1, 2, 3), 6]
    let a = Operation::Mov {
        pos: 1,
        n: 3,
        to: 3,
    };
    // [0, (1, 2), 3, 4, 5, 6] => [0, 3, 4, 5, 6]
    let b = Operation::Del { pos: 1, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 4, 5, 3, 6]);
}

#[test]
fn transform_mov_del_over_l() {
    // [0, 1, 2, (3, 4, 5), 6] => [0, 3, 4, 5, 1, 2, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 3,
        to: 1,
    };
    // [0, 1, 2, 3, (4, 5), 6] => [0, 1, 2, 3, 6]
    let b = Operation::Del { pos: 4, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 3, 1, 2, 6]);
}

#[test]
fn transform_mov_del_below() {
    // [0, (1, 2), 3, 4, 5] => [0, 3, 4, (1, 2), 5]
    let a = Operation::Mov {
        pos: 1,
        n: 2,
        to: 3,
    };
    // [0, 1, 2, (3, 4), 5] => [0, 1, 2, 5]
    let b = Operation::Del { pos: 3, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5], &[0, 1, 2, 5]);
}

#[test]
fn transform_mov_del_above() {
    // [0, 1, 2, (3, 4), 5] => [0, (3, 4), 1, 2, 5]
    let a = Operation::Mov {
        pos: 3,
        n: 2,
        to: 1,
    };
    // [0, (1, 2), 3, 4, 5] => [0, 3, 4, 5]
    let b = Operation::Del { pos: 1, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5], &[0, 3, 4, 5]);
}

#[test]
fn transform_mov_del_below_overlap_r() {
    // [0, (1, 2, 3), 4, 5, 6] => [0, 4, 5, (1, 2, 3), 6]
    let a = Operation::Mov {
        pos: 1,
        n: 3,
        to: 3,
    };
    // [0, 1, 2, (3, 4), 5, 6] => [0, 1, 2, 5, 6]
    let b = Operation::Del { pos: 3, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 5, 1, 2, 6]);
}

#[test]
fn transform_mov_del_below_overlap_r2() {
    // [0, (1, 2, 3, 4), 5, 6] => [0, 5, (1, 2, 3, 4), 6]
    let a = Operation::Mov {
        pos: 1,
        n: 4,
        to: 2,
    };
    // [0, 1, 2, (3, 4, 5), 6] => [0, 1, 2, 6]
    let b = Operation::Del { pos: 3, n: 3 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 1, 2, 6]);
}

#[test]
fn transform_mov_del_below_overlap_r3() {
    // [0, (1, 2, 3, 4), 5, 6, 7] => [0, 5, 6, (1, 2, 3, 4), 7]
    let a = Operation::Mov {
        pos: 1,
        n: 4,
        to: 3,
    };
    // [0, 1, 2, (3, 4, 5), 6, 7] => [0, 1, 2, 6, 7]
    let b = Operation::Del { pos: 3, n: 3 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6, 7], &[0, 6, 1, 2, 7]);
}

#[test]
fn transform_mov_del_below_overlap_l() {
    // [0, 1, 2, (3, 4, 5), 6] => [0, (3, 4, 5), 1, 2, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 3,
        to: 1,
    };
    // [0, 1, 2, 3, 4, (5, 6)] => [0, 1, 2, 3, 4]
    let b = Operation::Del { pos: 5, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 3, 4, 1, 2]);
}

#[test]
fn transform_mov_del_below_overlap_l2() {
    // [0, 1, (2, 3, 4, 5), 6] => [0, (2, 3, 4, 5), 1, 6]
    let a = Operation::Mov {
        pos: 2,
        n: 4,
        to: 1,
    };
    // [0, 1, 2, 3, 4, (5, 6)] => [0, 1, 2, 3, 4]
    let b = Operation::Del { pos: 5, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 2, 3, 4, 1]);
}

#[test]
fn transform_mov_del_below_overlap_l3() {
    // [0, 1, 2, (3, 4, 5, 6), 7] => [0, (3, 4, 5, 6), 1, 2, 7]
    let a = Operation::Mov {
        pos: 3,
        n: 4,
        to: 1,
    };
    // [0, 1, 2, 3, (4, 5, 6, 7)] => [0, 1, 2, 3]
    let b = Operation::Del { pos: 4, n: 4 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6, 7], &[0, 3, 1, 2]);
}

#[test]
fn transform_mov_del_below_overlap_l4() {
    // [0, 1, 2, 3, 4, (5, 6, 7, 8, 9), 10, 11] => [0, (5, 6, 7, 8, 9), 1, 2, 3, 4, 10, 11]
    let a = Operation::Mov {
        pos: 5,
        n: 5,
        to: 1,
    };
    // [0, 1, 2, 3, 4, 5, 6, 7, (8, 9, 10), 11] => [0, 1, 2, 3, 4, 5, 6, 7, 11]
    let b = Operation::Del { pos: 8, n: 3 };
    test_transform_sym(
        &a,
        &b,
        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        &[0, 5, 6, 7, 1, 2, 3, 4, 11],
    );
}

#[test]
fn transform_mov_del_above_overlap_r() {
    // [0, (1, 2, 3), 4, 5, 6] => [0, 4, 5, (1, 2, 3), 6]

    let a = Operation::Mov {
        pos: 1,
        n: 3,
        to: 6,
    };
    // [(0, 1), 2, 3, 4, 5, 6] => [2, 3, 4, 5, 6]
    let b = Operation::Del { pos: 0, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[4, 5, 2, 3, 6]);
}

#[test]
fn transform_mov_del_other_dir() {
    // [0, 1, 2, (3, 4, 5), 6] => [0, (3, 4, 5), 1, 2, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 3,
        to: 1,
    };
    // [0, 1, 2, 3, 4, (5, 6)] => [0, 1, 2, 3, 4]
    let b = Operation::Del { pos: 5, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[4, 5, 2, 3, 6]);
}

#[test]
fn transform_mov_del_above_overlap_r2() {
    // [0, (1, 2, 3, 4), 5, 6] => [0, 5, (1, 2, 3, 4), 6]
    let a = Operation::Mov {
        pos: 1,
        n: 4,
        to: 2,
    };
    // [(0, 1), 2, 3, 4, 5, 6] => [2, 3, 4, 5, 6]
    let b = Operation::Del { pos: 0, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[5, 2, 3, 4, 6]);
}

#[test]
fn transform_mov_del_above_overlap_r3() {
    // [0, (1, 2, 3, 4), 5, 6, 7] => [0, 5, 6, (1, 2, 3, 4), 7]
    let a = Operation::Mov {
        pos: 1,
        n: 4,
        to: 3,
    };
    // [(0, 1), 2, 3, 4, 5, 6, 7] => [2, 3, 4, 5, 6, 7]
    let b = Operation::Del { pos: 0, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6, 7], &[5, 6, 2, 3, 4, 7]);
}

#[test]
fn transform_mov_del_above_overlap_l() {
    // [0, 1, 2, (3, 4, 5), 6] => [0, (3, 4, 5), 1, 2, 6]
    let a = Operation::Mov {
        pos: 3,
        n: 3,
        to: 1,
    };
    // [0, 1, (2, 3), 4, 5, 6] => [0, 1, 4, 5, 6]
    let b = Operation::Del { pos: 2, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 4, 5, 1, 6]);
}

#[test]
fn transform_mov_del_above_overlap_l2() {
    // [0, 1, (2, 3, 4, 5), 6] => [0, (2, 3, 4, 5), 1, 6]
    let a = Operation::Mov {
        pos: 2,
        n: 4,
        to: 1,
    };
    // [0, (1, 2), 3, 4, 5, 6] => [0, 3, 4, 5, 6]
    let b = Operation::Del { pos: 1, n: 2 };
    test_transform_sym(&a, &b, &[0, 1, 2, 3, 4, 5, 6], &[0, 3, 4, 5, 6]);
}
*/