use crate::{*, Direction::*};
//use proptest_derive::Arbitrary;
use proptest::{prelude::*, option::of};

proptest! {
    #[test] fn proptest_direction (
        d in prop_oneof![
            Just(North), Just(South),
            Just(East),  Just(West),
            Just(Above), Just(Below)
        ],
        x in u16::MIN..u16::MAX,
        y in u16::MIN..u16::MAX,
        w in u16::MIN..u16::MAX,
        h in u16::MIN..u16::MAX,
        a in u16::MIN..u16::MAX,
    ) {
        let _ = d.split_fixed([x, y, w, h], a);
    }
}

proptest! {
    #[test] fn proptest_size (
        x in u16::MIN..u16::MAX,
        y in u16::MIN..u16::MAX,
        a in u16::MIN..u16::MAX,
        b in u16::MIN..u16::MAX,
    ) {
        let size = [x, y];
        let _ = size.w();
        let _ = size.h();
        let _ = size.wh();
        let _ = size.clip_w(a);
        let _ = size.clip_h(b);
        let _ = size.expect_min(a, b);
        let _ = size.to_area_pos();
        let _ = size.to_area_size();
    }
}

proptest! {
    #[test] fn proptest_area (
        x in u16::MIN..u16::MAX,
        y in u16::MIN..u16::MAX,
        w in u16::MIN..u16::MAX,
        h in u16::MIN..u16::MAX,
        a in u16::MIN..u16::MAX,
        b in u16::MIN..u16::MAX,
    ) {
        let _: [u16;4] = <[u16;4] as Area<u16>>::zero();
        let _: [u16;4] = <[u16;4] as Area<u16>>::from_position([a, b]);
        let _: [u16;4] = <[u16;4] as Area<u16>>::from_size([a, b]);
        let area: [u16;4] = [x, y, w, h];
        let _ = area.expect_min(a, b);
        let _ = area.xy();
        let _ = area.wh();
        let _ = area.xywh();
        let _ = area.clip_h(a);
        let _ = area.clip_w(b);
        let _ = area.clip([a, b]);
        let _ = area.set_w(a);
        let _ = area.set_h(b);
        let _ = area.x2();
        let _ = area.y2();
        let _ = area.lrtb();
        let _ = area.center();
        let _ = area.center_x(a);
        let _ = area.center_y(b);
        let _ = area.center_xy([a, b]);
        let _ = area.centered();
    }
}

macro_rules! test_op_transform {
    ($fn:ident, $Op:ident) => {
        proptest! {
            #[test] fn $fn (
                op_x in of(u16::MIN..u16::MAX),
                op_y in of(u16::MIN..u16::MAX),
                content in "\\PC*",
                x in u16::MIN..u16::MAX,
                y in u16::MIN..u16::MAX,
                w in u16::MIN..u16::MAX,
                h in u16::MIN..u16::MAX,
            ) {
                if let Some(op) = match (op_x, op_y) {
                    (Some(x), Some(y)) => Some($Op::xy(x, y, content)),
                    (Some(x), None)    => Some($Op::x(x, content)),
                    (None,    Some(y)) => Some($Op::y(y, content)),
                    _ => None
                } {
                    assert_eq!(Content::layout(&op, [x, y, w, h]),
                               Render::layout(&op,  [x, y, w, h]));
                }
            }
        }
    }
}

test_op_transform!(proptest_op_fixed,   Fixed);
test_op_transform!(proptest_op_min,     Min);
test_op_transform!(proptest_op_max,     Max);
test_op_transform!(proptest_op_push,    Push);
test_op_transform!(proptest_op_pull,    Pull);
test_op_transform!(proptest_op_shrink,  Shrink);
test_op_transform!(proptest_op_expand,  Expand);
test_op_transform!(proptest_op_margin,  Margin);
test_op_transform!(proptest_op_padding, Padding);

proptest! {
    #[test] fn proptest_op_bsp (
        d in prop_oneof![
            Just(North), Just(South),
            Just(East),  Just(West),
            Just(Above), Just(Below)
        ],
        a in "\\PC*",
        b in "\\PC*",
        x in u16::MIN..u16::MAX,
        y in u16::MIN..u16::MAX,
        w in u16::MIN..u16::MAX,
        h in u16::MIN..u16::MAX,
    ) {
        let bsp = Bsp(d, a, b);
        assert_eq!(
            Content::layout(&bsp, [x, y, w, h]),
            Render::layout(&bsp, [x, y, w, h]),
        );
    }
}

#[test] fn test_stub_output () -> Usually<()> {
    use crate::*;
    struct TestOutput([u16;4]);
    impl Output for TestOutput {
        type Unit = u16;
        type Size = [u16;2];
        type Area = [u16;4];
        fn area (&self) -> [u16;4] {
            self.0
        }
        fn area_mut (&mut self) -> &mut [u16;4] {
            &mut self.0
        }
        fn place <T: Render<Self> + ?Sized> (&mut self, _: [u16;4], _: &T) {
            ()
        }
    }
    impl Content<TestOutput> for String {
        fn render (&self, to: &mut TestOutput) {
            to.area_mut().set_w(self.len() as u16);
        }
    }
    Ok(())
}

#[test] fn test_space () {
    use crate::*;
    assert_eq!(Area::center(&[10u16, 10, 20, 20]), [20, 20]);
}

#[test] fn test_iter_map () {
    struct Foo;
    impl<T: Output> Content<T> for Foo {}
    fn _make_map <T: Output, U: Content<T> + Send + Sync> (data: &Vec<U>) -> impl Content<T> {
        Map::new(||data.iter(), |_foo, _index|{})
    }
    let _data = vec![Foo, Foo, Foo];
    //let map = make_map(&data);
}