// This file is part of Bizinikiwi.

// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// 	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use std::collections::BTreeMap;

use pezframe_support::{
	assert_ok, derive_impl,
	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Parameter, Pays},
	dispatch_context::with_context,
	pezpallet_prelude::{StorageInfoTrait, ValueQuery},
	parameter_types,
	storage::{unhashed, unhashed::contains_prefixed_key},
	traits::{
		ConstU32, GetCallIndex, GetCallName, GetStorageVersion, OnFinalize, OnGenesis,
		OnInitialize, OnRuntimeUpgrade, PalletError, PalletInfoAccess, SignedTransactionBuilder,
		StorageVersion, UnfilteredDispatchable,
	},
	weights::{RuntimeDbWeight, Weight},
	OrdNoBound, PartialOrdNoBound,
};
use pezframe_system::offchain::{CreateSignedTransaction, CreateTransactionBase, SigningTypes};
use scale_info::{meta_type, TypeInfo};
use pezsp_io::{
	hashing::{blake2_128, twox_128, twox_64},
	TestExternalities,
};
use pezsp_runtime::{
	testing::UintAuthorityId,
	traits::{Block as BlockT, Dispatchable},
	DispatchError, ModuleError,
};

parameter_types! {
	/// Used to control if the storage version should be updated.
	storage UpdateStorageVersion: bool = false;
}

pub struct SomeType1;
impl From<SomeType1> for u64 {
	fn from(_t: SomeType1) -> Self {
		0u64
	}
}

pub struct SomeType2;
impl From<SomeType2> for u64 {
	fn from(_t: SomeType2) -> Self {
		100u64
	}
}

pub struct SomeType3;
impl From<SomeType3> for u64 {
	fn from(_t: SomeType3) -> Self {
		0u64
	}
}

pub struct SomeType4;
impl From<SomeType4> for u64 {
	fn from(_t: SomeType4) -> Self {
		0u64
	}
}

pub struct SomeType5;
impl From<SomeType5> for u64 {
	fn from(_t: SomeType5) -> Self {
		0u64
	}
}

pub struct SomeType6;
impl From<SomeType6> for u64 {
	fn from(_t: SomeType6) -> Self {
		0u64
	}
}

pub struct SomeType7;
impl From<SomeType7> for u64 {
	fn from(_t: SomeType7) -> Self {
		0u64
	}
}

pub trait SomeAssociation1 {
	type _1: Parameter + codec::MaxEncodedLen + TypeInfo;
}
impl SomeAssociation1 for u64 {
	type _1 = u64;
}

pub trait SomeAssociation2 {
	type _2: Parameter + codec::MaxEncodedLen + TypeInfo;
}
impl SomeAssociation2 for u64 {
	type _2 = u64;
}

#[pezframe_support::pezpallet]
/// Pezpallet documentation
// Comments should not be included in the pezpallet documentation
#[pezpallet_doc("../example-pezpallet-doc.md")]
#[doc = include_str!("../example-readme.md")]
pub mod pezpallet {
	use super::*;
	use pezframe_support::pezpallet_prelude::*;
	use pezframe_system::pezpallet_prelude::*;
	use pezsp_runtime::DispatchResult;

	type BalanceOf<T> = <T as Config>::Balance;

	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(10);

	#[pezpallet::config]
	pub trait Config: pezframe_system::Config
	where
		<Self as pezframe_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
	{
		/// Some comment
		/// Some comment
		#[deprecated = "test 2"]
		#[pezpallet::constant]
		type MyGetParam: Get<u32>;

		/// Some comment
		/// Some comment
		#[pezpallet::constant]
		type MyGetParam2: Get<u32>;

		#[pezpallet::constant]
		type MyGetParam3: Get<<Self::AccountId as SomeAssociation1>::_1>;

		type Balance: Parameter + Default + TypeInfo;

		#[allow(deprecated)]
		type RuntimeEvent: From<Event<Self>> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
	}

	#[pezpallet::extra_constants]
	impl<T: Config> Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType2>,
	{
		/// Some doc
		/// Some doc
		fn some_extra() -> T::AccountId {
			SomeType2.into()
		}

		/// Some doc
		fn some_extra_extra() -> T::AccountId {
			SomeType1.into()
		}

		/// Some doc
		#[pezpallet::constant_name(SomeExtraRename)]
		fn some_extra_rename() -> T::AccountId {
			SomeType1.into()
		}
	}

	#[pezpallet::pezpallet]
	#[pezpallet::storage_version(STORAGE_VERSION)]
	pub struct Pezpallet<T>(_);

	#[pezpallet::hooks]
	impl<T: Config> Hooks<BlockNumberFor<T>> for Pezpallet<T>
	where
		T::AccountId: From<SomeType2> + From<SomeType1> + SomeAssociation1,
	{
		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType2); // Test for where clause
			Self::deposit_event(Event::Something(10));
			Weight::from_parts(10, 0)
		}
		fn on_finalize(_: BlockNumberFor<T>) {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType2); // Test for where clause
			Self::deposit_event(Event::Something(20));
		}
		fn on_runtime_upgrade() -> Weight {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType2); // Test for where clause
			Self::deposit_event(Event::Something(30));
			Weight::from_parts(30, 0)
		}
		fn integrity_test() {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType2); // Test for where clause
		}
	}

	#[pezpallet::call]
	impl<T: Config> Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + From<SomeType3> + SomeAssociation1,
	{
		/// call foo doc comment put in metadata
		#[pezpallet::call_index(0)]
		#[pezpallet::weight(Weight::from_parts(*foo as u64, 0))]
		#[deprecated = "test"]
		pub fn foo(
			origin: OriginFor<T>,
			#[pezpallet::compact] foo: u32,
			_bar: u32,
		) -> DispatchResultWithPostInfo {
			let _ = foo;
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType3); // Test for where clause
			let _ = origin;
			Self::deposit_event(Event::Something(3));
			Ok(().into())
		}

		/// call foo_storage_layer doc comment put in metadata
		#[pezpallet::call_index(1)]
		#[pezpallet::weight({1})]
		pub fn foo_storage_layer(
			_origin: OriginFor<T>,
			#[pezpallet::compact] foo: u32,
		) -> DispatchResultWithPostInfo {
			Self::deposit_event(Event::Something(0));
			if foo == 0 {
				Err(Error::<T>::InsufficientProposersBalance)?;
			}

			Ok(().into())
		}

		#[pezpallet::call_index(4)]
		#[pezpallet::weight({1})]
		pub fn foo_index_out_of_order(_origin: OriginFor<T>) -> DispatchResult {
			Ok(())
		}

		// Test for DispatchResult return type
		#[pezpallet::call_index(2)]
		#[pezpallet::weight({1})]
		pub fn foo_no_post_info(_origin: OriginFor<T>) -> DispatchResult {
			Ok(())
		}

		#[pezpallet::call_index(3)]
		#[pezpallet::weight({1})]
		pub fn check_for_dispatch_context(_origin: OriginFor<T>) -> DispatchResult {
			with_context::<(), _>(|_| ()).ok_or_else(|| DispatchError::Unavailable)
		}

		#[cfg(feature = "frame-feature-testing")]
		#[pezpallet::call_index(5)]
		#[pezpallet::weight({1})]
		pub fn foo_feature_test(_origin: OriginFor<T>) -> DispatchResult {
			Ok(())
		}
	}

	#[pezpallet::error]
	#[derive(PartialEq, Eq)]
	pub enum Error<T> {
		/// error doc comment put in metadata
		InsufficientProposersBalance,
		#[deprecated = "test"]
		NonExistentStorageValue,
		Code(u8),
		#[codec(skip)]
		Skipped(u128),
		CompactU8(#[codec(compact)] u8),
		#[cfg(feature = "frame-feature-testing")]
		FeatureTest,
	}

	#[pezpallet::event]
	#[pezpallet::generate_deposit(fn deposit_event)]

	pub enum Event<T: Config>
	where
		T::AccountId: SomeAssociation1 + From<SomeType1>,
	{
		/// event doc comment put in metadata
		Proposed(<T as pezframe_system::Config>::AccountId),
		#[deprecated = "test"]
		Spending(BalanceOf<T>),
		Something(u32),
		SomethingElse(<T::AccountId as SomeAssociation1>::_1),
	}

	#[pezpallet::storage]
	pub type ValueWhereClause<T: Config>
	where
		T::AccountId: SomeAssociation2,
	= StorageValue<_, <T::AccountId as SomeAssociation2>::_2>;

	#[pezpallet::storage]
	pub type Value<T> = StorageValue<Value = u32>;

	#[pezpallet::storage]
	#[pezpallet::storage_prefix = "Value2"]
	pub type RenamedValue<T> = StorageValue<Value = u64>;

	/// Test some doc
	#[pezpallet::type_value]
	pub fn MyDefault<T: Config>() -> u16
	where
		T::AccountId: From<SomeType7> + From<SomeType1> + SomeAssociation1,
	{
		let _ = T::AccountId::from(SomeType7); // Test where clause works
		4u16
	}

	#[pezpallet::storage]
	pub type Map<T: Config>
	where
		T::AccountId: From<SomeType7>,
	= StorageMap<_, Blake2_128Concat, u8, u16, ValueQuery, MyDefault<T>>;

	#[pezpallet::storage]
	pub type Map2<T> =
		StorageMap<Hasher = Twox64Concat, Key = u16, Value = u32, MaxValues = ConstU32<3>>;

	#[pezpallet::storage]
	#[allow(deprecated)]
	pub type Map3<T> =
		StorageMap<_, Blake2_128Concat, u32, u64, ResultQuery<Error<T>::NonExistentStorageValue>>;

	#[pezpallet::storage]
	pub type DoubleMap<T> = StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;

	#[pezpallet::storage]
	pub type DoubleMap2<T> = StorageDoubleMap<
		Hasher1 = Twox64Concat,
		Key1 = u16,
		Hasher2 = Blake2_128Concat,
		Key2 = u32,
		Value = u64,
		MaxValues = ConstU32<5>,
	>;

	#[pezpallet::storage]
	#[allow(deprecated)]
	pub type DoubleMap3<T> = StorageDoubleMap<
		_,
		Blake2_128Concat,
		u32,
		Twox64Concat,
		u64,
		u128,
		ResultQuery<Error<T>::NonExistentStorageValue>,
	>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn nmap)]
	pub type NMap<T> = StorageNMap<_, storage::Key<Blake2_128Concat, u8>, u32>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn nmap2)]
	pub type NMap2<T> = StorageNMap<
		Key = (NMapKey<Twox64Concat, u16>, NMapKey<Blake2_128Concat, u32>),
		Value = u64,
		MaxValues = ConstU32<11>,
	>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn nmap3)]
	#[allow(deprecated)]
	pub type NMap3<T> = StorageNMap<
		_,
		(NMapKey<Blake2_128Concat, u8>, NMapKey<Twox64Concat, u16>),
		u128,
		ResultQuery<Error<T>::NonExistentStorageValue>,
	>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn counted_nmap)]
	pub type CountedNMap<T> = CountedStorageNMap<_, storage::Key<Blake2_128Concat, u8>, u32>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn counted_nmap2)]
	pub type CountedNMap2<T> = CountedStorageNMap<
		Key = (NMapKey<Twox64Concat, u16>, NMapKey<Blake2_128Concat, u32>),
		Value = u64,
		MaxValues = ConstU32<11>,
	>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn counted_nmap3)]
	#[allow(deprecated)]
	pub type CountedNMap3<T> = CountedStorageNMap<
		_,
		(NMapKey<Blake2_128Concat, u8>, NMapKey<Twox64Concat, u16>),
		u128,
		ResultQuery<Error<T>::NonExistentStorageValue>,
	>;

	#[pezpallet::storage]
	#[pezpallet::getter(fn conditional_value)]
	#[cfg(feature = "frame-feature-testing")]
	pub type ConditionalValue<T> = StorageValue<_, u32>;

	#[cfg(feature = "frame-feature-testing")]
	#[pezpallet::storage]
	#[pezpallet::getter(fn conditional_map)]
	pub type ConditionalMap<T> =
		StorageMap<_, Twox64Concat, u16, u32, OptionQuery, GetDefault, ConstU32<12>>;

	#[cfg(feature = "frame-feature-testing")]
	#[pezpallet::storage]
	#[pezpallet::getter(fn conditional_double_map)]
	pub type ConditionalDoubleMap<T> =
		StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;

	#[cfg(feature = "frame-feature-testing")]
	#[pezpallet::storage]
	#[pezpallet::getter(fn conditional_nmap)]
	pub type ConditionalNMap<T> =
		StorageNMap<_, (storage::Key<Blake2_128Concat, u8>, storage::Key<Twox64Concat, u16>), u32>;

	#[cfg(feature = "frame-feature-testing")]
	#[pezpallet::storage]
	#[pezpallet::getter(fn conditional_counted_nmap)]
	pub type ConditionalCountedNMap<T> = CountedStorageNMap<
		_,
		(storage::Key<Blake2_128Concat, u8>, storage::Key<Twox64Concat, u16>),
		u32,
	>;

	#[pezpallet::storage]
	#[pezpallet::storage_prefix = "RenamedCountedMap"]
	#[pezpallet::getter(fn counted_storage_map)]
	pub type SomeCountedStorageMap<T> =
		CountedStorageMap<Hasher = Twox64Concat, Key = u8, Value = u32>;

	#[pezpallet::storage]
	#[pezpallet::unbounded]
	pub type Unbounded<T> = StorageValue<Value = Vec<u8>>;

	#[pezpallet::genesis_config]
	#[derive(pezframe_support::DefaultNoBound)]
	pub struct GenesisConfig<T: Config>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType4>,
	{
		#[serde(skip)]
		_config: core::marker::PhantomData<T>,
		_myfield: u32,
	}

	#[pezpallet::view_functions]
	impl<T: Config> Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1,
	{
		/// Query value no args.
		pub fn get_value() -> Option<u32> {
			Value::<T>::get()
		}

		/// Query value with args.
		pub fn get_value_with_arg(key: u16) -> Option<u32> {
			Map2::<T>::get(key)
		}
	}

	#[pezpallet::genesis_build]
	impl<T: Config> BuildGenesisConfig for GenesisConfig<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType4>,
	{
		fn build(&self) {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType4); // Test for where clause
		}
	}

	#[pezpallet::origin]
	#[derive(
		EqNoBound,
		RuntimeDebugNoBound,
		CloneNoBound,
		PartialEqNoBound,
		PartialOrdNoBound,
		OrdNoBound,
		Encode,
		Decode,
		DecodeWithMemTracking,
		TypeInfo,
		MaxEncodedLen,
	)]
	pub struct Origin<T>(PhantomData<T>);

	#[pezpallet::validate_unsigned]
	impl<T: Config> ValidateUnsigned for Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType5> + From<SomeType3>,
	{
		type Call = Call<T>;
		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType5); // Test for where clause
			if matches!(call, Call::foo_storage_layer { .. }) {
				return Ok(ValidTransaction::default());
			}
			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
		}
	}

	#[pezpallet::inherent]
	impl<T: Config> ProvideInherent for Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType6> + From<SomeType3>,
	{
		type Call = Call<T>;
		type Error = InherentError;

		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;

		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
			let _ = T::AccountId::from(SomeType1); // Test for where clause
			let _ = T::AccountId::from(SomeType6); // Test for where clause
			Some(Call::foo_no_post_info {})
		}

		fn is_inherent(call: &Self::Call) -> bool {
			matches!(call, Call::foo_no_post_info {} | Call::foo { .. })
		}

		fn check_inherent(call: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
			match call {
				Call::foo_no_post_info {} => Ok(()),
				Call::foo { foo: 0, bar: 0 } => Err(InherentError::Fatal),
				Call::foo { .. } => Ok(()),
				_ => unreachable!("other calls are not inherents"),
			}
		}

		fn is_inherent_required(d: &InherentData) -> Result<Option<Self::Error>, Self::Error> {
			match d.get_data::<bool>(b"required") {
				Ok(Some(true)) => Ok(Some(InherentError::Fatal)),
				Ok(Some(false)) | Ok(None) => Ok(None),
				Err(_) => unreachable!("should not happen in tests"),
			}
		}
	}

	#[pezpallet::composite_enum]
	pub enum HoldReason {
		Staking,
	}

	#[derive(codec::Encode, pezsp_runtime::RuntimeDebug)]
	#[cfg_attr(feature = "std", derive(codec::Decode))]
	pub enum InherentError {
		Fatal,
	}

	impl pezframe_support::inherent::IsFatalError for InherentError {
		fn is_fatal_error(&self) -> bool {
			matches!(self, InherentError::Fatal)
		}
	}

	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"testpall";
}

// Test that a pezpallet with non generic event and generic genesis_config is correctly handled
// and that a pezpallet with the attribute without_storage_info is correctly handled.
#[pezframe_support::pezpallet]
pub mod pallet2 {
	use super::{SomeAssociation1, SomeType1, UpdateStorageVersion};
	use pezframe_support::pezpallet_prelude::*;
	use pezframe_system::pezpallet_prelude::*;

	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);

	#[pezpallet::config]
	pub trait Config: pezframe_system::Config
	where
		<Self as pezframe_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
	{
		#[allow(deprecated)]
		type RuntimeEvent: From<Event> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
	}

	#[pezpallet::pezpallet]
	#[pezpallet::storage_version(STORAGE_VERSION)]
	#[pezpallet::without_storage_info]
	pub struct Pezpallet<T>(_);

	#[pezpallet::hooks]
	impl<T: Config> Hooks<BlockNumberFor<T>> for Pezpallet<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1,
	{
		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
			Self::deposit_event(Event::Something(11));
			Weight::zero()
		}
		fn on_finalize(_: BlockNumberFor<T>) {
			Self::deposit_event(Event::Something(21));
		}
		fn on_runtime_upgrade() -> Weight {
			Self::deposit_event(Event::Something(31));

			if UpdateStorageVersion::get() {
				Self::in_code_storage_version().put::<Self>();
			}

			Weight::zero()
		}
	}

	#[pezpallet::call]
	impl<T: Config> Pezpallet<T> where T::AccountId: From<SomeType1> + SomeAssociation1 {}

	#[pezpallet::storage]
	pub type SomeValue<T: Config> = StorageValue<_, Vec<u32>>;

	#[pezpallet::storage]
	pub type SomeCountedStorageMap<T> =
		CountedStorageMap<Hasher = Twox64Concat, Key = u8, Value = u32>;

	#[pezpallet::event]
	#[pezpallet::generate_deposit(fn deposit_event)]
	pub enum Event {
		/// Something
		Something(u32),
	}

	#[pezpallet::genesis_config]
	pub struct GenesisConfig<T: Config>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1,
	{
		phantom: PhantomData<T>,
	}

	impl<T: Config> Default for GenesisConfig<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1,
	{
		fn default() -> Self {
			GenesisConfig { phantom: Default::default() }
		}
	}

	#[pezpallet::genesis_build]
	impl<T: Config> BuildGenesisConfig for GenesisConfig<T>
	where
		T::AccountId: From<SomeType1> + SomeAssociation1,
	{
		fn build(&self) {}
	}

	#[pezpallet::composite_enum]
	pub enum HoldReason {
		Governance,
	}

	#[pezpallet::composite_enum]
	pub enum SlashReason {
		Equivocation,
	}
}

/// Test that the supertrait check works when we pass some parameter to the `pezframe_system::Config`.
#[pezframe_support::pezpallet]
pub mod pallet3 {
	#[pezpallet::config]
	pub trait Config:
		pezframe_system::Config<RuntimeOrigin = <Self as Config>::RuntimeOrigin>
	{
		type RuntimeOrigin;
	}

	#[pezpallet::pezpallet]
	pub struct Pezpallet<T>(_);
}

#[pezframe_support::pezpallet]
pub mod pallet4 {
	#[pezpallet::config]
	pub trait Config: pezframe_system::Config {}

	#[pezpallet::pezpallet]
	pub struct Pezpallet<T>(_);

	#[pezpallet::call]
	impl<T: Config> Pezpallet<T> {}
}

/// Test that the supertrait check works when we pass some parameter to the `pezframe_system::Config`.
#[pezframe_support::pezpallet]
pub mod pallet5 {
	#[pezpallet::config]
	pub trait Config:
		pezframe_system::Config<RuntimeOrigin = <Self as Config>::RuntimeOrigin>
	{
		type RuntimeOrigin;
	}

	#[pezpallet::pezpallet]
	pub struct Pezpallet<T>(_);
}

pezframe_support::parameter_types!(
	pub const MyGetParam3: u32 = 12;
);

#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
impl pezframe_system::Config for Runtime {
	type BaseCallFilter = pezframe_support::traits::Everything;
	type RuntimeOrigin = RuntimeOrigin;
	type Nonce = u64;
	type RuntimeCall = RuntimeCall;
	type Hash = pezsp_runtime::testing::H256;
	type Hashing = pezsp_runtime::traits::BlakeTwo256;
	type AccountId = u64;
	type Lookup = pezsp_runtime::traits::IdentityLookup<Self::AccountId>;
	type Block = Block;
	type RuntimeEvent = RuntimeEvent;
	type BlockWeights = ();
	type BlockLength = ();
	type DbWeight = ();
	type Version = ();
	type PalletInfo = PalletInfo;
	type AccountData = ();
	type OnNewAccount = ();
	type OnKilledAccount = ();
	type SystemWeightInfo = ();
	type SS58Prefix = ();
	type OnSetCode = ();
	type MaxConsumers = ConstU32<16>;
}
impl pezpallet::Config for Runtime {
	type RuntimeEvent = RuntimeEvent;
	type MyGetParam = ConstU32<10>;
	type MyGetParam2 = ConstU32<11>;
	type MyGetParam3 = MyGetParam3;
	type Balance = u64;
}

impl pallet2::Config for Runtime {
	type RuntimeEvent = RuntimeEvent;
}

impl pallet4::Config for Runtime {}

#[cfg(feature = "frame-feature-testing")]
impl pallet3::Config for Runtime {
	type RuntimeOrigin = RuntimeOrigin;
}

#[cfg(feature = "frame-feature-testing-2")]
impl pallet5::Config for Runtime {
	type RuntimeOrigin = RuntimeOrigin;
}

pub type Header = pezsp_runtime::generic::Header<u32, pezsp_runtime::traits::BlakeTwo256>;
pub type Block = pezsp_runtime::generic::Block<Header, UncheckedExtrinsic>;
pub type UncheckedExtrinsic = pezsp_runtime::generic::UncheckedExtrinsic<
	u64,
	RuntimeCall,
	UintAuthorityId,
	pezframe_system::CheckNonZeroSender<Runtime>,
>;
pub type UncheckedSignaturePayload = pezsp_runtime::generic::UncheckedSignaturePayload<
	u64,
	UintAuthorityId,
	pezframe_system::CheckNonZeroSender<Runtime>,
>;

impl SigningTypes for Runtime {
	type Public = UintAuthorityId;
	type Signature = UintAuthorityId;
}

impl<LocalCall> CreateTransactionBase<LocalCall> for Runtime
where
	RuntimeCall: From<LocalCall>,
{
	type RuntimeCall = RuntimeCall;
	type Extrinsic = UncheckedExtrinsic;
}

impl<LocalCall> CreateSignedTransaction<LocalCall> for Runtime
where
	RuntimeCall: From<LocalCall>,
{
	fn create_signed_transaction<
		C: pezframe_system::offchain::AppCrypto<Self::Public, Self::Signature>,
	>(
		call: RuntimeCall,
		_public: UintAuthorityId,
		account: u64,
		nonce: u64,
	) -> Option<UncheckedExtrinsic> {
		Some(UncheckedExtrinsic::new_signed(
			call,
			nonce,
			account.into(),
			pezframe_system::CheckNonZeroSender::new(),
		))
	}
}

#[pezframe_support::runtime]
mod runtime {
	#[runtime::runtime]
	#[runtime::derive(
		RuntimeCall,
		RuntimeEvent,
		RuntimeError,
		RuntimeOrigin,
		RuntimeFreezeReason,
		RuntimeHoldReason,
		RuntimeSlashReason,
		RuntimeLockId,
		RuntimeTask,
		RuntimeViewFunction
	)]
	pub struct Runtime;

	#[runtime::pezpallet_index(0)]
	pub type System = pezframe_system + Call + Event<T>;

	#[runtime::pezpallet_index(1)]
	pub type Example = pezpallet;

	#[runtime::pezpallet_index(2)]
	#[runtime::disable_call]
	pub type Example2 = pallet2;

	#[cfg(feature = "frame-feature-testing")]
	#[runtime::pezpallet_index(3)]
	pub type Example3 = pallet3;

	#[runtime::pezpallet_index(4)]
	pub type Example4 = pallet4;

	#[cfg(feature = "frame-feature-testing-2")]
	#[runtime::pezpallet_index(5)]
	pub type Example5 = pallet5;
}

// Test that the part `RuntimeCall` is excluded from Example2 and included in Example4.
fn _ensure_call_is_correctly_excluded_and_included(call: RuntimeCall) {
	match call {
		RuntimeCall::System(_) | RuntimeCall::Example(_) | RuntimeCall::Example4(_) => (),
	}
}

fn maybe_docs(doc: Vec<&'static str>) -> Vec<&'static str> {
	if cfg!(feature = "no-metadata-docs") {
		vec![]
	} else {
		doc
	}
}

#[test]
#[allow(deprecated)]
fn transactional_works() {
	TestExternalities::default().execute_with(|| {
		pezframe_system::Pezpallet::<Runtime>::set_block_number(1);

		pezpallet::Call::<Runtime>::foo_storage_layer { foo: 0 }
			.dispatch_bypass_filter(None.into())
			.err()
			.unwrap();
		assert!(pezframe_system::Pezpallet::<Runtime>::events().is_empty());

		pezpallet::Call::<Runtime>::foo_storage_layer { foo: 1 }
			.dispatch_bypass_filter(None.into())
			.unwrap();
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()
				.iter()
				.map(|e| &e.event)
				.collect::<Vec<_>>(),
			vec![&RuntimeEvent::Example(pezpallet::Event::Something(0))],
		);
	})
}

#[test]
fn call_expand() {
	let call_foo = pezpallet::Call::<Runtime>::foo { foo: 3, bar: 0 };
	assert_eq!(
		call_foo.get_dispatch_info(),
		DispatchInfo {
			call_weight: pezframe_support::weights::Weight::from_parts(3, 0),
			extension_weight: Default::default(),
			class: DispatchClass::Normal,
			pays_fee: Pays::Yes
		}
	);
	assert_eq!(call_foo.get_call_name(), "foo");
	#[cfg(not(feature = "frame-feature-testing"))]
	assert_eq!(
		pezpallet::Call::<Runtime>::get_call_names(),
		&[
			"foo",
			"foo_storage_layer",
			"foo_index_out_of_order",
			"foo_no_post_info",
			"check_for_dispatch_context"
		],
	);
	#[cfg(feature = "frame-feature-testing")]
	assert_eq!(
		pezpallet::Call::<Runtime>::get_call_names(),
		&[
			"foo",
			"foo_storage_layer",
			"foo_index_out_of_order",
			"foo_no_post_info",
			"check_for_dispatch_context",
			"foo_feature_test"
		],
	);

	assert_eq!(call_foo.get_call_index(), 0u8);
	#[cfg(not(feature = "frame-feature-testing"))]
	assert_eq!(pezpallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8]);
	#[cfg(feature = "frame-feature-testing")]
	assert_eq!(pezpallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8, 5u8]);
}

#[test]
fn call_expand_index() {
	let call_foo = pezpallet::Call::<Runtime>::foo_index_out_of_order {};

	assert_eq!(call_foo.get_call_index(), 4u8);
	#[cfg(not(feature = "frame-feature-testing"))]
	assert_eq!(pezpallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8]);
	#[cfg(feature = "frame-feature-testing")]
	assert_eq!(pezpallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8, 5u8]);
}

#[test]
fn error_expand() {
	assert_eq!(
		format!("{:?}", pezpallet::Error::<Runtime>::InsufficientProposersBalance),
		String::from("InsufficientProposersBalance"),
	);
	assert_eq!(
		<&'static str>::from(pezpallet::Error::<Runtime>::InsufficientProposersBalance),
		"InsufficientProposersBalance",
	);
	assert_eq!(
		DispatchError::from(pezpallet::Error::<Runtime>::InsufficientProposersBalance),
		DispatchError::Module(ModuleError {
			index: 1,
			error: [0, 0, 0, 0],
			message: Some("InsufficientProposersBalance")
		}),
	);
	assert_eq!(<pezpallet::Error::<Runtime> as PalletError>::MAX_ENCODED_SIZE, 3);
	#[cfg(feature = "frame-feature-testing")]
	assert_eq!(format!("{:?}", pezpallet::Error::<Runtime>::FeatureTest), String::from("FeatureTest"),);
}

#[test]
fn instance_expand() {
	// Assert same type.
	let _: pezpallet::__InherentHiddenInstance = ();
}

#[test]
fn inherent_expand() {
	use pezframe_support::inherent::InherentData;
	use pezsp_core::Hasher;
	use pezsp_runtime::{
		traits::{BlakeTwo256, Block as _, Header},
		Digest,
	};

	let inherents = InherentData::new().create_extrinsics();

	let expected =
		vec![UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo_no_post_info {}))];
	assert_eq!(expected, inherents);

	let block = Block::new(
		Header::new(
			1,
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			Digest::default(),
		),
		vec![
			UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo_no_post_info {})),
			UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo {
				foo: 1,
				bar: 0,
			})),
		],
	);

	assert!(InherentData::new().check_extrinsics(&block.into()).ok());

	let block = Block::new(
		Header::new(
			1,
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			Digest::default(),
		),
		vec![
			UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo_no_post_info {})),
			UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo {
				foo: 0,
				bar: 0,
			})),
		],
	);

	assert!(InherentData::new().check_extrinsics(&block.into()).fatal_error());

	let block = Block::new(
		Header::new(
			1,
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			Digest::default(),
		),
		vec![UncheckedExtrinsic::new_bare(RuntimeCall::Example(pezpallet::Call::foo_storage_layer {
			foo: 0,
		}))],
	);

	let mut inherent = InherentData::new();
	inherent.put_data(*b"required", &true).unwrap();
	assert!(inherent.check_extrinsics(&block.into()).fatal_error());

	let block = Block::new(
		Header::new(
			1,
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			BlakeTwo256::hash(b"test"),
			Digest::default(),
		),
		vec![UncheckedExtrinsic::new_signed(
			RuntimeCall::Example(pezpallet::Call::foo_no_post_info {}),
			1,
			1.into(),
			Default::default(),
		)],
	);

	let mut inherent = InherentData::new();
	inherent.put_data(*b"required", &true).unwrap();
	assert!(inherent.check_extrinsics(&block.into()).fatal_error());
}

#[test]
fn validate_unsigned_expand() {
	use pezframe_support::pezpallet_prelude::{
		InvalidTransaction, TransactionSource, TransactionValidityError, ValidTransaction,
		ValidateUnsigned,
	};
	let call = pezpallet::Call::<Runtime>::foo_no_post_info {};

	let validity = pezpallet::Pezpallet::validate_unsigned(TransactionSource::Local, &call).unwrap_err();
	assert_eq!(validity, TransactionValidityError::Invalid(InvalidTransaction::Call));

	let call = pezpallet::Call::<Runtime>::foo_storage_layer { foo: 0 };

	let validity = pezpallet::Pezpallet::validate_unsigned(TransactionSource::External, &call).unwrap();
	assert_eq!(validity, ValidTransaction::default());
}

#[test]
fn composite_expand() {
	use codec::Encode;

	let hold_reason: RuntimeHoldReason = pezpallet::HoldReason::Staking.into();
	let hold_reason2: RuntimeHoldReason = pallet2::HoldReason::Governance.into();
	let slash_reason: RuntimeSlashReason = pallet2::SlashReason::Equivocation.into();

	assert_eq!(hold_reason, RuntimeHoldReason::Example(pezpallet::HoldReason::Staking));
	assert_eq!(hold_reason2, RuntimeHoldReason::Example2(pallet2::HoldReason::Governance));
	assert_eq!(slash_reason, RuntimeSlashReason::Example2(pallet2::SlashReason::Equivocation));

	assert_eq!(hold_reason.encode(), [1, 0]);
	assert_eq!(hold_reason2.encode(), [2, 0]);
	assert_eq!(slash_reason.encode(), [2, 0]);
}

#[test]
#[allow(deprecated)]
fn pezpallet_expand_deposit_event() {
	TestExternalities::default().execute_with(|| {
		pezframe_system::Pezpallet::<Runtime>::set_block_number(1);
		pezpallet::Call::<Runtime>::foo { foo: 3, bar: 0 }
			.dispatch_bypass_filter(None.into())
			.unwrap();
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[0].event,
			RuntimeEvent::Example(pezpallet::Event::Something(3)),
		);
	})
}

#[test]
fn pezpallet_new_call_variant() {
	pezpallet::Call::<Runtime>::new_call_variant_foo(3, 4);
}

#[test]
#[allow(deprecated)]
fn storage_expand() {
	use pezframe_support::{pezpallet_prelude::*, storage::StoragePrefixedMap};

	fn twox_64_concat(d: &[u8]) -> Vec<u8> {
		let mut v = twox_64(d).to_vec();
		v.extend_from_slice(d);
		v
	}

	fn blake2_128_concat(d: &[u8]) -> Vec<u8> {
		let mut v = blake2_128(d).to_vec();
		v.extend_from_slice(d);
		v
	}

	TestExternalities::default().execute_with(|| {
		pezpallet::Value::<Runtime>::put(1);
		let k = [twox_128(b"Example"), twox_128(b"Value")].concat();
		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));

		pezpallet::RenamedValue::<Runtime>::put(2);
		let k = [twox_128(b"Example"), twox_128(b"Value2")].concat();
		assert_eq!(unhashed::get::<u64>(&k), Some(2));

		pezpallet::Map::<Runtime>::insert(1, 2);
		let mut k = [twox_128(b"Example"), twox_128(b"Map")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u16>(&k), Some(2u16));
		assert_eq!(&k[..32], &<pezpallet::Map<Runtime>>::final_prefix());

		pezpallet::Map2::<Runtime>::insert(1, 2);
		let mut k = [twox_128(b"Example"), twox_128(b"Map2")].concat();
		k.extend(1u16.using_encoded(twox_64_concat));
		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
		assert_eq!(&k[..32], &<pezpallet::Map2<Runtime>>::final_prefix());

		pezpallet::Map3::<Runtime>::insert(1, 2);
		let mut k = [twox_128(b"Example"), twox_128(b"Map3")].concat();
		k.extend(1u32.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u64>(&k), Some(2u64));
		assert_eq!(&k[..32], &<pezpallet::Map3<Runtime>>::final_prefix());
		assert_eq!(
			pezpallet::Map3::<Runtime>::get(2),
			Err(pezpallet::Error::<Runtime>::NonExistentStorageValue),
		);

		pezpallet::DoubleMap::<Runtime>::insert(&1, &2, &3);
		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		k.extend(2u16.using_encoded(twox_64_concat));
		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
		assert_eq!(&k[..32], &<pezpallet::DoubleMap<Runtime>>::final_prefix());

		pezpallet::DoubleMap2::<Runtime>::insert(&1, &2, &3);
		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap2")].concat();
		k.extend(1u16.using_encoded(twox_64_concat));
		k.extend(2u32.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
		assert_eq!(&k[..32], &<pezpallet::DoubleMap2<Runtime>>::final_prefix());

		pezpallet::DoubleMap3::<Runtime>::insert(&1, &2, &3);
		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap3")].concat();
		k.extend(1u32.using_encoded(blake2_128_concat));
		k.extend(2u64.using_encoded(twox_64_concat));
		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
		assert_eq!(&k[..32], &<pezpallet::DoubleMap3<Runtime>>::final_prefix());
		assert_eq!(
			pezpallet::DoubleMap3::<Runtime>::get(2, 3),
			Err(pezpallet::Error::<Runtime>::NonExistentStorageValue),
		);

		pezpallet::NMap::<Runtime>::insert((&1,), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"NMap")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
		assert_eq!(&k[..32], &<pezpallet::NMap<Runtime>>::final_prefix());

		pezpallet::NMap2::<Runtime>::insert((&1, &2), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"NMap2")].concat();
		k.extend(1u16.using_encoded(twox_64_concat));
		k.extend(2u32.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
		assert_eq!(&k[..32], &<pezpallet::NMap2<Runtime>>::final_prefix());
		assert_eq!(pezpallet::Pezpallet::<Runtime>::nmap2((1, 2)), Some(3u64));

		pezpallet::NMap3::<Runtime>::insert((&1, &2), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"NMap3")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		k.extend(2u16.using_encoded(twox_64_concat));
		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
		assert_eq!(&k[..32], &<pezpallet::NMap3<Runtime>>::final_prefix());
		assert_eq!(pezpallet::Pezpallet::<Runtime>::nmap3((1, 2)), Ok(3u128));
		assert_eq!(
			pezpallet::NMap3::<Runtime>::get((2, 3)),
			Err(pezpallet::Error::<Runtime>::NonExistentStorageValue),
		);

		pezpallet::CountedNMap::<Runtime>::insert((&1,), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
		assert_eq!(pezpallet::CountedNMap::<Runtime>::count(), 1);
		assert_eq!(
			unhashed::get::<u32>(
				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap")].concat()
			),
			Some(1u32)
		);

		pezpallet::CountedNMap2::<Runtime>::insert((&1, &2), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap2")].concat();
		k.extend(1u16.using_encoded(twox_64_concat));
		k.extend(2u32.using_encoded(blake2_128_concat));
		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
		assert_eq!(pezpallet::CountedNMap2::<Runtime>::count(), 1);
		assert_eq!(
			unhashed::get::<u32>(
				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap2")].concat()
			),
			Some(1u32)
		);
		assert_eq!(pezpallet::Pezpallet::<Runtime>::counted_nmap2((1, 2)), Some(3u64));

		pezpallet::CountedNMap3::<Runtime>::insert((&1, &2), &3);
		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap3")].concat();
		k.extend(1u8.using_encoded(blake2_128_concat));
		k.extend(2u16.using_encoded(twox_64_concat));
		assert_eq!(pezpallet::CountedNMap3::<Runtime>::count(), 1);
		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
		assert_eq!(pezpallet::Pezpallet::<Runtime>::counted_nmap3((1, 2)), Ok(3u128));
		assert_eq!(
			pezpallet::CountedNMap3::<Runtime>::get((2, 3)),
			Err(pezpallet::Error::<Runtime>::NonExistentStorageValue),
		);
		assert_eq!(
			unhashed::get::<u32>(
				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap3")].concat()
			),
			Some(1u32)
		);

		#[cfg(feature = "frame-feature-testing")]
		{
			pezpallet::ConditionalValue::<Runtime>::put(1);
			pezpallet::ConditionalMap::<Runtime>::insert(1, 2);
			pezpallet::ConditionalDoubleMap::<Runtime>::insert(1, 2, 3);
			pezpallet::ConditionalNMap::<Runtime>::insert((1, 2), 3);
		}

		pezpallet::SomeCountedStorageMap::<Runtime>::insert(1, 2);
		let mut k = [twox_128(b"Example"), twox_128(b"RenamedCountedMap")].concat();
		k.extend(1u8.using_encoded(twox_64_concat));
		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
		let k = [twox_128(b"Example"), twox_128(b"CounterForRenamedCountedMap")].concat();
		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));

		pezpallet::Unbounded::<Runtime>::put(vec![1, 2]);
		let k = [twox_128(b"Example"), twox_128(b"Unbounded")].concat();
		assert_eq!(unhashed::get::<Vec<u8>>(&k), Some(vec![1, 2]));
	})
}

#[test]
#[allow(deprecated)]
fn pezpallet_hooks_expand() {
	TestExternalities::default().execute_with(|| {
		pezframe_system::Pezpallet::<Runtime>::set_block_number(1);

		assert_eq!(AllPalletsWithoutSystem::on_initialize(1), Weight::from_parts(10, 0));
		AllPalletsWithoutSystem::on_finalize(1);

		assert_eq!(AllPalletsWithoutSystem::on_runtime_upgrade(), Weight::from_parts(30, 0));

		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[0].event,
			RuntimeEvent::Example(pezpallet::Event::Something(10)),
		);
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[1].event,
			RuntimeEvent::Example2(pallet2::Event::Something(11)),
		);
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[2].event,
			RuntimeEvent::Example(pezpallet::Event::Something(20)),
		);
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[3].event,
			RuntimeEvent::Example2(pallet2::Event::Something(21)),
		);
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[4].event,
			RuntimeEvent::Example(pezpallet::Event::Something(30)),
		);
		assert_eq!(
			pezframe_system::Pezpallet::<Runtime>::events()[5].event,
			RuntimeEvent::Example2(pallet2::Event::Something(31)),
		);
	})
}

#[test]
fn pezpallet_on_genesis() {
	TestExternalities::default().execute_with(|| {
		assert_eq!(pezpallet::Pezpallet::<Runtime>::on_chain_storage_version(), StorageVersion::new(0));
		pezpallet::Pezpallet::<Runtime>::on_genesis();
		assert_eq!(
			pezpallet::Pezpallet::<Runtime>::in_code_storage_version(),
			pezpallet::Pezpallet::<Runtime>::on_chain_storage_version(),
		);
	})
}

#[test]
fn migrate_from_pallet_version_to_storage_version() {
	const PALLET_VERSION_STORAGE_KEY_POSTFIX: &[u8] = b":__PALLET_VERSION__:";

	fn pezpallet_version_key(name: &str) -> [u8; 32] {
		pezframe_support::storage::storage_prefix(name.as_bytes(), PALLET_VERSION_STORAGE_KEY_POSTFIX)
	}

	TestExternalities::default().execute_with(|| {
		// Insert some fake pezpallet versions
		pezsp_io::storage::set(&pezpallet_version_key(Example::name()), &[1, 2, 3]);
		pezsp_io::storage::set(&pezpallet_version_key(Example2::name()), &[1, 2, 3]);
		pezsp_io::storage::set(&pezpallet_version_key(System::name()), &[1, 2, 3]);

		// Check that everyone currently is at version 0
		assert_eq!(Example::on_chain_storage_version(), StorageVersion::new(0));
		assert_eq!(Example2::on_chain_storage_version(), StorageVersion::new(0));
		assert_eq!(System::on_chain_storage_version(), StorageVersion::new(0));

		let db_weight = RuntimeDbWeight { read: 0, write: 5 };
		let weight = pezframe_support::migrations::migrate_from_pallet_version_to_storage_version::<
			AllPalletsWithSystem,
		>(&db_weight);

		let mut pezpallet_num = 4;
		if cfg!(feature = "frame-feature-testing") {
			pezpallet_num += 1;
		};
		if cfg!(feature = "frame-feature-testing-2") {
			pezpallet_num += 1;
		};

		// `pezpallet_num` pallets, 2 writes and every write costs 5 weight.
		assert_eq!(Weight::from_parts(pezpallet_num * 2 * 5, 0), weight);

		// All pezpallet versions should be removed
		assert!(pezsp_io::storage::get(&pezpallet_version_key(Example::name())).is_none());
		assert!(pezsp_io::storage::get(&pezpallet_version_key(Example2::name())).is_none());
		assert!(pezsp_io::storage::get(&pezpallet_version_key(System::name())).is_none());

		assert_eq!(Example::on_chain_storage_version(), pezpallet::STORAGE_VERSION);
		assert_eq!(Example2::on_chain_storage_version(), pallet2::STORAGE_VERSION);
		assert_eq!(System::on_chain_storage_version(), StorageVersion::new(0));
	});
}

#[test]
#[allow(deprecated)]
fn pezpallet_item_docs_in_metadata() {
	// call
	let call_variants = match meta_type::<pezpallet::Call<Runtime>>().type_info().type_def {
		scale_info::TypeDef::Variant(variants) => variants.variants,
		_ => unreachable!(),
	};

	assert_eq!(call_variants[0].docs, maybe_docs(vec!["call foo doc comment put in metadata"]));
	assert_eq!(
		call_variants[1].docs,
		maybe_docs(vec!["call foo_storage_layer doc comment put in metadata"])
	);
	assert!(call_variants[2].docs.is_empty());

	// event
	let event_variants = match meta_type::<pezpallet::Event<Runtime>>().type_info().type_def {
		scale_info::TypeDef::Variant(variants) => variants.variants,
		_ => unreachable!(),
	};

	assert_eq!(event_variants[0].docs, maybe_docs(vec!["event doc comment put in metadata"]));
	assert!(event_variants[1].docs.is_empty());

	// error
	let error_variants = match meta_type::<pezpallet::Error<Runtime>>().type_info().type_def {
		scale_info::TypeDef::Variant(variants) => variants.variants,
		_ => unreachable!(),
	};

	assert_eq!(error_variants[0].docs, maybe_docs(vec!["error doc comment put in metadata"]));
	assert!(error_variants[1].docs.is_empty());

	// storage is already covered in the main `fn metadata` test.
}

#[test]
#[allow(deprecated)]
fn metadata_v15() {
	use codec::Decode;
	use frame_metadata::{v15::*, *};

	let readme = "Very important information :D\n";
	let pezpallet_doc = "This is the best pezpallet\n";
	let expected_pallet_doc = vec![" Pezpallet documentation", readme, pezpallet_doc];

	let pallets = vec![
		PalletMetadata {
			index: 1,
			name: "Example",
			storage: Some(PalletStorageMetadata {
				prefix: "Example",
				entries: vec![
					StorageEntryMetadata {
						name: "ValueWhereClause",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<u64>()),
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "Value",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "Value2",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<u64>()),
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "Map",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Map {
							key: meta_type::<u8>(),
							value: meta_type::<u16>(),
							hashers: vec![StorageHasher::Blake2_128Concat],
						},
						default: vec![4, 0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "Map2",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<u16>(),
							value: meta_type::<u32>(),
							hashers: vec![StorageHasher::Twox64Concat],
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "Map3",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<u32>(),
							value: meta_type::<u64>(),
							hashers: vec![StorageHasher::Blake2_128Concat],
						},
						default: vec![1, 1],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "DoubleMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							value: meta_type::<u32>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
							key: meta_type::<(u8, u16)>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "DoubleMap2",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							value: meta_type::<u64>(),
							key: meta_type::<(u16, u32)>(),
							hashers: vec![
								StorageHasher::Twox64Concat,
								StorageHasher::Blake2_128Concat,
							],
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "DoubleMap3",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							value: meta_type::<u128>(),
							key: meta_type::<(u32, u64)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
						},
						default: vec![1, 1],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "NMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<u8>(),
							hashers: vec![StorageHasher::Blake2_128Concat],
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "NMap2",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u16, u32)>(),
							hashers: vec![
								StorageHasher::Twox64Concat,
								StorageHasher::Blake2_128Concat,
							],
							value: meta_type::<u64>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "NMap3",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u8, u16)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
							value: meta_type::<u128>(),
						},
						default: vec![1, 1],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CountedNMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<u8>(),
							hashers: vec![StorageHasher::Blake2_128Concat],
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CounterForCountedNMap",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
					StorageEntryMetadata {
						name: "CountedNMap2",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u16, u32)>(),
							hashers: vec![
								StorageHasher::Twox64Concat,
								StorageHasher::Blake2_128Concat,
							],
							value: meta_type::<u64>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CounterForCountedNMap2",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
					StorageEntryMetadata {
						name: "CountedNMap3",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u8, u16)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
							value: meta_type::<u128>(),
						},
						default: vec![1, 1],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CounterForCountedNMap3",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "ConditionalValue",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0],
						docs: vec![],
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "ConditionalMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<u16>(),
							value: meta_type::<u32>(),
							hashers: vec![StorageHasher::Twox64Concat],
						},
						default: vec![0],
						docs: vec![],
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "ConditionalDoubleMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							value: meta_type::<u32>(),
							key: meta_type::<(u8, u16)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
						},
						default: vec![0],
						docs: vec![],
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "ConditionalNMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u8, u16)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "ConditionalCountedNMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							key: meta_type::<(u8, u16)>(),
							hashers: vec![
								StorageHasher::Blake2_128Concat,
								StorageHasher::Twox64Concat,
							],
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					#[cfg(feature = "frame-feature-testing")]
					StorageEntryMetadata {
						name: "CounterForConditionalCountedNMap",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
					StorageEntryMetadata {
						name: "RenamedCountedMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							hashers: vec![StorageHasher::Twox64Concat],
							key: meta_type::<u8>(),
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CounterForRenamedCountedMap",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
					StorageEntryMetadata {
						name: "Unbounded",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<Vec<u8>>()),
						default: vec![0],
						docs: vec![],
					},
				],
			}),
			calls: Some(meta_type::<pezpallet::Call<Runtime>>().into()),
			event: Some(meta_type::<pezpallet::Event<Runtime>>().into()),
			constants: vec![
				PalletConstantMetadata {
					name: "MyGetParam",
					ty: meta_type::<u32>(),
					value: vec![10, 0, 0, 0],
					docs: maybe_docs(vec![" Some comment", " Some comment"]),
				},
				PalletConstantMetadata {
					name: "MyGetParam2",
					ty: meta_type::<u32>(),
					value: vec![11, 0, 0, 0],
					docs: maybe_docs(vec![" Some comment", " Some comment"]),
				},
				PalletConstantMetadata {
					name: "MyGetParam3",
					ty: meta_type::<u64>(),
					value: vec![12, 0, 0, 0, 0, 0, 0, 0],
					docs: vec![],
				},
				PalletConstantMetadata {
					name: "some_extra",
					ty: meta_type::<u64>(),
					value: vec![100, 0, 0, 0, 0, 0, 0, 0],
					docs: maybe_docs(vec![" Some doc", " Some doc"]),
				},
				PalletConstantMetadata {
					name: "some_extra_extra",
					ty: meta_type::<u64>(),
					value: vec![0, 0, 0, 0, 0, 0, 0, 0],
					docs: maybe_docs(vec![" Some doc"]),
				},
				PalletConstantMetadata {
					name: "SomeExtraRename",
					ty: meta_type::<u64>(),
					value: vec![0, 0, 0, 0, 0, 0, 0, 0],
					docs: maybe_docs(vec![" Some doc"]),
				},
			],
			error: Some(PalletErrorMetadata { ty: meta_type::<pezpallet::Error<Runtime>>() }),
			docs: expected_pallet_doc,
		},
		PalletMetadata {
			index: 2,
			name: "Example2",
			storage: Some(PalletStorageMetadata {
				prefix: "Example2",
				entries: vec![
					StorageEntryMetadata {
						name: "SomeValue",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Plain(meta_type::<Vec<u32>>()),
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "SomeCountedStorageMap",
						modifier: StorageEntryModifier::Optional,
						ty: StorageEntryType::Map {
							hashers: vec![StorageHasher::Twox64Concat],
							key: meta_type::<u8>(),
							value: meta_type::<u32>(),
						},
						default: vec![0],
						docs: vec![],
					},
					StorageEntryMetadata {
						name: "CounterForSomeCountedStorageMap",
						modifier: StorageEntryModifier::Default,
						ty: StorageEntryType::Plain(meta_type::<u32>()),
						default: vec![0, 0, 0, 0],
						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
					},
				],
			}),
			calls: None,
			event: Some(PalletEventMetadata { ty: meta_type::<pallet2::Event>() }),
			constants: vec![],
			error: None,
			docs: vec![],
		},
		#[cfg(feature = "frame-feature-testing")]
		PalletMetadata {
			index: 3,
			name: "Example3",
			storage: None,
			calls: None,
			event: None,
			constants: vec![],
			error: None,
			docs: vec![" Test that the supertrait check works when we pass some parameter to the `pezframe_system::Config`."],
		},
		PalletMetadata {
			index: 4,
			name: "Example4",
			storage: None,
			calls: Some(meta_type::<pallet4::Call<Runtime>>().into()),
			event: None,
			constants: vec![],
			error: None,
			docs: vec![],
		},
		#[cfg(feature = "frame-feature-testing-2")]
		PalletMetadata {
			index: 5,
			name: "Example5",
			storage: None,
			calls: None,
			event: None,
			constants: vec![],
			error: None,
			docs: vec![" Test that the supertrait check works when we pass some parameter to the `pezframe_system::Config`."],
		},
	];

	let empty_doc = pallets[0].event.as_ref().unwrap().ty.type_info().docs.is_empty() &&
		pallets[0].error.as_ref().unwrap().ty.type_info().docs.is_empty() &&
		pallets[0].calls.as_ref().unwrap().ty.type_info().docs.is_empty();

	if cfg!(feature = "no-metadata-docs") {
		assert!(empty_doc)
	} else {
		assert!(!empty_doc)
	}

	let extrinsic = ExtrinsicMetadata {
		version: 5,
		signed_extensions: vec![SignedExtensionMetadata {
			identifier: "UnitSignedExtension",
			ty: meta_type::<()>(),
			additional_signed: meta_type::<()>(),
		}],
		address_ty: meta_type::<
			<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Address
		>(),
		call_ty: meta_type::<<Runtime as CreateTransactionBase<RuntimeCall>>::RuntimeCall>(),
		signature_ty: meta_type::<
			<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Signature
		>(),
		extra_ty: meta_type::<
			<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Extension
		>(),
	};

	let outer_enums = OuterEnums {
		call_enum_ty: meta_type::<RuntimeCall>(),
		event_enum_ty: meta_type::<RuntimeEvent>(),
		error_enum_ty: meta_type::<RuntimeError>(),
	};

	let expected_metadata: RuntimeMetadataPrefixed = RuntimeMetadataLastVersion::new(
		pallets,
		extrinsic,
		meta_type::<Runtime>(),
		vec![],
		outer_enums,
		CustomMetadata { map: Default::default() },
	)
	.into();
	let expected_metadata = match expected_metadata.1 {
		RuntimeMetadata::V15(metadata) => metadata,
		_ => panic!("metadata has been bumped, test needs to be updated"),
	};

	let bytes = &Runtime::metadata_at_version(15).expect("Metadata must be present; qed");

	let actual_metadata: RuntimeMetadataPrefixed =
		Decode::decode(&mut &bytes[..]).expect("Metadata encoded properly; qed");

	let actual_metadata = match actual_metadata.1 {
		RuntimeMetadata::V15(metadata) => metadata,
		_ => panic!("metadata has been bumped, test needs to be updated"),
	};

	pretty_assertions::assert_eq!(actual_metadata.pallets, expected_metadata.pallets);
}

#[test]
fn metadata_at_version() {
	use frame_metadata::*;
	use pezsp_core::Decode;

	// Metadata always returns the V14.3
	let metadata = Runtime::metadata();
	let at_metadata = match Runtime::metadata_at_version(14) {
		Some(opaque) => {
			let bytes = &*opaque;
			let metadata: RuntimeMetadataPrefixed = Decode::decode(&mut &bytes[..]).unwrap();
			metadata
		},
		_ => panic!("metadata has been bumped, test needs to be updated"),
	};

	assert_eq!(metadata, at_metadata);
}

#[test]
fn metadata_versions() {
	assert_eq!(vec![14, 15, 16], Runtime::metadata_versions());
}

#[test]
fn metadata_ir_pallet_runtime_docs() {
	let ir = Runtime::metadata_ir();
	let pezpallet = ir
		.pallets
		.iter()
		.find(|pezpallet| pezpallet.name == "Example")
		.expect("Pezpallet should be present");

	let readme = "Very important information :D\n";
	let pezpallet_doc = "This is the best pezpallet\n";
	let expected = vec![" Pezpallet documentation", readme, pezpallet_doc];
	assert_eq!(pezpallet.docs, expected);
}

#[test]
fn extrinsic_metadata_ir_types() {
	let ir = Runtime::metadata_ir().extrinsic;

	assert_eq!(
		meta_type::<<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Address>(),
		ir.address_ty
	);
	assert_eq!(meta_type::<u64>(), ir.address_ty);

	assert_eq!(
		meta_type::<<Runtime as CreateTransactionBase<RuntimeCall>>::RuntimeCall>(),
		ir.call_ty
	);
	assert_eq!(meta_type::<RuntimeCall>(), ir.call_ty);

	assert_eq!(
		meta_type::<<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Signature>(),
		ir.signature_ty
	);
	assert_eq!(meta_type::<UintAuthorityId>(), ir.signature_ty);

	assert_eq!(
		meta_type::<<<<Runtime as pezframe_system::Config>::Block as BlockT>::Extrinsic as SignedTransactionBuilder>::Extension>(),
		ir.extra_ty
	);
	assert_eq!(meta_type::<pezframe_system::CheckNonZeroSender<Runtime>>(), ir.extra_ty);
}

#[test]
fn test_pallet_runtime_docs() {
	let docs = crate::pezpallet::Pezpallet::<Runtime>::pezpallet_documentation_metadata();
	let readme = "Very important information :D\n";
	let pezpallet_doc = "This is the best pezpallet\n";
	let expected = vec![" Pezpallet documentation", readme, pezpallet_doc];
	assert_eq!(docs, expected);
}

#[test]
fn test_pallet_info_access() {
	assert_eq!(<System as pezframe_support::traits::PalletInfoAccess>::name(), "System");
	assert_eq!(<Example as pezframe_support::traits::PalletInfoAccess>::name(), "Example");
	assert_eq!(<Example2 as pezframe_support::traits::PalletInfoAccess>::name(), "Example2");
	assert_eq!(<System as pezframe_support::traits::PalletInfoAccess>::index(), 0);
	assert_eq!(<Example as pezframe_support::traits::PalletInfoAccess>::index(), 1);
	assert_eq!(<Example2 as pezframe_support::traits::PalletInfoAccess>::index(), 2);
}

#[test]
fn test_storage_info() {
	use pezframe_support::{
		storage::storage_prefix as prefix,
		traits::{StorageInfo, StorageInfoTrait},
	};

	// Storage max size is calculated by adding up all the hasher size, the key type size and the
	// value type size
	assert_eq!(
		Example::storage_info(),
		vec![
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"ValueWhereClause".to_vec(),
				prefix: prefix(b"Example", b"ValueWhereClause").to_vec(),
				max_values: Some(1),
				max_size: Some(8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Value".to_vec(),
				prefix: prefix(b"Example", b"Value").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Value2".to_vec(),
				prefix: prefix(b"Example", b"Value2").to_vec(),
				max_values: Some(1),
				max_size: Some(8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Map".to_vec(),
				prefix: prefix(b"Example", b"Map").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 2),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Map2".to_vec(),
				prefix: prefix(b"Example", b"Map2").to_vec(),
				max_values: Some(3),
				max_size: Some(8 + 2 + 4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Map3".to_vec(),
				prefix: prefix(b"Example", b"Map3").to_vec(),
				max_values: None,
				max_size: Some(16 + 4 + 8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"DoubleMap".to_vec(),
				prefix: prefix(b"Example", b"DoubleMap").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 8 + 2 + 4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"DoubleMap2".to_vec(),
				prefix: prefix(b"Example", b"DoubleMap2").to_vec(),
				max_values: Some(5),
				max_size: Some(8 + 2 + 16 + 4 + 8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"DoubleMap3".to_vec(),
				prefix: prefix(b"Example", b"DoubleMap3").to_vec(),
				max_values: None,
				max_size: Some(16 + 4 + 8 + 8 + 16),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"NMap".to_vec(),
				prefix: prefix(b"Example", b"NMap").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"NMap2".to_vec(),
				prefix: prefix(b"Example", b"NMap2").to_vec(),
				max_values: Some(11),
				max_size: Some(8 + 2 + 16 + 4 + 8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"NMap3".to_vec(),
				prefix: prefix(b"Example", b"NMap3").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 8 + 2 + 16),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CountedNMap".to_vec(),
				prefix: prefix(b"Example", b"CountedNMap").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CounterForCountedNMap".to_vec(),
				prefix: prefix(b"Example", b"CounterForCountedNMap").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CountedNMap2".to_vec(),
				prefix: prefix(b"Example", b"CountedNMap2").to_vec(),
				max_values: Some(11),
				max_size: Some(8 + 2 + 16 + 4 + 8),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CounterForCountedNMap2".to_vec(),
				prefix: prefix(b"Example", b"CounterForCountedNMap2").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CountedNMap3".to_vec(),
				prefix: prefix(b"Example", b"CountedNMap3").to_vec(),
				max_values: None,
				max_size: Some(16 + 1 + 8 + 2 + 16),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CounterForCountedNMap3".to_vec(),
				prefix: prefix(b"Example", b"CounterForCountedNMap3").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"ConditionalValue".to_vec(),
					prefix: prefix(b"Example", b"ConditionalValue").to_vec(),
					max_values: Some(1),
					max_size: Some(4),
				}
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"ConditionalMap".to_vec(),
					prefix: prefix(b"Example", b"ConditionalMap").to_vec(),
					max_values: Some(12),
					max_size: Some(8 + 2 + 4),
				}
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"ConditionalDoubleMap".to_vec(),
					prefix: prefix(b"Example", b"ConditionalDoubleMap").to_vec(),
					max_values: None,
					max_size: Some(16 + 1 + 8 + 2 + 4),
				}
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"ConditionalNMap".to_vec(),
					prefix: prefix(b"Example", b"ConditionalNMap").to_vec(),
					max_values: None,
					max_size: Some(16 + 1 + 8 + 2 + 4),
				}
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"ConditionalCountedNMap".to_vec(),
					prefix: prefix(b"Example", b"ConditionalCountedNMap").to_vec(),
					max_values: None,
					max_size: Some(16 + 1 + 8 + 2 + 4),
				}
			},
			#[cfg(feature = "frame-feature-testing")]
			{
				StorageInfo {
					pezpallet_name: b"Example".to_vec(),
					storage_name: b"CounterForConditionalCountedNMap".to_vec(),
					prefix: prefix(b"Example", b"CounterForConditionalCountedNMap").to_vec(),
					max_values: Some(1),
					max_size: Some(4),
				}
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"RenamedCountedMap".to_vec(),
				prefix: prefix(b"Example", b"RenamedCountedMap").to_vec(),
				max_values: None,
				max_size: Some(8 + 1 + 4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"CounterForRenamedCountedMap".to_vec(),
				prefix: prefix(b"Example", b"CounterForRenamedCountedMap").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
			StorageInfo {
				pezpallet_name: b"Example".to_vec(),
				storage_name: b"Unbounded".to_vec(),
				prefix: prefix(b"Example", b"Unbounded").to_vec(),
				max_values: Some(1),
				max_size: None,
			},
		],
	);

	assert_eq!(
		Example2::storage_info(),
		vec![
			StorageInfo {
				pezpallet_name: b"Example2".to_vec(),
				storage_name: b"SomeValue".to_vec(),
				prefix: prefix(b"Example2", b"SomeValue").to_vec(),
				max_values: Some(1),
				max_size: None,
			},
			StorageInfo {
				pezpallet_name: b"Example2".to_vec(),
				storage_name: b"SomeCountedStorageMap".to_vec(),
				prefix: prefix(b"Example2", b"SomeCountedStorageMap").to_vec(),
				max_values: None,
				max_size: None,
			},
			StorageInfo {
				pezpallet_name: b"Example2".to_vec(),
				storage_name: b"CounterForSomeCountedStorageMap".to_vec(),
				prefix: prefix(b"Example2", b"CounterForSomeCountedStorageMap").to_vec(),
				max_values: Some(1),
				max_size: Some(4),
			},
		],
	);
}

#[test]
fn assert_type_all_pallets_with_system_is_correct() {
	// Just ensure the 2 types are same.
	fn _a(_t: AllPalletsWithSystem) {}
	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
	fn _b(t: (System, Example, Example2, Example4)) {
		_a(t)
	}
	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
	fn _b(t: (System, Example, Example2, Example3, Example4)) {
		_a(t)
	}
	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
	fn _b(t: (System, Example, Example2, Example4, Example5)) {
		_a(t)
	}
	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
	fn _b(t: (System, Example, Example2, Example3, Example4, Example5)) {
		_a(t)
	}
}

#[test]
fn assert_type_all_pallets_without_system_is_correct() {
	// Just ensure the 2 types are same.
	fn _a(_t: AllPalletsWithoutSystem) {}
	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
	fn _b(t: (Example, Example2, Example4)) {
		_a(t)
	}
	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
	fn _b(t: (Example, Example2, Example3, Example4)) {
		_a(t)
	}
	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
	fn _b(t: (Example, Example2, Example4, Example5)) {
		_a(t)
	}
	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
	fn _b(t: (Example, Example2, Example3, Example4, Example5)) {
		_a(t)
	}
}

#[test]
fn test_storage_alias() {
	use pezframe_support::Twox64Concat;

	#[pezframe_support::storage_alias]
	type Value<T: pezpallet::Config>
	where
		<T as pezframe_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
	= StorageValue<pezpallet::Pezpallet<T>, u32, ValueQuery>;

	#[pezframe_support::storage_alias]
	type SomeCountedStorageMap<T: pallet2::Config>
	where
		<T as pezframe_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
	= CountedStorageMap<pallet2::Pezpallet<T>, Twox64Concat, u8, u32>;

	TestExternalities::default().execute_with(|| {
		pezpallet::Value::<Runtime>::put(10);
		assert_eq!(10, Value::<Runtime>::get());

		pallet2::SomeCountedStorageMap::<Runtime>::insert(10, 100);
		assert_eq!(Some(100), SomeCountedStorageMap::<Runtime>::get(10));
		assert_eq!(1, SomeCountedStorageMap::<Runtime>::count());
		assert_eq!(
			SomeCountedStorageMap::<Runtime>::storage_info(),
			pallet2::SomeCountedStorageMap::<Runtime>::storage_info()
		);
	})
}

#[test]
fn pezpallet_on_chain_storage_version_initializes_correctly() {
	type Executive = pezframe_executive::Executive<
		Runtime,
		Block,
		pezframe_system::ChainContext<Runtime>,
		Runtime,
		AllPalletsWithSystem,
	>;

	// Simple example of a pezpallet with in-code version 10 being added to the runtime for the first
	// time.
	TestExternalities::default().execute_with(|| {
		let in_code_version = Example::in_code_storage_version();

		// Check the pezpallet has no storage items set.
		let pezpallet_hashed_prefix = twox_128(Example::name().as_bytes());
		let exists = contains_prefixed_key(&pezpallet_hashed_prefix);
		assert_eq!(exists, false);

		// [`pezframe_support::traits::BeforeAllRuntimeMigrations`] hook should initialize the storage
		// version.
		Executive::execute_on_runtime_upgrade();

		// Check that the storage version was initialized to the in-code version
		let on_chain_version_after = StorageVersion::get::<Example>();
		assert_eq!(on_chain_version_after, in_code_version);
	});

	// Pezpallet with no in-code storage version should have the on-chain version initialized to 0.
	TestExternalities::default().execute_with(|| {
		// Example4 in_code_storage_version is NoStorageVersionSet.

		// Check the pezpallet has no storage items set.
		let pezpallet_hashed_prefix = twox_128(Example4::name().as_bytes());
		let exists = contains_prefixed_key(&pezpallet_hashed_prefix);
		assert_eq!(exists, false);

		// Confirm the storage version is implicitly 0.
		let on_chain_version_before = StorageVersion::get::<Example4>();
		assert_eq!(on_chain_version_before, StorageVersion::new(0));

		// [`pezframe_support::traits::BeforeAllRuntimeMigrations`] initializes the storage version.
		Executive::execute_on_runtime_upgrade();

		// Check that the storage version now exists and was initialized to 0.
		let on_chain_version_after = StorageVersion::get::<Example4>();
		assert_eq!(StorageVersion::exists::<Example4>(), true);
		assert_eq!(on_chain_version_after, StorageVersion::new(0));
	});
}

#[cfg(feature = "try-runtime")]
#[test]
fn post_runtime_upgrade_detects_storage_version_issues() {
	use pezframe_support::traits::UpgradeCheckSelect;

	struct CustomUpgrade;

	impl OnRuntimeUpgrade for CustomUpgrade {
		fn on_runtime_upgrade() -> Weight {
			Example2::in_code_storage_version().put::<Example2>();

			Default::default()
		}
	}

	struct CustomUpgradePallet4;

	impl OnRuntimeUpgrade for CustomUpgradePallet4 {
		fn on_runtime_upgrade() -> Weight {
			StorageVersion::new(100).put::<Example4>();

			Default::default()
		}
	}

	type Executive = pezframe_executive::Executive<
		Runtime,
		Block,
		pezframe_system::ChainContext<Runtime>,
		Runtime,
		AllPalletsWithSystem,
	>;

	/// TODO: The `OnRuntimeUpgrade` generic parameter in `Executive` is deprecated and will be
	/// removed in a future version. Once removed, this `#[allow(deprecated)]` attribute
	/// can be safely deleted.
	#[allow(deprecated)]
	type ExecutiveWithUpgrade = pezframe_executive::Executive<
		Runtime,
		Block,
		pezframe_system::ChainContext<Runtime>,
		Runtime,
		AllPalletsWithSystem,
		CustomUpgrade,
	>;

	/// TODO: The `OnRuntimeUpgrade` generic parameter in `Executive` is deprecated and will be
	/// removed in a future version. Once removed, this `#[allow(deprecated)]` attribute
	/// can be safely deleted.
	#[allow(deprecated)]
	type ExecutiveWithUpgradePallet4 = pezframe_executive::Executive<
		Runtime,
		Block,
		pezframe_system::ChainContext<Runtime>,
		Runtime,
		AllPalletsWithSystem,
		CustomUpgradePallet4,
	>;

	TestExternalities::default().execute_with(|| {
		// Set the on-chain version to one less than the in-code version for `Example`, simulating a
		// forgotten migration
		StorageVersion::new(9).put::<Example2>();

		// The version isn't changed, we should detect it.
		assert!(
			Executive::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap_err() ==
				"On chain and in-code storage version do not match. Missing runtime upgrade?"
					.into()
		);
	});

	TestExternalities::default().execute_with(|| {
		// Call `on_genesis` to put the storage version of `Example` into the storage.
		Example::on_genesis();
		// We set the new storage version in the pezpallet and that should be detected.
		UpdateStorageVersion::set(&true);
		Executive::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap();
	});

	TestExternalities::default().execute_with(|| {
		// Call `on_genesis` to put the storage version of `Example` into the storage.
		Example::on_genesis();
		// We set the new storage version in the custom upgrade and that should be detected.
		ExecutiveWithUpgrade::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap();
	});

	TestExternalities::default().execute_with(|| {
		// Call `on_genesis` to put the storage version of `Example` into the storage.
		Example::on_genesis();
		// We need to set the correct storage version for `Example2`
		UpdateStorageVersion::set(&true);

		// `CustomUpgradePallet4` will set a storage version for `Example4` while this doesn't has
		// any storage version "enabled".
		assert!(
			ExecutiveWithUpgradePallet4::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost)
				.unwrap_err() ==
				"On chain storage version set, while the pezpallet \
				doesn't have the `#[pezpallet::storage_version(VERSION)]` attribute."
					.into()
		);
	});
}

#[test]
fn test_dispatch_context() {
	TestExternalities::default().execute_with(|| {
		// By default there is no context
		assert!(with_context::<(), _>(|_| ()).is_none());

		// When not using `dispatch`, there should be no dispatch context
		assert_eq!(
			DispatchError::Unavailable,
			Example::check_for_dispatch_context(RuntimeOrigin::root()).unwrap_err(),
		);

		// When using `dispatch`, there should be a dispatch context
		assert_ok!(RuntimeCall::from(pezpallet::Call::<Runtime>::check_for_dispatch_context {})
			.dispatch(RuntimeOrigin::root()));
	});
}

#[test]
fn test_call_feature_parsing() {
	let call = pezpallet::Call::<Runtime>::check_for_dispatch_context {};
	match call {
		pezpallet::Call::<Runtime>::check_for_dispatch_context {} |
		pezpallet::Call::<Runtime>::foo { .. } |
		pezpallet::Call::foo_storage_layer { .. } |
		pezpallet::Call::foo_index_out_of_order {} |
		pezpallet::Call::foo_no_post_info {} => (),
		#[cfg(feature = "frame-feature-testing")]
		pezpallet::Call::foo_feature_test {} => (),
		pezpallet::Call::__Ignore(_, _) => (),
	}
}

#[test]
#[allow(deprecated)]
fn test_error_feature_parsing() {
	let err = pezpallet::Error::<Runtime>::InsufficientProposersBalance;
	match err {
		pezpallet::Error::InsufficientProposersBalance |
		pezpallet::Error::NonExistentStorageValue |
		pezpallet::Error::Code(_) |
		pezpallet::Error::Skipped(_) |
		pezpallet::Error::CompactU8(_) => (),
		#[cfg(feature = "frame-feature-testing")]
		pezpallet::Error::FeatureTest => (),
		pezpallet::Error::__Ignore(_, _) => (),
	}
}

#[test]
fn pezpallet_metadata() {
	use pezsp_metadata_ir::{EnumDeprecationInfoIR, ItemDeprecationInfoIR, VariantDeprecationInfoIR};
	let pallets = Runtime::metadata_ir().pallets;
	let example = pallets[0].clone();
	let example2 = pallets[1].clone();
	{
		// Example pezpallet calls is fully and partially deprecated
		let meta = &example.calls.unwrap();
		assert_eq!(
			EnumDeprecationInfoIR(BTreeMap::from([(
				0,
				VariantDeprecationInfoIR::Deprecated { note: "test", since: None }
			)])),
			meta.deprecation_info
		)
	}
	{
		// Example pezpallet constant is deprecated
		let meta = &example.constants[0];
		assert_eq!(
			ItemDeprecationInfoIR::Deprecated { note: "test 2", since: None },
			meta.deprecation_info
		)
	}
	{
		// Example pezpallet errors are partially and fully deprecated
		let meta = &example.error.unwrap();
		assert_eq!(
			EnumDeprecationInfoIR(BTreeMap::from([(
				2,
				VariantDeprecationInfoIR::Deprecated { note: "test", since: None }
			)])),
			meta.deprecation_info
		)
	}
	{
		// Example pezpallet events are partially and fully deprecated
		let meta = example.event.unwrap();
		assert_eq!(
			EnumDeprecationInfoIR(BTreeMap::from([(
				1,
				VariantDeprecationInfoIR::Deprecated { note: "test", since: None }
			)])),
			meta.deprecation_info
		);
	}
	{
		// Example2 pezpallet events are not deprecated
		let meta = example2.event.unwrap();
		assert!(!meta.deprecation_info.has_deprecated_variants());
	}
}