// This file is part of Substrate.

// 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.

//! # Utility Pallet

//! A stateless pallet with helpers for dispatch management which does no re-authentication.

//!

//! - [`Config`]

//! - [`Call`]

//!

//! ## Overview

//!

//! This pallet contains two basic pieces of functionality:

//! - Batch dispatch: A stateless operation, allowing any origin to execute multiple calls in a

//!   single dispatch. This can be useful to amalgamate proposals, combining `set_code` with

//!   corresponding `set_storage`s, for efficient multiple payouts with just a single signature

//!   verify, or in combination with one of the other two dispatch functionality.

//! - Pseudonymal dispatch: A stateless operation, allowing a signed origin to execute a call from

//!   an alternative signed origin. Each account has 2 * 2**16 possible "pseudonyms" (alternative

//!   account IDs) and these can be stacked. This can be useful as a key management tool, where you

//!   need multiple distinct accounts (e.g. as controllers for many staking accounts), but where

//!   it's perfectly fine to have each of them controlled by the same underlying keypair. Derivative

//!   accounts are, for the purposes of proxy filtering considered exactly the same as the origin

//!   and are thus hampered with the origin's filters.

//!

//! Since proxy filters are respected in all dispatches of this pallet, it should never need to be

//! filtered by any proxy.

//!

//! ## Interface

//!

//! ### Dispatchable Functions

//!

//! #### For batch dispatch

//! * `batch` - Dispatch multiple calls from the sender's origin.

//!

//! #### For pseudonymal dispatch

//! * `as_derivative` - Dispatch a call from a derivative signed origin.

// Ensure we're `no_std` when compiling for Wasm.

#![cfg_attr(not(feature = "std"), no_std)]

mod benchmarking;

mod tests;

pub mod weights;

extern crate alloc;

use alloc::{boxed::Box, vec::Vec};

use codec::{Decode, Encode};

use frame_support::{

	dispatch::{extract_actual_weight, GetDispatchInfo, PostDispatchInfo},

	traits::{IsSubType, OriginTrait, UnfilteredDispatchable},

};

use sp_core::TypeId;

use sp_io::hashing::blake2_256;

use sp_runtime::traits::{BadOrigin, Dispatchable, TrailingZeroInput};

pub use weights::WeightInfo;

pub use pallet::*;

pub mod pallet {

	use super::*;

	use frame_support::pallet_prelude::*;

	use frame_system::pallet_prelude::*;

	pub struct Pallet<T>(_);

	/// Configuration trait.

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// The overarching event type.

		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The overarching call type.

		type RuntimeCall: Parameter

			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>

			+ GetDispatchInfo

			+ From<frame_system::Call<Self>>

			+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>

			+ IsSubType<Call<Self>>

			+ IsType<<Self as frame_system::Config>::RuntimeCall>;

		/// The caller origin, overarching type of all pallets origins.

		type PalletsOrigin: Parameter +

			Into<<Self as frame_system::Config>::RuntimeOrigin> +

			IsType<<<Self as frame_system::Config>::RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

	}

	pub enum Event {

		/// well as the error.

	}

	// Align the call size to 1KB. As we are currently compiling the runtime for native/wasm

	// the `size_of` of the `Call` can be different. To ensure that this don't leads to

	// mismatches between native/wasm or to different metadata for the same runtime, we

	// algin the call size. The value is chosen big enough to hopefully never reach it.

	const CALL_ALIGN: u32 = 1024;

	#[pallet::extra_constants]

	impl<T: Config> Pallet<T> {

		/// The limit on the number of batched calls.

	}

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

				CALL_ALIGN,

			);

	}

	pub enum Error<T> {

	}

	impl<T: Config> Pallet<T> {

		/// Send a batch of dispatch calls.

		///

		/// May be called from any origin except `None`.

		///

		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not

		///   exceed the constant: `batched_calls_limit` (available in constant metadata).

		///

		/// If origin is root then the calls are dispatched without checking origin filter. (This

		/// includes bypassing `frame_system::Config::BaseCallFilter`).

		///

		/// ## Complexity

		/// - O(C) where C is the number of calls to be batched.

		///

		/// This will return `Ok` in all circumstances. To determine the success of the batch, an

		/// event is deposited. If a call failed and the batch was interrupted, then the

		/// `BatchInterrupted` event is deposited, along with the number of successful calls made

		/// and the error of the failed call. If all were successful, then the `BatchCompleted`

		/// event is deposited.

		#[pallet::call_index(0)]

		#[pallet::weight({

			let dispatch_weight = dispatch_infos.iter()

				.saturating_add(T::WeightInfo::batch(calls.len() as u32));

			let dispatch_class = {

				let all_operational = dispatch_infos.iter()

				if all_operational {

					DispatchClass::Operational

				} else {

					DispatchClass::Normal

				}

			};

			(dispatch_weight, dispatch_class)

		})]

		pub fn batch(

			origin: OriginFor<T>,

			calls: Vec<<T as Config>::RuntimeCall>,

			// Track the actual weight of each of the batch calls.

				// If origin is root, don't apply any dispatch filters; root can call anything.

				} else {

				};

				// Add the weight of this call.

			}

		}

		/// Send a call through an indexed pseudonym of the sender.

		///

		/// Filter from origin are passed along. The call will be dispatched with an origin which

		/// use the same filter as the origin of this call.

		///

		/// NOTE: If you need to ensure that any account-based filtering is not honored (i.e.

		/// because you expect `proxy` to have been used prior in the call stack and you do not want

		/// the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`

		/// in the Multisig pallet instead.

		///

		/// NOTE: Prior to version *12, this was called `as_limited_sub`.

		///

		/// The dispatch origin for this call must be _Signed_.

		#[pallet::call_index(1)]

		#[pallet::weight({

			let dispatch_info = call.get_dispatch_info();

			(

				T::WeightInfo::as_derivative()

					// AccountData for inner call origin accountdata.

					.saturating_add(T::DbWeight::get().reads_writes(1, 1))

					.saturating_add(dispatch_info.weight),

				dispatch_info.class,

			)

		})]

		pub fn as_derivative(

			origin: OriginFor<T>,

			index: u16,

			call: Box<<T as Config>::RuntimeCall>,

		}

		/// Send a batch of dispatch calls and atomically execute them.

		/// The whole transaction will rollback and fail if any of the calls failed.

		///

		/// May be called from any origin except `None`.

		///

		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not

		///   exceed the constant: `batched_calls_limit` (available in constant metadata).

		///

		/// If origin is root then the calls are dispatched without checking origin filter. (This

		/// includes bypassing `frame_system::Config::BaseCallFilter`).

		///

		/// ## Complexity

		/// - O(C) where C is the number of calls to be batched.

		#[pallet::call_index(2)]

		#[pallet::weight({

			let dispatch_weight = dispatch_infos.iter()

				.saturating_add(T::WeightInfo::batch_all(calls.len() as u32));

			let dispatch_class = {

				let all_operational = dispatch_infos.iter()

				if all_operational {

					DispatchClass::Operational

				} else {

					DispatchClass::Normal

				}

			};

			(dispatch_weight, dispatch_class)

		})]

		pub fn batch_all(

			origin: OriginFor<T>,

			calls: Vec<<T as Config>::RuntimeCall>,

			// Track the actual weight of each of the batch calls.

				// If origin is root, bypass any dispatch filter; root can call anything.

				} else {

				};

				// Add the weight of this call.

			}

		}

		/// Dispatches a function call with a provided origin.

		///

		/// The dispatch origin for this call must be _Root_.

		///

		/// ## Complexity

		/// - O(1).

		#[pallet::call_index(3)]

		#[pallet::weight({

			let dispatch_info = call.get_dispatch_info();

			(

				T::WeightInfo::dispatch_as()

					.saturating_add(dispatch_info.weight),

				dispatch_info.class,

			)

		})]

		pub fn dispatch_as(

			origin: OriginFor<T>,

			as_origin: Box<T::PalletsOrigin>,

			call: Box<<T as Config>::RuntimeCall>,

		}

		/// Send a batch of dispatch calls.

		/// Unlike `batch`, it allows errors and won't interrupt.

		///

		/// May be called from any origin except `None`.

		///

		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not

		///   exceed the constant: `batched_calls_limit` (available in constant metadata).

		///

		/// If origin is root then the calls are dispatch without checking origin filter. (This

		/// includes bypassing `frame_system::Config::BaseCallFilter`).

		///

		/// ## Complexity

		/// - O(C) where C is the number of calls to be batched.

		#[pallet::call_index(4)]

		#[pallet::weight({

			let dispatch_weight = dispatch_infos.iter()

				.saturating_add(T::WeightInfo::force_batch(calls.len() as u32));

			let dispatch_class = {

				let all_operational = dispatch_infos.iter()

				if all_operational {

					DispatchClass::Operational

				} else {

					DispatchClass::Normal

				}

			};

			(dispatch_weight, dispatch_class)

		})]

		pub fn force_batch(

			origin: OriginFor<T>,

			calls: Vec<<T as Config>::RuntimeCall>,

			// Track the actual weight of each of the batch calls.

				// If origin is root, don't apply any dispatch filters; root can call anything.

				} else {

				};

				// Add the weight of this call.

			}

		}

		/// Dispatch a function call with a specified weight.

		///

		/// This function does not check the weight of the call, and instead allows the

		/// Root origin to specify the weight of the call.

		///

		/// The dispatch origin for this call must be _Root_.

		#[pallet::call_index(5)]

		#[pallet::weight((*weight, call.get_dispatch_info().class))]

		pub fn with_weight(

			origin: OriginFor<T>,

			call: Box<<T as Config>::RuntimeCall>,

			weight: Weight,

			let _ = weight; // Explicitly don't check the the weight witness.

		}

	}

}

/// A pallet identifier. These are per pallet and should be stored in a registry somewhere.

#[derive(Clone, Copy, Eq, PartialEq, Encode, Decode)]

struct IndexedUtilityPalletId(u16);

impl TypeId for IndexedUtilityPalletId {

	const TYPE_ID: [u8; 4] = *b"suba";

}

impl<T: Config> Pallet<T> {

	/// Derive a derivative account ID from the owner account and the sub-account index.

}