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

//! # Configuration Pallet

//!

//! This pallet stores the configuration for an orchestration-collator assignation chain. In

//! particular stores:

//!

//!    - How many collators are taken.

//!    - How many of those collators should be serving the orchestrator chain

//!    - Howe many of those collators should be serving the containerChains

//!

//! All configuration changes are protected behind the root origin

//! CHanges to the configuration are not immeditaly applied, but rather we wait

//! T::SessionDelay to apply these changes

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

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub use weights::WeightInfo;

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

mod benchmarks;

pub use pallet::*;

use {

    frame_support::pallet_prelude::*,

    frame_system::pallet_prelude::*,

    serde::{Deserialize, Serialize},

    sp_runtime::{traits::AtLeast32BitUnsigned, Perbill, Saturating},

    sp_std::prelude::*,

    tp_traits::GetSessionIndex,

};

const LOG_TARGET: &str = "pallet_configuration";

/// All configuration of the runtime with respect to parachains and parathreads.

#[derive(

    Clone,

    Encode,

    Decode,

    PartialEq,

    Serialize,

)]

pub struct HostConfiguration {

    /// Maximum number of collators, in total, including orchestrator and containers

    pub max_collators: u32,

    /// Minimum number of collators to be assigned to orchestrator chain

    pub min_orchestrator_collators: u32,

    /// Maximum number of collators to be assigned to orchestrator chain after all the container chains have been

    /// assigned collators.

    pub max_orchestrator_collators: u32,

    /// How many collators to assign to one container chain

    pub collators_per_container: u32,

    /// Rotate all collators once every n sessions. If this value is 0 means that there is no rotation

    pub full_rotation_period: u32,

    /// How many collators to assign to one parathread

    // TODO: for now we only support 1 collator per parathread because using Aura for consensus conflicts with

    // the idea of being able to create blocks every n slots: if there are 2 collators and we create blocks

    // every 2 slots, 1 collator will create all the blocks.

    pub collators_per_parathread: u32,

    /// How many parathreads can be assigned to one collator

    pub parathreads_per_collator: u32,

    /// Ratio of collators that we expect to be assigned to container chains. Affects fees.

    pub target_container_chain_fullness: Perbill,

    ///  Maximum number of cores that can be allocated to parachains (only applicable for solo chain)

    pub max_parachain_cores_percentage: Option<Perbill>,

}

impl Default for HostConfiguration {

}

/// Enumerates the possible inconsistencies of `HostConfiguration`.

#[derive(Debug)]

pub enum InconsistentError {

    /// `max_orchestrator_collators` is lower than `min_orchestrator_collators`

    MaxCollatorsLowerThanMinCollators,

    /// `min_orchestrator_collators` must be at least 1

    MinOrchestratorCollatorsTooLow,

    /// `max_collators` must be at least 1

    MaxCollatorsTooLow,

    /// Tried to modify an unimplemented parameter

    UnimplementedParameter,

}

impl HostConfiguration {

    /// Checks that this instance is consistent with the requirements on each individual member.

    ///

    /// # Errors

    ///

    /// This function returns an error if the configuration is inconsistent.

    /// Checks that this instance is consistent with the requirements on each individual member.

    ///

    /// # Panics

    ///

    /// This function panics if the configuration is inconsistent.

}

pub mod pallet {

    use tp_traits::GetHostConfiguration;

    use super::*;

    pub struct Pallet<T>(_);

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

    #[pallet::config]

    pub trait Config: frame_system::Config {

        type SessionIndex: parity_scale_codec::FullCodec + TypeInfo + Copy + AtLeast32BitUnsigned;

        // `SESSION_DELAY` is used to delay any changes to Paras registration or configurations.

        // Wait until the session index is 2 larger then the current index to apply any changes,

        // which guarantees that at least one full session has passed before any changes are applied.

        #[pallet::constant]

        type SessionDelay: Get<Self::SessionIndex>;

        type CurrentSessionIndex: GetSessionIndex<Self::SessionIndex>;

        type ForceEmptyOrchestrator: Get<bool>;

        /// Weight information for extrinsics in this pallet.

        type WeightInfo: WeightInfo;

    }

    pub enum Error<T> {

        InvalidNewValue,

    }

    /// The active configuration for the current session.

    pub(crate) type ActiveConfig<T: Config> = StorageValue<_, HostConfiguration, ValueQuery>;

    /// Pending configuration changes.

    ///

    /// This is a list of configuration changes, each with a session index at which it should

    /// be applied.

    ///

    /// The list is sorted ascending by session index. Also, this list can only contain at most

    /// 2 items: for the next session and for the `scheduled_session`.

    // TODO: instead of making this unbounded, we could refactor into a BoundedVec<X, Const<2>>

    // since it can have at most 2 items anyway. But the upstream pallet doesn't do that so low

    // priority.

    #[pallet::unbounded]

    pub(crate) type PendingConfigs<T: Config> =

        StorageValue<_, Vec<(T::SessionIndex, HostConfiguration)>, ValueQuery>;

    /// If this is set, then the configuration setters will bypass the consistency checks. This

    /// is meant to be used only as the last resort.

    pub(crate) type BypassConsistencyCheck<T: Config> = StorageValue<_, bool, ValueQuery>;

    #[pallet::genesis_config]

    #[derive(frame_support::DefaultNoBound)]

    pub struct GenesisConfig<T: Config> {

        pub config: HostConfiguration,

        #[serde(skip)]

        pub _config: sp_std::marker::PhantomData<T>,

    }

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

    }

    impl<T: Config> Pallet<T> {

        #[pallet::call_index(0)]

        #[pallet::weight((

			T::WeightInfo::set_config_with_u32(),

			DispatchClass::Operational,

		))]

        }

        #[pallet::call_index(1)]

        #[pallet::weight((

			T::WeightInfo::set_config_with_u32(),

			DispatchClass::Operational,

		))]

        }

        #[pallet::call_index(2)]

        #[pallet::weight((

			T::WeightInfo::set_config_with_u32(),

			DispatchClass::Operational,

		))]

        }

        #[pallet::call_index(3)]

        #[pallet::weight((

			T::WeightInfo::set_config_with_u32(),

			DispatchClass::Operational,

		))]

        }

        #[pallet::call_index(4)]

        #[pallet::weight((

			T::WeightInfo::set_config_with_u32(),

			DispatchClass::Operational,

		))]

        }

        #[pallet::call_index(5)]

        #[pallet::weight((

        T::WeightInfo::set_config_with_u32(),

        DispatchClass::Operational,

        ))]

        }

        #[pallet::call_index(6)]

        #[pallet::weight((

        T::WeightInfo::set_config_with_u32(),

        DispatchClass::Operational,

        ))]

        }

        #[pallet::call_index(7)]

        #[pallet::weight((

        T::WeightInfo::set_config_with_u32(),

        DispatchClass::Operational,

        ))]

        pub fn set_target_container_chain_fullness(

            origin: OriginFor<T>,

            new: Perbill,

        }

        #[pallet::call_index(8)]

        #[pallet::weight((

        T::WeightInfo::set_config_with_u32(),

        DispatchClass::Operational,

        ))]

        pub fn set_max_parachain_cores_percentage(

            origin: OriginFor<T>,

            new: Option<Perbill>,

        }

        /// Setting this to true will disable consistency checks for the configuration setters.

        /// Use with caution.

        #[pallet::call_index(44)]

        #[pallet::weight((

			T::DbWeight::get().writes(1),

			DispatchClass::Operational,

		))]

        }

    }

    /// A struct that holds the configuration that was active before the session change and optionally

    /// a configuration that became active after the session change.

    pub struct SessionChangeOutcome {

        /// Previously active configuration.

        pub prev_config: HostConfiguration,

        /// If new configuration was applied during the session change, this is the new configuration.

        pub new_config: Option<HostConfiguration>,

    }

    impl<T: Config> Pallet<T> {

        /// Called by the initializer to note that a new session has started.

        ///

        /// Returns the configuration that was actual before the session change and the configuration

        /// that became active after the session change. If there were no scheduled changes, both will

        /// be the same.

                // This should never happen since we schedule configuration changes only into the future

                // sessions and this handler called for each session change.

                    target: LOG_TARGET,

                );

            // We insert future as PendingConfig

        /// Return the session index that should be used for any future scheduled changes.

        /// Forcibly set the active config. This should be used with extreme care, and typically

        /// only when enabling parachains runtime pallets for the first time on a chain which has

        /// been running without them.

        /// This function should be used to update members of the configuration.

        ///

        /// This function is used to update the configuration in a way that is safe. It will check the

        /// resulting configuration and ensure that the update is valid. If the update is invalid, it

        /// will check if the previous configuration was valid. If it was invalid, we proceed with

        /// updating the configuration, giving a chance to recover from such a condition.

        ///

        /// The actual configuration change take place after a couple of sessions have passed. In case

        /// this function is called more than once in a session, then the pending configuration change

        /// will be updated and the changes will be applied at once.

        // NOTE: Explicitly tell rustc not to inline this because otherwise heuristics note the incoming

        // closure making it's attractive to inline. However, in this case, we will end up with lots of

        // duplicated code (making this function to show up in the top of heaviest functions) only for

        // the sake of essentially avoiding an indirect call. Doesn't worth it.

        #[inline(never)]

                // This will emit a warning each configuration update if the consistency check is

                // bypassed. This is an attempt to make sure the bypass is not accidentally left on.

                    target: LOG_TARGET,

                );

                    // Base configuration is consistent and the new configuration is inconsistent.

                    // This means that the value set by the `updater` is invalid and we can return

                    // it as an error.

                        target: LOG_TARGET,

                        e,

                    );

                } else {

                    // The configuration was already broken, so we can as well proceed with the update.

                    // You cannot break something that is already broken.

                    //

                    // That will allow to call several functions and ultimately return the configuration

                    // into consistent state.

                        target: LOG_TARGET,

                    );

                }

            } else {

            };

    }

    impl<T: Config> GetHostConfiguration<T::SessionIndex> for Pallet<T> {

    }

}