#![allow(deprecated)]
#![doc = include_str!("../doc/macros.md")]

#[macro_use]
#[doc(hidden)]
pub mod internal;

mod tests;

#[macro_export]
#[doc = include_str!("../doc/macros/BitArr_type.md")]
macro_rules! BitArr {
	(for $len:expr, in $store:ty, $order:ty $(,)?) => {
		$crate::array::BitArray::<
			[$store; $crate::mem::elts::<$store>($len)], $order
		>
	};

	(for $len:expr, in $store:ty $(,)?) => {
		$crate::BitArr!(for $len, in $store, $crate::order::Lsb0)
	};

	(for $len:expr) => {
		$crate::BitArr!(for $len, in usize)
	};
}

#[macro_export]
#[doc = include_str!("../doc/macros/bitarr_value.md")]
macro_rules! bitarr {
	/* `const`-expression constructors.
	 *
	 * These arms expand to expressions which are guaranteed to be valid in
	 * `const` position: initializing `static` or `const`, or arguments to
	 * `const fn`.
	 *
	 * > Other arms *may* be valid in `const`s, but do not guarantee it.
	 *
	 * They are more restricted than the general variants below, because the
	 * trait system is not yet usable in `const` contexts and thus these
	 * expansions can only use codepaths defined in this module, and cannot use
	 * the rest of `bitvec`’s systems.
	 *
	 * All valid invocations with a leading `const` will remain valid if the
	 * `const` is removed, though their expansion may change to no longer be
	 * valid in `const` contexts.
	 */

	//  Bit-sequencing requires detecting `Cell` separately from other types.
	//  See below.

	(const Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type Data = [Cell<$store>; ELTS];
		const DATA: Data = $crate::__encode_bits!(Cell<$store>, $order; $($val),*);

		type This = $crate::array::BitArray<Data, $order>;
		This { data: DATA, ..This::ZERO }
	}};
	(const $store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type Data = [$store; ELTS];
		const DATA: Data = $crate::__encode_bits!($store, $order; $($val),*);

		type This = $crate::array::BitArray<Data, $order>;
		This { data: DATA, ..This::ZERO }
	}};

	//  Bit-repetition is agnostic to types, so it only needs two arms.

	(const $store:ty, $order:ty; $val:expr; $len:expr) => {{
		use $crate::macros::internal::core;
		type Mem = <$store as $crate::store::BitStore>::Mem;

		const ELTS: usize = $crate::mem::elts::<$store>($len);
		const ELEM: Mem = $crate::__extend_bool!($val, $store);
		const DATA: [Mem; ELTS] = [ELEM; ELTS];

		type This = $crate::array::BitArray<[$store; ELTS], $order>;
		unsafe { core::mem::transmute::<_, This>(DATA) }
	}};
	(const $val:expr; $len:expr) => {{
		$crate::bitarr!(const usize, $crate::order::Lsb0; $val; $len)
	}};

	(const $($val:expr),* $(,)?) => {{
		$crate::bitarr!(const usize, Lsb0; $($val),*)
	}};

	/* Non-`const` constructors.
	 *
	 * These expansions are allowed to produce code that does not run in `const`
	 * contexts. While it is *likely* that the expansions will be evaluated at
	 * compile-time, they won’t do so while the `const` engine is active.
	 */

	/* Bit-sequence encoding.
	 *
	 * This requires four arms to the `const` section’s one, because of how both
	 * the ordering and storage arguments may be provided. As macros operate
	 * syntactically, before the type system begins, they have to accept any
	 * syntax that could later be accepted as the name of a satisfying type.
	 *
	 * The `$order:ident` matcher uses the fact that `:ident` matches remain
	 * matchable across deeper macro invocations, so that the bottom of the
	 * macro stack can detect the magic tokens `LocalBits`, `Lsb0`, and `Msb0`,
	 * and operate accordingly. The `$order:path` matcher is always opaque, and
	 * serves as a fallback for complex type-names.
	 *
	 * `Cell<$store>` uses literal detection to extract the interior type width.
	 * This cannot be done by `:ty` or `:path`, as these are opaque, and
	 * `:ident` does not match `Cell<_>`.
	 */

	(Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;

		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type Data = [Celled; ELTS];
		type This = $crate::array::BitArray<Data, $order>;

		This::new($crate::__encode_bits!(Cell<$store>, $order; $($val),*))
	}};
	(Cell<$store:ident>, $order:path; $($val:expr),* $(,)?) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;

		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type This = $crate::array::BitArray<[Celled; ELTS], $order>;

		This::new($crate::__encode_bits!(Cell<$store>, $order; $($val),*))
	}};

	($store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type This = $crate::array::BitArray<[$store; ELTS], $order>;

		This::new($crate::__encode_bits!($store, $order; $($val),*))
	}};
	($store:ident, $order:path; $($val:expr),* $(,)?) => {{
		const ELTS: usize = $crate::__count_elts!($store; $($val),*);
		type This = $crate::array::BitArray<[$store; ELTS], $order>;

		This::new($crate::__encode_bits!($store, $order; $($val),*))
	}};


	($store:ty, $order:ty; $val:expr; $len:expr) => {{
		$crate::bitarr!(const $store, $order; $val; $len)
	}};
	($val:expr; $len:expr) => {{
		$crate::bitarr!(const $val; $len)
	}};
	($($val:expr),* $(,)?) => {
		$crate::bitarr!(usize, Lsb0; $($val),*)
	};
}

#[macro_export]
#[doc = include_str!("../doc/macros/bits.md")]
macro_rules! bits {
	/* `&'static` constructors.
	 *
	 * Like the `bitarr!(const …)` arms, these arms must expand to code that is
	 * valid in `const` contexts. As such, they can only accept `$order`
	 * arguments that are one of the `LocalBits`, `Lsb0`, or `Msb0` literals.
	 * Once the underlying `static BitArray` is created,
	 */
	(static mut Cell<$store:ident>, $order:ty; $val:expr; $len:expr) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;
		static mut DATA: $crate::BitArr!(for $len, in Celled, $order) =
			$crate::bitarr!(const Cell<$store>, $order; $val; $len);
		 &mut DATA[.. $len]
	}};
	(static mut $store:ident, $order:ident; $val:expr; $len:expr) => {{
		static mut DATA: $crate::BitArr!(for $len, in $store, $order) =
			$crate::bitarr!(const $store, $order; $val; $len);
		DATA.get_unchecked_mut(.. $len)
	}};

	(static mut Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;
		const BITS: usize = $crate::__count!($($val),*);

		static mut DATA: $crate::BitArr!(for BITS, in $store, $order) =
			$crate::bitarr!(const $store, $order; $($val),*);
		&mut *(
			DATA.get_unchecked_mut(.. BITS)
				as *mut $crate::slice::BitSlice<$store, $order>
				as *mut $crate::slice::BitSlice<Celled, $order>
		)
	}};
	(static mut $store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		static mut DATA: $crate::BitArr!(for BITS, in $store, $order) =
			$crate::bitarr!(const $store, $order; $($val),*);
		DATA.get_unchecked_mut(.. BITS)
	}};

	(static mut $val:expr; $len:expr) => {{
		static mut DATA: $crate::BitArr!(for $len) =
			$crate::bitarr!(const usize, $crate::order::Lsb0; $val; $len);
		DATA.get_unchecked_mut(.. $len)
	}};
	(static mut $($val:expr),* $(,)?) => {{
		$crate::bits!(static mut usize, Lsb0; $($val),*)
	}};

	(static Cell<$store:ident>, $order:ty; $val:expr; $len:expr) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;
		static DATA: $crate::BitArr!(for $len, in $store, $order) =
			$crate::bitarr!(const $store, $order; $val; $len);
		unsafe {
			&*(
				DATA.get_unchecked(.. $len)
					as *const $crate::slice::BitSlice<$store, $order>
					as *const $crate::slice::BitSlice<Celled, $order>
			)
		}
	}};
	(static Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		use $crate::macros::internal::core;
		type Celled = core::cell::Cell<$store>;
		const BITS: usize = $crate::__count!($($val),*);

		static DATA: $crate::BitArr!(for BITS, in $store, $order) =
			$crate::bitarr!(const $store, $order; $($val),*);
		unsafe {
			&*(
				DATA.get_unchecked(.. BITS)
					as *const $crate::slice::BitSlice<$store, $order>
					as *const $crate::slice::BitSlice<Celled, $order>
			)
		}
	}};

	(static $store:ident, $order:ident; $val:expr; $len:expr) => {{
		static DATA: $crate::BitArr!(for $len, in $store, $order) =
			$crate::bitarr!(const $store, $order; $val; $len);
		unsafe { DATA.get_unchecked(.. $len) }
	}};
	(static $val:expr; $len:expr) => {{
		static DATA: $crate::BitArr!(for $len) =
			$crate::bitarr!(const usize, $crate::order::Lsb0; $val; $len);
		unsafe { DATA.get_unchecked(.. $len) }
	}};

	(static $store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		static DATA: $crate::BitArr!(for BITS, in $store, $order) =
			$crate::bitarr!(const $store, $order; $($val),*);
		unsafe { DATA.get_unchecked(.. BITS) }
	}};
	(static $($val:expr),* $(,)?) => {{
		$crate::bits!(static usize, Lsb0; $($val),*)
	}};

	//  Repetition syntax `[bit ; count]`.
	//  NOTE: `count` must be a `const`, as this is a non-allocating macro.

	//  Sequence syntax `[bit (, bit)*]` or `[(bit ,)*]`.

	//  Explicit order and store.

	(mut Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&mut $crate::bitarr!(Cell<$store>, $order; $($val),*)[.. BITS]
	}};
	(mut Cell<$store:ident>, $order:path; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&mut $crate::bitarr!(Cell<$store>, $order; $($val),*)[.. BITS]
	}};

	(mut $store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&mut $crate::bitarr!($store, $order; $($val),*)[.. BITS]
	}};
	(mut $store:ident, $order:path; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&mut $crate::bitarr!($store, $order; $($val),*)[.. BITS]
	}};

	//  Explicit order and store.
	(mut $store:ty, $order:ty; $val:expr; $len:expr) => {{
		&mut $crate::bitarr!($store, $order; $val; $len)[.. $len]
	}};
	//  Default order and store.
	(mut $val:expr; $len:expr) => {
		$crate::bits!(mut usize, $crate::order::Lsb0; $val; $len)
	};

	//  Default order and store.
	(mut $($val:expr),* $(,)?) => {
		$crate::bits!(mut usize, Lsb0; $($val),*)
	};

	//  Repeat everything from above, but now immutable.

	($store:ty, $order:ty; $val:expr; $len:expr) => {{
		&$crate::bitarr!($store, $order; $val; $len)[.. $len]
	}};

	(Cell<$store:ident>, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&$crate::bitarr!(Cell<$store>, $order; $($val),*)[.. BITS]
	}};
	($store:ident, $order:ident; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&$crate::bitarr!($store, $order; $($val),*)[.. BITS]
	}};

	(Cell<$store:ident>, $order:path; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&$crate::bitarr!(Cell<$store>, $order; $($val),*)[.. BITS]
	}};
	($store:ident, $order:path; $($val:expr),* $(,)?) => {{
		const BITS: usize = $crate::__count!($($val),*);
		&$crate::bitarr!($store, $order; $($val),*)[.. BITS]
	}};

	//  Default order and store.
	($val:expr; $len:expr) => {
		$crate::bits!(usize, $crate::order::Lsb0; $val; $len)
	};
	($($val:expr),* $(,)?) => {
		$crate::bits!(usize, Lsb0; $($val),*)
	};
}

#[macro_export]
#[cfg(feature = "alloc")]
#[doc = include_str!("../doc/macros/bitvec.md")]
macro_rules! bitvec {
	//  First, capture the repetition syntax, as it is permitted to use runtime
	//  values for the repetition count.
	($store:ty, $order:ty; $val:expr; $len:expr) => {
		$crate::vec::BitVec::<$store, $order>::repeat($val != 0, $len)
	};
	// Capture `Cell<T>` patterns and prevent them from being parsed as
	// comparisons. Guess we didn't escape Most Vexing Parse after all.
	(Cell<$store:ident>, $order:ident $($rest:tt)*) => {
		$crate::vec::BitVec::from_bitslice($crate::bits!(Cell<$store>, $order $($rest)*))
	};
	($val:expr; $len:expr) => {
		$crate::bitvec!(usize, $crate::order::Lsb0; $val; $len)
	};

	//  Delegate all others to the `bits!` macro.
	($($arg:tt)*) => {
		$crate::vec::BitVec::from_bitslice($crate::bits!($($arg)*))
	};
}

#[macro_export]
#[cfg(feature = "alloc")]
#[doc = include_str!("../doc/macros/bitbox.md")]
macro_rules! bitbox {
	($($arg:tt)*) => {
		$crate::bitvec!($($arg)*).into_boxed_bitslice()
	};
}