use varihappy_macros::{
	reverse_expr_type, reverse_tuple_type, tuple_expr_len_rest, tuple_expr_mut, tuple_expr_ref,
	tuple_type_len, tuple_type_len_rest,
};

pub trait Tuple {
	type AsRef<'a>: Tuple
	where
		Self: 'a;
	type AsMut<'a>: Tuple
	where
		Self: 'a;

	type Reversed: Tuple;

	fn as_ref(&self) -> Self::AsRef<'_>;
	fn as_mut(&mut self) -> Self::AsMut<'_>;
	fn rev(self) -> Self::Reversed;
}

pub trait Tuple1: Tuple {
	type Item0;
	type Rest: Tuple;

	fn into_0(self) -> Self::Item0;
	fn split_into(self) -> (Self::Item0, Self::Rest);
	fn into_rest(self) -> Self::Rest;
}

impl Tuple for () {
	type AsRef<'a>
		= ()
	where
		Self: 'a;
	type AsMut<'a>
		= ()
	where
		Self: 'a;

	type Reversed = ();

	fn as_ref(&self) -> Self::AsRef<'_> {}
	fn as_mut(&mut self) -> Self::AsMut<'_> {}
	fn rev(self) -> Self::Reversed {}
}

impl<A> Tuple for (A,) {
	type AsRef<'a>
		= (&'a A,)
	where
		Self: 'a;
	type AsMut<'a>
		= (&'a mut A,)
	where
		Self: 'a;

	type Reversed = (A,);

	fn as_ref(&self) -> Self::AsRef<'_> {
		(&self.0,)
	}
	fn as_mut(&mut self) -> Self::AsMut<'_> {
		(&mut self.0,)
	}
	fn rev(self) -> Self::Reversed {
		self
	}
}

impl<A> Tuple1 for (A,) {
	type Item0 = A;
	type Rest = ();

	fn into_0(self) -> Self::Item0 {
		self.0
	}

	fn split_into(self) -> (Self::Item0, <Self as Tuple1>::Rest) {
		(self.0, ())
	}

	fn into_rest(self) -> Self::Rest {}
}

macro_rules! impl_tuple {
	($length: expr; $($letter: ident),*) => {
		impl<$($letter),*> Tuple for tuple_type_len!($length) {
			type AsRef<'a> = ($(&'a $letter,)*) where Self: 'a;
			type AsMut<'a> = ($(&'a mut $letter,)*) where Self: 'a;
			type Reversed =  reverse_tuple_type!($length);

			fn as_ref(&self) -> Self::AsRef<'_> {
				tuple_expr_ref!($length)
			}

			fn as_mut(&mut self) -> Self::AsMut<'_> {
				tuple_expr_mut!($length)
			}

			fn rev(self) -> Self::Reversed {
				reverse_expr_type!($length)
			}
		}

		impl<$($letter),*> Tuple1 for tuple_type_len!($length) {
			type Item0 = A;
			type Rest = tuple_type_len_rest!($length);

			fn into_0(self) -> Self::Item0 {
				self.0
			}
			fn split_into(self) -> (Self::Item0, Self::Rest) {
				(self.0, tuple_expr_len_rest!($length))
			}

			fn into_rest(self) -> Self::Rest {
				tuple_expr_len_rest!($length)
			}
		}
	};
}

impl_tuple!(2; A, B);
impl_tuple!(3; A, B, C);
impl_tuple!(4; A, B, C, D);
impl_tuple!(5; A, B, C, D, E);
impl_tuple!(6; A, B, C, D, E, F);
impl_tuple!(7; A, B, C, D, E, F, G);
impl_tuple!(8; A, B, C, D, E, F, G, H);
impl_tuple!(9; A, B, C, D, E, F, G, H, I);
impl_tuple!(10; A, B, C, D, E, F, G, H, I, J);
impl_tuple!(11; A, B, C, D, E, F, G, H, I, J, K);
impl_tuple!(12; A, B, C, D, E, F, G, H, I, J, K, L);
impl_tuple!(13; A, B, C, D, E, F, G, H, I, J, K, L, M);
impl_tuple!(14; A, B, C, D, E, F, G, H, I, J, K, L, M, N);
impl_tuple!(15; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
impl_tuple!(16; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
impl_tuple!(17; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q);
impl_tuple!(18; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R);
impl_tuple!(19; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
impl_tuple!(20; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T);
impl_tuple!(21; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U);
impl_tuple!(22; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V);
impl_tuple!(23; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W);
impl_tuple!(24; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X);
impl_tuple!(25; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y);
impl_tuple!(26; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z);

macro_rules! tuple_trait {
	(trait $trait_name: ident for $trait_minus1: ident {
		type $item_name: ident;
		fn $item_getter: ident;
	}) => {
		pub trait $trait_name: $trait_minus1 {
			type $item_name;
			type Rest: Tuple;

			fn $item_getter(self) -> Self::$item_name;
			fn into_rest(self) -> <Self as $trait_name>::Rest;
		}

		impl<R: Tuple1, T: $trait_minus1<Rest = R>> $trait_name for T {
			type $item_name = R::Item0;
			type Rest = R::Rest;

			fn $item_getter(self) -> Self::$item_name {
				$trait_minus1::into_rest(self).into_0()
			}

			fn into_rest(self) -> <Self as $trait_name>::Rest {
				$trait_minus1::into_rest(self).into_rest()
			}
		}
	};
}

tuple_trait!(trait Tuple2 for Tuple1 { type Item1; fn into_1; });
tuple_trait!(trait Tuple3 for Tuple2 { type Item2; fn into_2; });
tuple_trait!(trait Tuple4 for Tuple3 { type Item3; fn into_3; });
tuple_trait!(trait Tuple5 for Tuple4 { type Item4; fn into_4; });
tuple_trait!(trait Tuple6 for Tuple5 { type Item5; fn into_5; });
tuple_trait!(trait Tuple7 for Tuple6 { type Item6; fn into_6; });
tuple_trait!(trait Tuple8 for Tuple7 { type Item7; fn into_7; });
tuple_trait!(trait Tuple9 for Tuple8 { type Item8; fn into_8; });
tuple_trait!(trait Tuple10 for Tuple9 { type Item9; fn into_9; });
tuple_trait!(trait Tuple11 for Tuple10 { type Item10; fn into_10; });
tuple_trait!(trait Tuple12 for Tuple11 { type Item11; fn into_11; });
tuple_trait!(trait Tuple13 for Tuple12 { type Item12; fn into_12; });
tuple_trait!(trait Tuple14 for Tuple13 { type Item13; fn into_13; });
tuple_trait!(trait Tuple15 for Tuple14 { type Item14; fn into_14; });
tuple_trait!(trait Tuple16 for Tuple15 { type Item15; fn into_15; });
tuple_trait!(trait Tuple17 for Tuple16 { type Item16; fn into_16; });
tuple_trait!(trait Tuple18 for Tuple17 { type Item17; fn into_17; });
tuple_trait!(trait Tuple19 for Tuple18 { type Item18; fn into_18; });
tuple_trait!(trait Tuple20 for Tuple19 { type Item19; fn into_19; });
tuple_trait!(trait Tuple21 for Tuple20 { type Item20; fn into_20; });
tuple_trait!(trait Tuple22 for Tuple21 { type Item21; fn into_21; });
tuple_trait!(trait Tuple23 for Tuple22 { type Item22; fn into_22; });
tuple_trait!(trait Tuple24 for Tuple23 { type Item23; fn into_23; });
tuple_trait!(trait Tuple25 for Tuple24 { type Item24; fn into_24; });
tuple_trait!(trait Tuple26 for Tuple25 { type Item25; fn into_25; });