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

//! Block resource limits configuration structures.

//!

//! FRAME defines two resources that are limited within a block:

//! - Weight (execution cost/time)

//! - Length (block size)

//!

//! `frame_system` tracks consumption of each of these resources separately for each

//! `DispatchClass`. This module contains configuration object for both resources,

//! which should be passed to `frame_system` configuration when runtime is being set up.

use frame_support::{

	dispatch::{DispatchClass, OneOrMany, PerDispatchClass},

	weights::{constants, Weight},

};

use scale_info::TypeInfo;

use sp_runtime::{traits::Bounded, Perbill, RuntimeDebug};

/// Block length limit configuration.

pub struct BlockLength {

	/// Maximal total length in bytes for each extrinsic class.

	///

	/// In the worst case, the total block length is going to be:

	/// `MAX(max)`

	pub max: PerDispatchClass<u32>,

}

impl Default for BlockLength {

}

impl BlockLength {

	/// Create new `BlockLength` with `max` for every class.

	/// Create new `BlockLength` with `max` for `Operational` & `Mandatory`

	/// and `normal * max` for `Normal`.

				} else {

				}

}

pub struct ValidationErrors {

	pub has_errors: bool,

	#[cfg(feature = "std")]

	pub errors: Vec<String>,

}

macro_rules! error_assert {

	($cond : expr, $err : expr, $format : expr $(, $params: expr )*$(,)*) => {

		if !$cond {

			$err.has_errors = true;

			#[cfg(feature = "std")]

			{ $err.errors.push(format!($format $(, &$params )*)); }

		}

	}

}

/// A result of validating `BlockWeights` correctness.

pub type ValidationResult = Result<BlockWeights, ValidationErrors>;

/// A ratio of `Normal` dispatch class within block, used as default value for

/// `BlockWeight` and `BlockLength`. The `Default` impls are provided mostly for convenience

/// to use in tests.

const DEFAULT_NORMAL_RATIO: Perbill = Perbill::from_percent(75);

/// `DispatchClass`-specific weight configuration.

pub struct WeightsPerClass {

	/// Base weight of single extrinsic of given class.

	pub base_extrinsic: Weight,

	/// Maximal weight of single extrinsic. Should NOT include `base_extrinsic` cost.

	///

	/// `None` indicates that this class of extrinsics doesn't have a limit.

	pub max_extrinsic: Option<Weight>,

	/// Block maximal total weight for all extrinsics of given class.

	///

	/// `None` indicates that weight sum of this class of extrinsics is not

	/// restricted. Use this value carefully, since it might produce heavily oversized

	/// blocks.

	///

	/// In the worst case, the total weight consumed by the class is going to be:

	/// `MAX(max_total) + MAX(reserved)`.

	pub max_total: Option<Weight>,

	/// Block reserved allowance for all extrinsics of a particular class.

	///

	/// Setting to `None` indicates that extrinsics of that class are allowed

	/// to go over total block weight (but at most `max_total` for that class).

	/// Setting to `Some(x)` guarantees that at least `x` weight of particular class

	/// is processed in every block.

	pub reserved: Option<Weight>,

}

/// Block weight limits & base values configuration.

///

/// This object is responsible for defining weight limits and base weight values tracked

/// during extrinsic execution.

///

/// Each block starts with `base_block` weight being consumed right away. Next up the

/// `on_initialize` pallet callbacks are invoked and their cost is added before any extrinsic

/// is executed. This cost is tracked as `Mandatory` dispatch class.

///

/// ```text,ignore

/// |   | `max_block`    |   |

/// |   |                |   |

/// |   |                |   |

/// |   |                |   |

/// |   |                |  #| `on_initialize`

/// |  #| `base_block`   |  #|

/// |NOM|                |NOM|

///  ||\_ Mandatory

///  |\__ Operational

///  \___ Normal

/// ```

///

/// The remaining capacity can be used to dispatch extrinsics. Note that each dispatch class

/// is being tracked separately, but the sum can't exceed `max_block` (except for `reserved`).

/// Below you can see a picture representing full block with 3 extrinsics (two `Operational` and

/// one `Normal`). Each class has it's own limit `max_total`, but also the sum cannot exceed

/// `max_block` value.

///

/// ```text,ignore

///                          -- `Mandatory` limit (unlimited)

/// | # |                 |   |

/// | # | `Ext3`          | - - `Operational` limit

/// |#  | `Ext2`          |-  - `Normal` limit

/// | # | `Ext1`          | # |

/// |  #| `on_initialize` | ##|

/// |  #| `base_block`    |###|

/// |NOM|                 |NOM|

/// ```

///

/// It should be obvious now that it's possible for one class to reach it's limit (say `Normal`),

/// while the block has still capacity to process more transactions (`max_block` not reached,

/// `Operational` transactions can still go in). Setting `max_total` to `None` disables the

/// per-class limit. This is generally highly recommended for `Mandatory` dispatch class, while it

/// can be dangerous for `Normal` class and should only be done with extra care and consideration.

///

/// Often it's desirable for some class of transactions to be added to the block despite it being

/// full. For instance one might want to prevent high-priority `Normal` transactions from pushing

/// out lower-priority `Operational` transactions. In such cases you might add a `reserved` capacity

/// for given class.

///

/// ```test,ignore

///              _

///   #           \

///   #   `Ext8`   - `reserved`

///   #          _/

/// | # | `Ext7                 | - - `Operational` limit

/// |#  | `Ext6`                |   |

/// |#  | `Ext5`                |-# - `Normal` limit

/// |#  | `Ext4`                |## |

/// |  #| `on_initialize`       |###|

/// |  #| `base_block`          |###|

/// |NOM|                       |NOM|

/// ```

///

/// In the above example, `Ext4-6` fill up the block almost up to `max_block`. `Ext7` would not fit

/// if there wasn't the extra `reserved` space for `Operational` transactions. Note that `max_total`

/// limit applies to `reserved` space as well (i.e. the sum of weights of `Ext7` & `Ext8` mustn't

/// exceed it). Setting `reserved` to `None` allows the extrinsics to always get into the block up

/// to their `max_total` limit. If `max_total` is set to `None` as well, all extrinsics witch

/// dispatchables of given class will always end up in the block (recommended for `Mandatory`

/// dispatch class).

///

/// As a consequence of `reserved` space, total consumed block weight might exceed `max_block`

/// value, so this parameter should rather be thought of as "target block weight" than a hard limit.

pub struct BlockWeights {

	/// Base weight of block execution.

	pub base_block: Weight,

	/// Maximal total weight consumed by all kinds of extrinsics (without `reserved` space).

	pub max_block: Weight,

	/// Weight limits for extrinsics of given dispatch class.

	pub per_class: PerDispatchClass<WeightsPerClass>,

}

impl Default for BlockWeights {

}

impl BlockWeights {

	/// Get per-class weight settings.

	/// Verifies correctness of this `BlockWeights` object.

				class, max_for_class, self.base_block, base_for_class,

			);

			// Max extrinsic can't be greater than max_for_class.

			);

			// Max extrinsic should not be 0

				class, weights.max_extrinsic,

			);

			// Make sure that if reserved is set it's greater than base_for_class.

				class,

				reserved,

				base_for_class,

			);

			// Make sure max block is greater than max_total if it's set.

				class,

				self.max_block,

				weights.max_total,

			);

			// Make sure we can fit at least one extrinsic.

			);

		}

		} else {

		}

	/// Create new weights definition, with both `Normal` and `Operational`

	/// classes limited to given weight.

	///

	/// Note there is no reservation for `Operational` class, so this constructor

	/// is not suitable for production deployments.

	/// Create a sensible default weights system given only expected maximal block weight and the

	/// ratio that `Normal` extrinsics should occupy.

	///

	/// Assumptions:

	///  - Average block initialization is assumed to be `10%`.

	///  - `Operational` transactions have reserved allowance (`1.0 - normal_ratio`)

	/// Start constructing new `BlockWeights` object.

	///

	/// By default all kinds except of `Mandatory` extrinsics are disallowed.

}

/// An opinionated builder for `Weights` object.

pub struct BlockWeightsBuilder {

	weights: BlockWeights,

	init_cost: Option<Perbill>,

}

impl BlockWeightsBuilder {

	/// Set base block weight.

	/// Average block initialization weight cost.

	///

	/// This value is used to derive maximal allowed extrinsic weight for each

	/// class, based on the allowance.

	///

	/// This is to make sure that extrinsics don't stay forever in the pool,

	/// because they could seemingly fit the block (since they are below `max_block`),

	/// but the cost of calling `on_initialize` always prevents them from being included.

	/// Set parameters for particular class.

	///

	/// Note: `None` values of `max_extrinsic` will be overwritten in `build` in case

	/// `avg_block_initialization` rate is set to a non-zero value.

	/// Construct the `BlockWeights` object.

		// compute max block size.

			};

		}

		// compute max size of single extrinsic

			}

		// Validate the result

	/// Construct the `BlockWeights` object or panic if it's invalid.

	///

	/// This is a convenience method to be called whenever you construct a runtime.

}

#[cfg(test)]

mod tests {

	use super::*;

	#[test]

	fn default_weights_are_valid() {

		BlockWeights::default().validate().unwrap();

	}

}