#[fortuples::auto_impl]
trait SimpleTest {}

impl SimpleTest for i32 {}
impl SimpleTest for f32 {}

#[fortuples::auto_impl]
#[tuples::refs_tuple]
#[tuples::max_size(3)]
trait SimpleForRefs {
    fn only_on_refs();
}

#[fortuples::auto_impl]
#[tuples::refs_tuple(mut)]
#[tuples::max_size(3)]
trait SimpleForMutRefs {
    fn only_on_mut_refs();
}

#[fortuples::auto_impl]
#[tuples::max_size(2)]
trait NoArgs {
    fn foo();

    fn bar();
}

impl NoArgs for i32 {
    fn foo() {}

    fn bar() {}
}

impl NoArgs for char {
    fn foo() {}

    fn bar() {}
}

#[fortuples::auto_impl]
#[tuples::min_size(1)]
#[tuples::max_size(3)]
trait OnlySelf {
    fn foo(self);

    fn bar(&self);

    fn baz(&mut self);
}

impl OnlySelf for i32 {
    fn foo(self) {}

    fn bar(&self) {}

    fn baz(&mut self) {}
}

impl OnlySelf for &'static str {
    fn foo(self) {}

    fn bar(&self) {}

    fn baz(&mut self) {}
}

#[fortuples::auto_impl]
#[tuples::max_size(2)]
trait Args {
    fn bias(&self, out: &mut i32);

    fn sum(&mut self, arg: i32, arg_ref: &i32, out: &mut i32) {
        self.bias(out);
        *out += arg + arg_ref;
    }

    fn diff(arg_ref: &i32, arg: i32, out: &mut i32) {
        *out -= arg_ref - arg;
    }
}

impl Args for i32 {
    fn bias(&self, out: &mut i32) {
        *out += self;
    }
}

#[fortuples::auto_impl]
#[tuples::max_size(2)]
trait Generalized<'a, T, U: From<i32>>
where
    T: Clone,
{
    fn foo_gen<'f, F: From<i32>>(&self, t: T, u: &'a U, f: &'f mut F);

    fn bar_gen<'b, B>(t: T, u: &'a U, f: &'b B)
    where
        B: From<i32>;
}

#[fortuples::auto_impl]
#[tuples::max_size(2)]
trait Wildcard {
    fn wild_foo(&mut self, _: i32, _: &i32);

    fn wild_bar(_: &i32, _: i32, out: &mut i32);
}

impl Wildcard for i32 {
    fn wild_foo(&mut self, i: i32, r: &i32) {
        *self += i + r;
    }

    fn wild_bar(i: &i32, r: i32, out: &mut i32) {
        *out += i + r;
    }
}

#[fortuples::auto_impl]
#[tuples::member_type(i32)]
#[tuples::min_size(1)]
#[tuples::max_size(5)]
trait MemberType {
    fn inc(&mut self);
    fn dec(&mut self);
}

impl MemberType for i32 {
    fn inc(&mut self) {
        *self += 1;
    }

    fn dec(&mut self) {
        *self -= 1;
    }
}

#[fortuples::auto_impl]
#[tuples::max_size(2)]
unsafe trait UnsafeTrait {
    unsafe fn not_safe();
}

#[test]
fn test_auto_impl_simple() {
    fn simple<T: SimpleTest>() {}

    simple::<()>();
    simple::<((),)>();
    simple::<((), i32)>();
    simple::<((), i32, f32)>();
    simple::<((), i32, f32, i32)>();
    simple::<((), i32, f32, i32, ())>();
    simple::<((), i32, f32, i32, ())>();
    simple::<((), i32, f32, i32, (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), (), (), (), (), ())>();
    simple::<((), i32, f32, i32, (), (), (), (), (), (), (), (), (), ())>();
    simple::<(
        (),
        i32,
        f32,
        i32,
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
    )>();
    simple::<(
        (),
        i32,
        f32,
        i32,
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
        (),
    )>();
}

#[test]
fn test_auto_impl_no_args() {
    <() as NoArgs>::foo();
    <() as NoArgs>::bar();

    <(i32,) as NoArgs>::foo();
    <(i32,) as NoArgs>::bar();

    <(i32, char) as NoArgs>::foo();
    <(i32, char) as NoArgs>::bar();
}

#[test]
fn test_auto_impl_only_self() {
    fn test<T: OnlySelf>(mut t: T) {
        t.bar();
        t.baz();
        t.foo();
    }

    test((1,));
    test((1, "hi"));
    test((1, "hi", 42));
}

#[test]
fn test_auto_impl_generalized() {
    let mut mut_num = 0;
    let num = 42;

    ().foo_gen((), &num, &mut mut_num);
    ((),).foo_gen((), &num, &mut mut_num);
    ((), ()).foo_gen((), &num, &mut mut_num);

    <() as Generalized<_, _>>::bar_gen((), &num, &mut_num);
    <((),) as Generalized<_, _>>::bar_gen((), &num, &mut_num);
    <((), ()) as Generalized<_, _>>::bar_gen((), &num, &mut_num);
}

#[test]
fn test_auto_impl_member_type() {
    {
        let mut _1 = (0,);
        let mut _2 = (0, 10);
        let mut _3 = (0, 10, 20);
        let mut _4 = (0, 10, 20, 30);
        let mut _5 = (0, 10, 20, 30, 40);

        _1.inc();
        _2.inc();
        _3.inc();
        _4.inc();
        _5.inc();

        assert_eq!(_1, (1,));
        assert_eq!(_2, (1, 11));
        assert_eq!(_3, (1, 11, 21));
        assert_eq!(_4, (1, 11, 21, 31));
        assert_eq!(_5, (1, 11, 21, 31, 41));
    }

    {
        let mut _1 = (0,);
        let mut _2 = (0, 10);
        let mut _3 = (0, 10, 20);
        let mut _4 = (0, 10, 20, 30);
        let mut _5 = (0, 10, 20, 30, 40);

        _1.dec();
        _2.dec();
        _3.dec();
        _4.dec();
        _5.dec();

        assert_eq!(_1, (-1,));
        assert_eq!(_2, (-1, 9));
        assert_eq!(_3, (-1, 9, 19));
        assert_eq!(_4, (-1, 9, 19, 29));
        assert_eq!(_5, (-1, 9, 19, 29, 39));
    }
}

#[test]
fn test_auto_impl_args() {
    let a = 42;
    let b = 112;

    {
        let mut out = 0;
        ().sum(a, &b, &mut out);

        assert_eq!(out, 0);
    }

    {
        let mut out = 0;
        <() as Args>::diff(&a, b, &mut out);

        assert_eq!(out, 0);
    }

    {
        let mut out = 0;
        let num = 10;

        (num,).sum(a, &b, &mut out);

        assert_eq!(out, a + b + num);
    }

    {
        let mut out = 0;

        <(i32,) as Args>::diff(&a, a, &mut out);

        assert_eq!(out, 0);
    }

    {
        let mut out = 0;
        let num = 10;

        (num, ()).sum(a, &b, &mut out);

        assert_eq!(out, a + b + num);
    }

    {
        let mut out = 0;

        <(i32, ()) as Args>::diff(&a, a, &mut out);

        assert_eq!(out, 0);
    }
}

#[test]
fn test_auto_impl_refs() {
    <(&(),) as SimpleForRefs>::only_on_refs();
    <(&(), &()) as SimpleForRefs>::only_on_refs();
    <(&(), &(), &()) as SimpleForRefs>::only_on_refs();
}

#[test]
fn test_auto_impl_mut_refs() {
    <(&mut (),) as SimpleForMutRefs>::only_on_mut_refs();
    <(&mut (), &mut ()) as SimpleForMutRefs>::only_on_mut_refs();
    <(&mut (), &mut (), &mut ()) as SimpleForMutRefs>::only_on_mut_refs();
}

#[test]
fn test_auto_impl_unsafe() {
    unsafe {
        <() as UnsafeTrait>::not_safe();
        <((),) as UnsafeTrait>::not_safe();
        <((), ()) as UnsafeTrait>::not_safe();
    }
}

#[test]
fn test_auto_impl_wildcard() {
    let a = 42;
    let b = 112;

    {
        let mut num = 0;

        ().wild_foo(a, &b);
        <() as Wildcard>::wild_bar(&a, b, &mut num);

        assert_eq!(num, 0);
    }

    {
        let mut num_t = (1,);
        let mut num = 0;

        num_t.wild_foo(a, &b);
        assert_eq!(num_t.0, 1 + a + b);

        <(i32,) as Wildcard>::wild_bar(&a, b, &mut num);
        assert_eq!(num, a + b);
    }

    {
        let mut num_t = (1, 2);
        let mut num = 0;

        num_t.wild_foo(a, &b);
        assert_eq!(num_t.0, 1 + a + b);
        assert_eq!(num_t.1, 2 + a + b);

        <(i32, ()) as Wildcard>::wild_bar(&a, b, &mut num);
        assert_eq!(num, a + b);
    }
}