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

//! # Referenda Pallet

//!

//! ## Overview

//!

//! A pallet for executing referenda. No voting logic is present here, and the `Polling` and

//! `PollStatus` traits are used to allow the voting logic (likely in a pallet) to be utilized.

//!

//! A referendum is a vote on whether a proposal should be dispatched from a particular origin. The

//! origin is used to determine which one of several _tracks_ that a referendum happens under.

//! Tracks each have their own configuration which governs the voting process and parameters.

//!

//! A referendum's lifecycle has three main stages: Preparation, deciding and conclusion.

//! Referenda are considered "ongoing" immediately after submission until their eventual

//! conclusion, and votes may be cast throughout.

//!

//! In order to progress from preparating to being decided, three things must be in place:

//! - There must have been a *Decision Deposit* placed, an amount determined by the track. Anyone

//! may place this deposit.

//! - A period must have elapsed since submission of the referendum. This period is known as the

//! *Preparation Period* and is determined by the track.

//! - The track must not already be at capacity with referendum being decided. The maximum number of

//! referenda which may be being decided simultaneously is determined by the track.

//!

//! In order to become concluded, one of three things must happen:

//! - The referendum should remain in an unbroken _Passing_ state for a period of time. This

//! is known as the _Confirmation Period_ and is determined by the track. A referendum is considered

//! _Passing_ when there is a sufficiently high support and approval, given the amount of time it

//! has been being decided. Generally the threshold for what counts as being "sufficiently high"

//! will reduce over time. The curves setting these thresholds are determined by the track. In this

//! case, the referendum is considered _Approved_ and the proposal is scheduled for dispatch.

//! - The referendum reaches the end of its deciding phase outside not _Passing_. It ends in

//! rejection and the proposal is not dispatched.

//! - The referendum is cancelled.

//!

//! A general time-out is also in place and referenda which exist in preparation for too long may

//! conclude without ever entering into a deciding stage.

//!

//! Once a referendum is concluded, the decision deposit may be refunded.

//!

//! ## Terms

//! - *Support*: The number of aye-votes, pre-conviction, as a proportion of the total number of

//!   pre-conviction votes able to be cast in the population.

//!

//! - [`Config`]

//! - [`Call`]

#![recursion_limit = "256"]

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

extern crate alloc;

use alloc::boxed::Box;

use codec::{Codec, Encode};

use core::fmt::Debug;

use frame_support::{

	dispatch::DispatchResult,

	ensure,

	traits::{

		schedule::{

			v3::{Anon as ScheduleAnon, Named as ScheduleNamed},

			DispatchTime,

		},

		Currency, LockIdentifier, OnUnbalanced, OriginTrait, PollStatus, Polling, QueryPreimage,

		ReservableCurrency, StorePreimage, VoteTally,

	},

	BoundedVec,

};

use frame_system::pallet_prelude::BlockNumberFor;

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{AtLeast32BitUnsigned, Bounded, Dispatchable, One, Saturating, Zero},

	DispatchError, Perbill,

};

mod branch;

pub mod migration;

mod types;

pub mod weights;

use self::branch::{BeginDecidingBranch, OneFewerDecidingBranch, ServiceBranch};

pub use self::{

	pallet::*,

	types::{

		BalanceOf, BoundedCallOf, CallOf, Curve, DecidingStatus, DecidingStatusOf, Deposit,

		InsertSorted, NegativeImbalanceOf, PalletsOriginOf, ReferendumIndex, ReferendumInfo,

		ReferendumInfoOf, ReferendumStatus, ReferendumStatusOf, ScheduleAddressOf, TallyOf,

		TrackIdOf, TrackInfo, TrackInfoOf, TracksInfo, VotesOf,

	},

	weights::WeightInfo,

};

pub use alloc::vec::Vec;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

#[cfg(feature = "runtime-benchmarks")]

pub mod benchmarking;

pub use frame_support::traits::Get;

#[macro_export]

macro_rules! impl_tracksinfo_get {

	($tracksinfo:ty, $balance:ty, $blocknumber:ty) => {

		impl

			$crate::Get<

				$crate::Vec<(

					<$tracksinfo as $crate::TracksInfo<$balance, $blocknumber>>::Id,

					$crate::TrackInfo<$balance, $blocknumber>,

				)>,

			> for $tracksinfo

		{

		}

	};

}

const ASSEMBLY_ID: LockIdentifier = *b"assembly";

pub mod pallet {

	use super::*;

	use frame_support::{pallet_prelude::*, traits::EnsureOriginWithArg};

	use frame_system::pallet_prelude::*;

	/// The in-code storage version.

	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T, I = ()>(_);

	#[pallet::config]

	pub trait Config<I: 'static = ()>: frame_system::Config + Sized {

		// System level stuff.

		type RuntimeCall: Parameter

			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>

			+ From<Call<Self, I>>

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

			+ From<frame_system::Call<Self>>;

		type RuntimeEvent: From<Event<Self, I>>

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

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

		/// The Scheduler.

		type Scheduler: ScheduleAnon<

				BlockNumberFor<Self>,

				CallOf<Self, I>,

				PalletsOriginOf<Self>,

				Hasher = Self::Hashing,

			> + ScheduleNamed<

				BlockNumberFor<Self>,

				CallOf<Self, I>,

				PalletsOriginOf<Self>,

				Hasher = Self::Hashing,

			>;

		/// Currency type for this pallet.

		type Currency: ReservableCurrency<Self::AccountId>;

		// Origins and unbalances.

		/// Origin from which proposals may be submitted.

		type SubmitOrigin: EnsureOriginWithArg<

			Self::RuntimeOrigin,

			PalletsOriginOf<Self>,

			Success = Self::AccountId,

		>;

		/// Origin from which any vote may be cancelled.

		type CancelOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Origin from which any vote may be killed.

		type KillOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Handler for the unbalanced reduction when slashing a preimage deposit.

		type Slash: OnUnbalanced<NegativeImbalanceOf<Self, I>>;

		/// The counting type for votes. Usually just balance.

		type Votes: AtLeast32BitUnsigned + Copy + Parameter + Member + MaxEncodedLen;

		/// The tallying type.

		type Tally: VoteTally<Self::Votes, TrackIdOf<Self, I>>

			+ Clone

			+ Codec

			+ Eq

			+ Debug

			+ TypeInfo

			+ MaxEncodedLen;

		// Constants

		/// The minimum amount to be used as a deposit for a public referendum proposal.

		#[pallet::constant]

		type SubmissionDeposit: Get<BalanceOf<Self, I>>;

		/// Maximum size of the referendum queue for a single track.

		#[pallet::constant]

		type MaxQueued: Get<u32>;

		/// The number of blocks after submission that a referendum must begin being decided by.

		/// Once this passes, then anyone may cancel the referendum.

		#[pallet::constant]

		type UndecidingTimeout: Get<BlockNumberFor<Self>>;

		/// Quantization level for the referendum wakeup scheduler. A higher number will result in

		/// fewer storage reads/writes needed for smaller voters, but also result in delays to the

		/// automatic referendum status changes. Explicit servicing instructions are unaffected.

		#[pallet::constant]

		type AlarmInterval: Get<BlockNumberFor<Self>>;

		// The other stuff.

		/// Information concerning the different referendum tracks.

		#[pallet::constant]

		type Tracks: Get<

				Vec<(

					<Self::Tracks as TracksInfo<BalanceOf<Self, I>, BlockNumberFor<Self>>>::Id,

					TrackInfo<BalanceOf<Self, I>, BlockNumberFor<Self>>,

				)>,

			> + TracksInfo<

				BalanceOf<Self, I>,

				BlockNumberFor<Self>,

				RuntimeOrigin = <Self::RuntimeOrigin as OriginTrait>::PalletsOrigin,

			>;

		/// The preimage provider.

		type Preimages: QueryPreimage<H = Self::Hashing> + StorePreimage;

	}

	/// The next free referendum index, aka the number of referenda started so far.

	pub type ReferendumCount<T, I = ()> = StorageValue<_, ReferendumIndex, ValueQuery>;

	/// Information concerning any given referendum.

	pub type ReferendumInfoFor<T: Config<I>, I: 'static = ()> =

		StorageMap<_, Blake2_128Concat, ReferendumIndex, ReferendumInfoOf<T, I>>;

	/// The sorted list of referenda ready to be decided but not yet being decided, ordered by

	/// conviction-weighted approvals.

	///

	/// This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.

	pub type TrackQueue<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Twox64Concat,

		TrackIdOf<T, I>,

		BoundedVec<(ReferendumIndex, T::Votes), T::MaxQueued>,

		ValueQuery,

	>;

	/// The number of referenda being decided currently.

	pub type DecidingCount<T: Config<I>, I: 'static = ()> =

		StorageMap<_, Twox64Concat, TrackIdOf<T, I>, u32, ValueQuery>;

	/// The metadata is a general information concerning the referendum.

	/// The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON

	/// dump or IPFS hash of a JSON file.

	///

	/// Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)

	/// large preimages.

	pub type MetadataOf<T: Config<I>, I: 'static = ()> =

		StorageMap<_, Blake2_128Concat, ReferendumIndex, T::Hash>;

	pub enum Event<T: Config<I>, I: 'static = ()> {

		Submitted {

		DecisionDepositPlaced {

		DecisionDepositRefunded {

		DepositSlashed {

		DecisionStarted {

		Confirmed {

		Approved {

		Rejected {

		TimedOut {

		Cancelled {

		Killed {

		SubmissionDepositRefunded {

		MetadataSet {

		MetadataCleared {

	}

	pub enum Error<T, I = ()> {

	}

	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {

		#[cfg(feature = "try-runtime")]

		#[cfg(any(feature = "std", test))]

	}

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Propose a referendum on a privileged action.

		///

		/// - `origin`: must be `SubmitOrigin` and the account must have `SubmissionDeposit` funds

		///   available.

		/// - `proposal_origin`: The origin from which the proposal should be executed.

		/// - `proposal`: The proposal.

		/// - `enactment_moment`: The moment that the proposal should be enacted.

		///

		/// Emits `Submitted`.

		#[pallet::call_index(0)]

		#[pallet::weight(T::WeightInfo::submit())]

		pub fn submit(

			origin: OriginFor<T>,

			proposal_origin: Box<PalletsOriginOf<T>>,

			proposal: BoundedCallOf<T, I>,

			enactment_moment: DispatchTime<BlockNumberFor<T>>,

			// If the pre-image is already stored, ensure that it has the same length as given in

			// `proposal`.

			{

		}

		/// Post the Decision Deposit for a referendum.

		///

		/// - `origin`: must be `Signed` and the account must have funds available for the

		///   referendum's track's Decision Deposit.

		/// - `index`: The index of the submitted referendum whose Decision Deposit is yet to be

		///   posted.

		///

		/// Emits `DecisionDepositPlaced`.

		#[pallet::call_index(1)]

		#[pallet::weight(ServiceBranch::max_weight_of_deposit::<T, I>())]

		pub fn place_decision_deposit(

			origin: OriginFor<T>,

			index: ReferendumIndex,

		}

		/// Refund the Decision Deposit for a closed referendum back to the depositor.

		///

		/// - `origin`: must be `Signed` or `Root`.

		/// - `index`: The index of a closed referendum whose Decision Deposit has not yet been

		///   refunded.

		///

		/// Emits `DecisionDepositRefunded`.

		#[pallet::call_index(2)]

		#[pallet::weight(T::WeightInfo::refund_decision_deposit())]

		pub fn refund_decision_deposit(

			origin: OriginFor<T>,

			index: ReferendumIndex,

		}

		/// Cancel an ongoing referendum.

		///

		/// - `origin`: must be the `CancelOrigin`.

		/// - `index`: The index of the referendum to be cancelled.

		///

		/// Emits `Cancelled`.

		#[pallet::call_index(3)]

		#[pallet::weight(T::WeightInfo::cancel())]

		}

		/// Cancel an ongoing referendum and slash the deposits.

		///

		/// - `origin`: must be the `KillOrigin`.

		/// - `index`: The index of the referendum to be cancelled.

		///

		/// Emits `Killed` and `DepositSlashed`.

		#[pallet::call_index(4)]

		#[pallet::weight(T::WeightInfo::kill())]

		}

		/// Advance a referendum onto its next logical state. Only used internally.

		///

		/// - `origin`: must be `Root`.

		/// - `index`: the referendum to be advanced.

		#[pallet::call_index(5)]

		#[pallet::weight(ServiceBranch::max_weight_of_nudge::<T, I>())]

		pub fn nudge_referendum(

			origin: OriginFor<T>,

			index: ReferendumIndex,

			// This is our wake-up, so we can disregard the alarm.

		}

		/// Advance a track onto its next logical state. Only used internally.

		///

		/// - `origin`: must be `Root`.

		/// - `track`: the track to be advanced.

		///

		/// Action item for when there is now one fewer referendum in the deciding phase and the

		/// `DecidingCount` is not yet updated. This means that we should either:

		/// - begin deciding another referendum (and leave `DecidingCount` alone); or

		/// - decrement `DecidingCount`.

		#[pallet::call_index(6)]

		#[pallet::weight(OneFewerDecidingBranch::max_weight::<T, I>())]

		pub fn one_fewer_deciding(

			origin: OriginFor<T>,

			track: TrackIdOf<T, I>,

				} else {

				};

		}

		/// Refund the Submission Deposit for a closed referendum back to the depositor.

		///

		/// - `origin`: must be `Signed` or `Root`.

		/// - `index`: The index of a closed referendum whose Submission Deposit has not yet been

		///   refunded.

		///

		/// Emits `SubmissionDepositRefunded`.

		#[pallet::call_index(7)]

		#[pallet::weight(T::WeightInfo::refund_submission_deposit())]

		pub fn refund_submission_deposit(

			origin: OriginFor<T>,

			index: ReferendumIndex,

		}

		/// Set or clear metadata of a referendum.

		///

		/// Parameters:

		/// - `origin`: Must be `Signed` by a creator of a referendum or by anyone to clear a

		///   metadata of a finished referendum.

		/// - `index`:  The index of a referendum to set or clear metadata for.

		/// - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.

		#[pallet::call_index(8)]

		#[pallet::weight(

			maybe_hash.map_or(

			)]

		pub fn set_metadata(

			origin: OriginFor<T>,

			index: ReferendumIndex,

			maybe_hash: Option<T::Hash>,

			} else {

			}

		}

	}

}

impl<T: Config<I>, I: 'static> Polling<T::Tally> for Pallet<T, I> {

	type Index = ReferendumIndex;

	type Votes = VotesOf<T, I>;

	type Moment = BlockNumberFor<T>;

	type Class = TrackIdOf<T, I>;

			},

		}

			},

		}

	#[cfg(feature = "runtime-benchmarks")]

	fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()> {

		let index = ReferendumCount::<T, I>::mutate(|x| {

			let r = *x;

			*x += 1;

			r

		});

		let now = frame_system::Pallet::<T>::block_number();

		let dummy_account_id =

			codec::Decode::decode(&mut sp_runtime::traits::TrailingZeroInput::new(&b"dummy"[..]))

				.expect("infinite length input; no invalid inputs for type; qed");

		let mut status = ReferendumStatusOf::<T, I> {

			track: class,

			origin: frame_support::dispatch::RawOrigin::Root.into(),

			proposal: T::Preimages::bound(CallOf::<T, I>::from(Call::nudge_referendum { index }))

				.map_err(|_| ())?,

			enactment: DispatchTime::After(Zero::zero()),

			submitted: now,

			submission_deposit: Deposit { who: dummy_account_id, amount: Zero::zero() },

			decision_deposit: None,

			deciding: None,

			tally: TallyOf::<T, I>::new(class),

			in_queue: false,

			alarm: None,

		};

		Self::ensure_alarm_at(&mut status, index, sp_runtime::traits::Bounded::max_value());

		ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));

		Ok(index)

	}

	#[cfg(feature = "runtime-benchmarks")]

	fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()> {

		let mut status = Self::ensure_ongoing(index).map_err(|_| ())?;

		Self::ensure_no_alarm(&mut status);

		Self::note_one_fewer_deciding(status.track);

		let now = frame_system::Pallet::<T>::block_number();

		let info = if approved {

			ReferendumInfo::Approved(now, Some(status.submission_deposit), status.decision_deposit)

		} else {

			ReferendumInfo::Rejected(now, Some(status.submission_deposit), status.decision_deposit)

		};

		ReferendumInfoFor::<T, I>::insert(index, info);

		Ok(())

	}

	#[cfg(feature = "runtime-benchmarks")]

	fn max_ongoing() -> (Self::Class, u32) {

		let r = T::Tracks::tracks()

			.iter()

			.max_by_key(|(_, info)| info.max_deciding)

			.expect("Always one class");

		(r.0, r.1.max_deciding)

	}

}

impl<T: Config<I>, I: 'static> Pallet<T, I> {

	/// Check that referendum `index` is in the `Ongoing` state and return the `ReferendumStatus`

	/// value, or `Err` otherwise.

		}

	/// Returns whether the referendum is passing.

	/// Referendum must be ongoing and its track must exist.

				} else {

				};

			},

		}

	// Enqueue a proposal from a referendum which has presumably passed.

	/// Set an alarm to dispatch `call` at block number `when`.

		);

	/// Mutate a referendum's `status` into the correct deciding state.

	///

	/// - `now` is the current block number.

	/// - `track` is the track info for the referendum.

	///

	/// This will properly set up the `confirming` item.

		} else {

		};

	/// If it returns `Some`, deciding has begun and it needs waking at the given block number. The

	/// second item is the flag for whether it is confirming or not.

	///

	/// If `None`, then it is queued and should be nudged automatically as the queue gets drained.

			// Begin deciding.

		} else {

			// Add to queue.

		}

	/// Grab the index and status for the referendum which is the highest priority of those for the

	/// given track which are ready for being decided.

		loop {

			}

		}

	/// Schedule a call to `one_fewer_deciding` function via the dispatchable

	/// `defer_one_fewer_deciding`. We could theoretically call it immediately (and it would be

	/// overall more efficient), however the weights become rather less easy to measure.

			Err(_) => {

			},

		};

	/// Ensure that a `service_referendum` alarm happens for the referendum `index` at `alarm`.

	///

	/// This will do nothing if the alarm is already set.

	///

	/// Returns `false` if nothing changed.

			// Either no alarm or one that was different

					Err(_) => {

						);

					},

				};

		} else {

		}

	/// Advance the state of a referendum, which comes down to:

	/// - If it's ready to be decided, start deciding;

	/// - If it's not ready to be decided and non-deciding timeout has passed, fail;

	/// - If it's ongoing and passing, ensure confirming; if at end of confirmation period, pass.

	/// - If it's ongoing and not passing, stop confirming; if it has reached end time, fail.

	///

	/// Weight will be a bit different depending on what it does, but it's designed so as not to

	/// differ dramatically, especially if `MaxQueue` is kept small. In particular _there are no

	/// balance operations in here_.

	///

	/// In terms of storage, every call to it is expected to access:

	/// - The scheduler, either to insert, remove or alter an entry;

	/// - `TrackQueue`, which should be a `BoundedVec` with a low limit (8-16);

	/// - `DecidingCount`.

	///

	/// Both of the two storage items will only have as many items as there are different tracks,

	/// perhaps around 10 and should be whitelisted.

	///

	/// The heaviest branch is likely to be when a proposal is placed into, or moved within, the

	/// `TrackQueue`. Basically this happens when a referendum is in the deciding queue and receives

	/// a vote, or when it moves into the deciding queue.

		// Should it begin being decided?

		};

		// Default the alarm to the end of the world.

			None => {

				// Are we already queued for deciding?

					// Does our position in the queue need updating?

						// Just insert.

						// We were in the queue - slide into the correct position.

					} else {

					};

				} else {

					// Are we ready for deciding?

						} else {

						}

					} else {

					}

				}

				// If we didn't move into being decided, then check the timeout.

					// Too long without being decided - end it.

			},

						},

						None => {

							// Start confirming

						},

					}

				} else {

						// Failed!

						// Stop confirming

					} else {

					}

				};

			},

		}

		} else {

		};

	/// Determine the point at which a referendum will be accepted, move into confirmation with the

	/// given `tally` or end with rejection (whichever happens sooner).

	/// Cancel the alarm in `status`, if one exists.

			// Incorrect alarm - cancel it.

		} else {

		}

	/// Reserve a deposit and return the `Deposit` instance.

	/// Return a deposit, if `Some`.

	/// Slash a deposit, if `Some`.

	/// Get the track info value for the track `id`.

	/// Determine whether the given `tally` would result in a referendum passing at `elapsed` blocks

	/// into a total decision `period`, given the two curves for `support_needed` and

	/// `approval_needed`.

	/// Clear metadata if exist for a given referendum index.

	/// Ensure the correctness of the state of this pallet.

	///

	/// The following assertions must always apply.

	///

	/// General assertions: