#![allow(clippy::unit_arg)]

use std::fmt::{Debug, Error, Formatter, Write};

use crate::Vector;

use proptest::proptest;
use proptest_derive::Arbitrary;

#[derive(Arbitrary, Debug)]
enum Action<A> {
    PushFront(A),
    PushBack(A),
    PopFront,
    PopBack,
    Insert(usize, A),
    Remove(usize),
    JoinLeft(Vec<A>),
    JoinRight(Vec<A>),
    SplitLeft(usize),
    SplitRight(usize),
}

#[derive(Arbitrary)]
struct Actions<A>(Vec<Action<A>>)
where
    A: Clone;

impl<A> Debug for Actions<A>
where
    A: Debug + Clone,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let mut out = String::new();
        let mut expected = vec![];
        writeln!(out, "let mut vec = Vector::new();")?;
        for action in &self.0 {
            match action {
                Action::PushFront(ref value) => {
                    expected.insert(0, value.clone());
                    writeln!(out, "vec.push_front({:?});", value)?
                }
                Action::PushBack(ref value) => {
                    expected.push(value.clone());
                    writeln!(out, "vec.push_back({:?});", value)?
                }
                Action::PopFront => {
                    if !expected.is_empty() {
                        expected.remove(0);
                    }
                    writeln!(out, "vec.pop_front();")?
                }
                Action::PopBack => {
                    expected.pop();
                    writeln!(out, "vec.pop_back();")?
                }
                Action::Insert(ref index, ref value) => {
                    let index = cap_index(expected.len(), *index);
                    expected.insert(index, value.clone());
                    writeln!(out, "vec.insert({:?}, {:?});", index, value)?
                }
                Action::Remove(ref index) => {
                    if !expected.is_empty() {
                        let index = cap_index(expected.len(), *index);
                        expected.remove(index);
                        writeln!(out, "vec.remove({:?})", index)?
                    } else {
                        continue;
                    }
                }
                Action::JoinLeft(ref vec) => {
                    let mut vec_new = vec.clone();
                    vec_new.append(&mut expected);
                    expected = vec_new;
                    writeln!(
                        out,
                        "let mut vec_new = Vector::from(vec!{:?}); // size {:?}",
                        vec,
                        vec.len()
                    )?;
                    writeln!(out, "vec_new.append(vec);")?;
                    writeln!(out, "vec = vec_new;")?
                }
                Action::JoinRight(ref vec) => {
                    expected.append(&mut vec.clone());
                    writeln!(
                        out,
                        "vec.append(Vector::from(vec!{:?})); // size {:?}",
                        vec,
                        vec.len()
                    )?
                }
                Action::SplitLeft(ref index) => {
                    let index = cap_index(expected.len(), *index);
                    expected.truncate(index);
                    writeln!(out, "vec.split_off({:?});", index)?
                }
                Action::SplitRight(ref index) => {
                    let index = cap_index(expected.len(), *index);
                    expected = expected.split_off(index);
                    writeln!(out, "vec = vec.split_off({:?});", index)?
                }
            }
            writeln!(out, "// len = {:?}", expected.len())?;
        }
        writeln!(out, "let expected = vec!{:?};", expected)?;
        writeln!(out, "assert_eq!(Vector::from(expected), vec);")?;
        write!(f, "{}", super::code_fmt(&out))
    }
}

fn cap_index(len: usize, index: usize) -> usize {
    if len == 0 {
        0
    } else {
        index % len
    }
}

proptest! {
    #[test]
    fn comprehensive(actions: Actions<u8>) {
        let mut vec = Vector::new();
        let mut nat = Vec::new();
        vec.assert_invariants();
        for action in actions.0 {
            match action {
                Action::PushFront(value) => {
                    let len = vec.len();
                    nat.insert(0, value);
                    vec.push_front(value);
                    assert_eq!(len + 1, vec.len());
                }
                Action::PushBack(value) => {
                    let len = vec.len();
                    nat.push(value);
                    vec.push_back(value);
                    assert_eq!(len + 1, vec.len());
                }
                Action::PopFront => {
                    if vec.is_empty() {
                        assert_eq!(None, vec.pop_front());
                    } else {
                        let len = vec.len();
                        assert_eq!(nat.remove(0), vec.pop_front().unwrap());
                        assert_eq!(len - 1, vec.len());
                    }
                }
                Action::PopBack => {
                    if vec.is_empty() {
                        assert_eq!(None, vec.pop_back());
                    } else {
                        let len = vec.len();
                        assert_eq!(nat.pop(), vec.pop_back());
                        assert_eq!(len - 1, vec.len());
                    }
                }
                Action::Insert(index, value) => {
                    let index = cap_index(vec.len(), index);
                    let len = vec.len();
                    nat.insert(index, value);
                    vec.insert(index, value);
                    assert_eq!(len + 1, vec.len());
                }
                Action::Remove(index) => {
                    if vec.is_empty() {
                        continue;
                    }
                    let index = cap_index(vec.len(), index);
                    let len = vec.len();
                    assert_eq!(nat.remove(index), vec.remove(index));
                    assert_eq!(len - 1, vec.len());
                }
                Action::JoinLeft(mut new_nat) => {
                    let mut new_vec = new_nat.iter().cloned().collect::<Vector<_>>();
                    let add_len = new_nat.len();
                    let len = vec.len();
                    new_vec.append(vec);
                    vec = new_vec;
                    new_nat.append(&mut nat);
                    nat = new_nat;
                    assert_eq!(len + add_len, vec.len());
                }
                Action::JoinRight(mut new_nat) => {
                    let new_vec = new_nat.iter().cloned().collect::<Vector<_>>();
                    let add_len = new_nat.len();
                    let len = vec.len();
                    vec.append(new_vec);
                    nat.append(&mut new_nat);
                    assert_eq!(len + add_len, vec.len());
                }
                Action::SplitLeft(index) => {
                    let index = cap_index(vec.len(), index);
                    let len = vec.len();
                    let vec_right = vec.split_off(index);
                    let nat_right = nat.split_off(index);
                    assert_eq!(index, vec.len());
                    assert_eq!(len - index, vec_right.len());
                    assert_eq!(nat_right.iter().cloned().collect::<Vector<_>>(), vec_right);
                }
                Action::SplitRight(index) => {
                    let index = cap_index(vec.len(), index);
                    let len = vec.len();
                    let vec_right = vec.split_off(index);
                    let nat_right = nat.split_off(index);
                    assert_eq!(index, vec.len());
                    assert_eq!(len - index, vec_right.len());
                    assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec);
                    vec = vec_right;
                    nat = nat_right;
                }
            }
            vec.assert_invariants();
            assert_eq!(nat.len(),vec.len());
            assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec);
        }
    }
}

#[test]
fn test_inserts() {
    const N: usize = 2000;
    let mut v = Vector::new();
    for i in 0..N {
        v.insert(v.len() / 2, i);
    }
    let mut rv: Vec<usize> = Vec::new();
    rv.extend((0..N).skip(1).step_by(2));
    rv.extend((0..N).step_by(2).rev());
    assert_eq!(rv.iter().cloned().collect::<Vector<_>>(), v);
}