mod util;

use otvec::Operation;
use util::{test_transform, test_transform_sym};

use rstest::rstest;

#[rstest]
#[case(0, 1, 0, &[1, 2, 3, 4, 5])]
#[case(0, 1, 1, &[1, 2, 3, 4, 5])]
#[case(0, 1, 2, &[2, 1, 3, 4, 5])]
fn apply_mov(#[case] pos: usize, #[case] n: usize, #[case] to: usize, #[case] expect: &[i32]) {
    let mut input = vec![1, 2, 3, 4, 5];
    let op = Operation::Mov { pos, n, to };
    op.apply(&mut input);
    assert_eq!(input, expect);
}

#[test]
fn print() {
    let input = vec![1, 2, 3, 4, 5];

    let op = Operation::Mov {
        pos: 1,
        n: 2,
        to: 4,
    };
    op.print_on(&input);
}

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

#[test]
fn transform_ins_ins_same_pos() {
    let input = [1, 4];

    let a = Operation::Ins {
        pos: 1,
        val: vec![2],
    };
    let b = Operation::Ins {
        pos: 1,
        val: vec![3],
    };
    test_transform(&a, &b, &input, &[1, 2, 3, 4]);
    test_transform(&b, &a, &input, &[1, 3, 2, 4]);
}

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

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

#[test]
fn transform_del_del_same_pos() {
    let a = Operation::Del { pos: 1, n: 1 };
    let b = Operation::Del { pos: 1, n: 1 };
    test_transform_sym(&a, &b, &[1, 2, 3], &[1, 3]);
}

#[test]
fn transform_del_del_mult() {
    let a = Operation::Del { pos: 1, n: 2 };
    let b = Operation::Del { pos: 4, n: 3 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6, 7, 8], &[1, 4, 8]);
}

#[test]
fn transform_del_del_overlap() {
    let a = Operation::Del { pos: 1, n: 4 };
    let b = Operation::Del { pos: 3, n: 3 };
    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6, 7, 8], &[1, 7, 8]);
}

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

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

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

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

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

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

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

#[test]
fn transform_mov_ins() {
    let input = [1, 3, 4, 5];

    let a = Operation::Mov {
        pos: 3,
        n: 1,
        to: 1,
    };
    let b = Operation::Ins {
        pos: 1,
        val: vec![2],
    };
    test_transform(&a, &b, &input, &[1, 5, 2, 3, 4]);
    test_transform(&b, &a, &input, &[1, 2, 5, 3, 4]);
}

#[test]
fn transform_mov_ins2() {
    let input = [1, 2, 3, 5];

    let a = Operation::Mov {
        pos: 1,
        n: 1,
        to: 3,
    };
    let b = Operation::Ins {
        pos: 3,
        val: vec![4],
    };
    test_transform(&a, &b, &input, &[1, 3, 2, 4, 5]);
    test_transform(&b, &a, &input, &[1, 3, 4, 2, 5]);
}

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

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

#[test]
fn transform_mov_del_within_dst_r() {
    // [1, (2), 3, 4, 5, 6] => [1, 3, 4, 5, (2), 6]
    let a = Operation::Mov {
        pos: 1,
        n: 1,
        to: 4,
    };
    // [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, 3, 2]);
}

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

    test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[5, 4, 6]);
}

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

    test_transform_sym(&a, &b, &[1, 2, 3, 4], &[3, 2, 4]);
}

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

    test_transform_sym(&a, &b, &[1, 2, 3, 4], &[1, 3, 2]);
}

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

    test_transform_sym(&a, &b, &[1, 2, 3, 4], &[2, 1]);
}

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

    test_transform_sym(&a, &b, &[1, 2, 3, 4], &[4, 3]);
}

#[test]
fn transform_mov_mov() {
    let input = [1, 2, 3, 4];

    let a = Operation::Mov {
        pos: 1,
        n: 1,
        to: 0,
    };
    let b = Operation::Mov {
        pos: 1,
        n: 1,
        to: 3,
    };
    test_transform(&a, &b, &input, &[1, 3, 2, 4]);
    test_transform(&b, &a, &input, &[2, 1, 3, 4]);
}

#[test]
fn transform_mov_mov2() {
    let input = [1, 2, 3, 4];

    let a = Operation::Mov {
        pos: 0,
        n: 1,
        to: 2,
    };
    let b = Operation::Mov {
        pos: 3,
        n: 1,
        to: 2,
    };
    test_transform(&a, &b, &input, &[2, 1, 4, 3]);
    test_transform(&b, &a, &input, &[2, 4, 1, 3]);
}

#[test]
fn transform_mov_mov3() {
    let input = [1, 2, 3, 4];

    let a = Operation::Mov {
        pos: 2,
        n: 1,
        to: 1,
    };
    let b = Operation::Mov {
        pos: 3,
        n: 1,
        to: 1,
    };
    test_transform(&a, &b, &input, &[1, 3, 4, 2]);
    test_transform(&b, &a, &input, &[1, 4, 3, 2]);
}

#[test]
fn transform_mov_mov4() {
    let input = [1, 2, 3, 4];

    let a = Operation::Mov {
        pos: 0,
        n: 1,
        to: 2,
    };
    let b = Operation::Mov {
        pos: 2,
        n: 1,
        to: 0,
    };
    test_transform(&a, &b, &input, &[3, 2, 1, 4]);
    // test_transform(&b, &a, &input, &[1, 4, 3, 2]); TODO: difference from reference impl
}

#[test]
fn transform_mov_mov5() {
    let input = [1, 2, 3, 4];

    let a = Operation::Mov {
        pos: 0,
        n: 1,
        to: 3,
    };
    let b = Operation::Mov {
        pos: 0,
        n: 1,
        to: 3,
    };
    test_transform(&a, &b, &input, &[2, 3, 1, 4]);
}