// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! ExternalValidators pallet.

//!

//! A pallet to manage external validators for a solochain.

//!

//! ## Terminology

//!

//! - WhitelistedValidators: Fixed validators set by root/governance. Have priority over the external validators.

//!      Are not rewarded.

//! - ExternalValidators: Validators set using storage proofs from another blockchain. Can be disabled by setting

//!     `SkipExternalValidators` to true.

//!

//! Validators only change once per era. By default the era changes after a fixed number of sessions, but new eras

//! can be forced or disabled using a root extrinsic.

//!

//! The structure of this pallet and the concept of eras is inspired by `pallet_staking` from Polkadot.

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

pub use pallet::*;

use {

    frame_support::pallet_prelude::Weight,

    log::log,

    parity_scale_codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen},

    scale_info::TypeInfo,

    sp_runtime::{traits::Get, RuntimeDebug},

    sp_staking::SessionIndex,

    sp_std::{collections::btree_set::BTreeSet, vec::Vec},

    tp_traits::{

        ActiveEraInfo, EraIndex, EraIndexProvider, ExternalIndexProvider, InvulnerablesProvider,

        OnEraEnd, OnEraStart, ValidatorProvider,

    },

};

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmarking;

pub mod weights;

pub mod pallet {

    pub use crate::weights::WeightInfo;

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

    use frame_support::traits::Currency;

    use {

        super::*,

        frame_support::{

            pallet_prelude::*,

            traits::{EnsureOrigin, UnixTime, ValidatorRegistration},

            BoundedVec, DefaultNoBound,

        },

        frame_system::pallet_prelude::*,

        sp_runtime::{traits::Convert, SaturatedConversion},

        sp_std::vec::Vec,

    };

    /// Configure the pallet by specifying the parameters and types on which it depends.

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// Overarching event type.

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

        /// Origin that can dictate updating parameters of this pallet.

        type UpdateOrigin: EnsureOrigin<Self::RuntimeOrigin>;

        /// Number of eras to keep in history.

        ///

        /// Following information is kept for eras in `[current_era -

        /// HistoryDepth, current_era]`: `ErasStartSessionIndex`

        ///

        /// Must be more than the number of eras delayed by session.

        /// I.e. active era must always be in history. I.e. `active_era >

        /// current_era - history_depth` must be guaranteed.

        ///

        /// If migrating an existing pallet from storage value to config value,

        /// this should be set to same value or greater as in storage.

        #[pallet::constant]

        type HistoryDepth: Get<u32>;

        /// Maximum number of whitelisted validators.

        #[pallet::constant]

        type MaxWhitelistedValidators: Get<u32>;

        /// Maximum number of external validators.

        #[pallet::constant]

        type MaxExternalValidators: Get<u32>;

        /// A stable ID for a validator.

        type ValidatorId: Member

            + Parameter

            + Ord

            + MaybeSerializeDeserialize

            + MaxEncodedLen

            + TryFrom<Self::AccountId>;

        /// A conversion from account ID to validator ID.

        ///

        /// Its cost must be at most one storage read.

        type ValidatorIdOf: Convert<Self::AccountId, Option<Self::ValidatorId>>;

        /// Validate a user is registered

        type ValidatorRegistration: ValidatorRegistration<Self::ValidatorId>;

        /// Time used for computing era duration.

        ///

        /// It is guaranteed to start being called from the first `on_finalize`. Thus value at

        /// genesis is not used.

        type UnixTime: UnixTime;

        /// Number of sessions per era.

        #[pallet::constant]

        type SessionsPerEra: Get<SessionIndex>;

        type OnEraStart: OnEraStart;

        type OnEraEnd: OnEraEnd;

        /// The weight information of this pallet.

        type WeightInfo: WeightInfo;

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

        type Currency: Currency<Self::AccountId>

            + frame_support::traits::fungible::Balanced<Self::AccountId>;

    }

    pub struct Pallet<T>(_);

    /// Fixed validators set by root/governance. Have priority over the external validators.

    pub type WhitelistedValidators<T: Config> =

        StorageValue<_, BoundedVec<T::ValidatorId, T::MaxWhitelistedValidators>, ValueQuery>;

    /// Copy of `WhitelistedValidators` at the start of this active era.

    /// Used to check which validators we don't need to reward.

    pub type WhitelistedValidatorsActiveEra<T: Config> =

        StorageValue<_, BoundedVec<T::ValidatorId, T::MaxWhitelistedValidators>, ValueQuery>;

    /// Same as `WhitelistedValidatorsActiveEra` but only exists for a brief period of time when the

    /// next era has been planned but not enacted yet.

    pub type WhitelistedValidatorsActiveEraPending<T: Config> =

        StorageValue<_, BoundedVec<T::ValidatorId, T::MaxWhitelistedValidators>, ValueQuery>;

    /// Validators set using storage proofs from another blockchain. Ignored if `SkipExternalValidators` is true.

    pub type ExternalValidators<T: Config> =

        StorageValue<_, BoundedVec<T::ValidatorId, T::MaxExternalValidators>, ValueQuery>;

    /// Allow to disable external validators.

    pub type SkipExternalValidators<T: Config> = StorageValue<_, bool, ValueQuery>;

    /// The current era information, it is either ActiveEra or ActiveEra + 1 if the new era validators have been queued.

    pub type CurrentEra<T: Config> = StorageValue<_, EraIndex>;

    /// The active era information, it holds index and start.

    pub type ActiveEra<T: Config> = StorageValue<_, ActiveEraInfo>;

    /// The session index at which the era start for the last [`Config::HistoryDepth`] eras.

    ///

    /// Note: This tracks the starting session (i.e. session index when era start being active)

    /// for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.

    pub type ErasStartSessionIndex<T> = StorageMap<_, Twox64Concat, EraIndex, SessionIndex>;

    /// Mode of era forcing.

    pub type ForceEra<T> = StorageValue<_, Forcing, ValueQuery>;

    /// Latest received external index. This index can be a timestamp

    /// a set-id, an epoch or in general anything that identifies

    /// a particular set of validators selected at a given point in time

    pub type ExternalIndex<T> = StorageValue<_, u64, ValueQuery>;

    /// Pending external index to be applied in the upcoming era

    pub type PendingExternalIndex<T> = StorageValue<_, u64, ValueQuery>;

    /// Current external index attached to the latest validators

    pub type CurrentExternalIndex<T> = StorageValue<_, u64, ValueQuery>;

    #[pallet::genesis_config]

    #[derive(DefaultNoBound)]

    pub struct GenesisConfig<T: Config> {

        pub skip_external_validators: bool,

        pub whitelisted_validators: Vec<T::ValidatorId>,

        pub external_validators: Vec<T::ValidatorId>,

    }

    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

            );

    }

    pub enum Event<T: Config> {

        /// A new whitelisted validator was added.

        WhitelistedValidatorAdded { account_id: T::AccountId },

        /// A whitelisted validator was removed.

        WhitelistedValidatorRemoved { account_id: T::AccountId },

        /// A new era has started.

        NewEra { era: EraIndex },

        /// A new force era mode was set.

        ForceEra { mode: Forcing },

        /// External validators were set.

        ExternalValidatorsSet {

            validators: Vec<T::ValidatorId>,

            external_index: u64,

        },

    }

    pub enum Error<T> {

        TooManyWhitelisted,

        AlreadyWhitelisted,

        NotWhitelisted,

        NoKeysRegistered,

        UnableToDeriveValidatorId,

    }

    impl<T: Config> Pallet<T> {

        /// Allow to ignore external validators and use only whitelisted ones.

        ///

        /// The origin for this call must be the `UpdateOrigin`.

        #[pallet::call_index(0)]

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

        }

        /// Add a new account `who` to the list of `WhitelistedValidators`.

        ///

        /// The origin for this call must be the `UpdateOrigin`.

        #[pallet::call_index(1)]

        #[pallet::weight(T::WeightInfo::add_whitelisted(

			T::MaxWhitelistedValidators::get().saturating_sub(1),

		))]

        #[allow(clippy::useless_conversion)]

            // don't let one unprepared validator ruin things for everyone.

        }

        /// Remove an account `who` from the list of `WhitelistedValidators` collators.

        ///

        /// The origin for this call must be the `UpdateOrigin`.

        #[pallet::call_index(2)]

        #[pallet::weight(T::WeightInfo::remove_whitelisted(T::MaxWhitelistedValidators::get()))]

        }

        /// Force when the next era will start. Possible values: next session, never, same as always.

        #[pallet::call_index(3)]

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

        }

        /// Manually set external validators. Should only be needed for tests, validators are set

        /// automatically by the bridge.

        #[pallet::call_index(4)]

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

        pub fn set_external_validators(

            origin: OriginFor<T>,

            validators: Vec<T::ValidatorId>,

            external_index: u64,

        }

    }

    impl<T: Config> Pallet<T> {

        /// Helper to set a new `ForceEra` mode.

        /// Returns validators for the next session. Whitelisted validators first, then external validators.

        /// The returned list is deduplicated, but the order is respected.

        /// If `SkipExternalValidators` is true, this function will ignore external validators.

        /// Plan a new session potentially trigger a new era.

                // Initial era has been set.

                    // Will be set to `NotForcing` again if a new era has been triggered.

                    // Short circuit to `try_trigger_new_era`.

                    // Only go to `try_trigger_new_era` if deadline reached.

                    _ => {

                        // Either `Forcing::ForceNone`,

                        // or `Forcing::NotForcing if era_length < T::SessionsPerEra::get()`.

                    }

                }

                // New era.

            } else {

                // Set initial era.

            }

        /// Start a session potentially starting an era.

            // This is only `Some` when current era has already progressed to the next era, while the

            // active era is one behind (i.e. in the *last session of the active era*, or *first session

            // of the new current era*, depending on how you look at it).

            {

        /// End a session potentially ending an era.

                {

        /// Start a new era. It does:

        /// * Increment `active_era.index`,

        /// * reset `active_era.start`,

        /// * emit `NewEra` event,

        /// * call `OnEraStart` hook,

        /// End era. It does:

        /// * call `OnEraEnd` hook,

        /// Plan a new era.

        ///

        /// * Bump the current era storage (which holds the latest planned era).

        /// * Store start session index for the new planned era.

        /// * Clean old era information.

        ///

        /// Returns the new validator set.

            // Clean old era information.

            // Save whitelisted validators for when the era truly changes (start_era)

        /// Potentially plan a new era.

        ///

        /// In case a new era is planned, the new validator set is returned.

        /// Clear all era information for given era.

    }

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

            // Set the start of the first era.

            // `on_finalize` weight is tracked in `on_initialize`

    }

    impl<T: Config> ExternalIndexProvider for Pallet<T> {

    }

}

/// Keeps only the first instance of each element in the input vec. Respects ordering of elements.

    }

impl<T: Config> pallet_session::SessionManager<T::ValidatorId> for Pallet<T> {

            new_index

        );

}

impl<T: Config> pallet_session::historical::SessionManager<T::ValidatorId, ()> for Pallet<T> {

}

impl<T: Config> EraIndexProvider for Pallet<T> {

}

impl<T: Config> ValidatorProvider<T::ValidatorId> for Pallet<T> {

}

impl<T: Config> InvulnerablesProvider<T::ValidatorId> for Pallet<T> {

}

/// Mode of era-forcing.

#[derive(

    Copy,

    Clone,

    PartialEq,

    Eq,

    Default,

    Encode,

    RuntimeDebug,

    MaxEncodedLen,

)]

pub enum Forcing {

    #[default]

    NotForcing,

    ForceNew,

    ForceNone,

    ForceAlways,

}