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

//! # Inactivity Tracking Pallet

//!

//! This pallet tracks and stores the activity of container chain and orchestrator chain collators

//! for configurable number of sessions. It is used to determine if a collator is inactive

//! for that period of time.

//!

//! The tracking functionality can be enabled or disabled with root privileges.

//! By default, the tracking is enabled.

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

extern crate alloc;

use {

    alloc::collections::btree_set::BTreeSet,

    frame_support::{

        dispatch::DispatchResult, dispatch::DispatchResultWithPostInfo, ensure,

        pallet_prelude::Weight,

    },

    parity_scale_codec::{Decode, Encode},

    scale_info::TypeInfo,

    serde::{Deserialize, Serialize},

    sp_core::{MaxEncodedLen, RuntimeDebug},

    sp_runtime::{traits::Get, BoundedBTreeSet},

    sp_staking::SessionIndex,

    tp_traits::{

        AuthorNotingHook, AuthorNotingInfo, ForSession, GetContainerChainsWithCollators,

        GetSessionIndex, InvulnerablesHelper, MaybeSelfChainBlockAuthor,

        NodeActivityTrackingHelper, ParaId, ParathreadHelper, StakingCandidateHelper,

    },

};

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmarking;

pub mod weights;

pub use weights::WeightInfo;

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

use tp_traits::BlockNumber;

pub mod migrations;

pub use pallet::*;

#[frame_support::pallet]

pub mod pallet {

    use {

        super::*,

        crate::weights::WeightInfo,

        alloc::collections::btree_set::BTreeSet,

        core::marker::PhantomData,

        frame_support::{pallet_prelude::*, storage::types::StorageMap},

        frame_system::pallet_prelude::*,

    };

    pub type Collator<T> = <T as frame_system::Config>::AccountId;

    /// The status of collator activity tracking

    #[derive(

        Clone,

        PartialEq,

        Eq,

        Encode,

        DecodeWithMemTracking,

        Decode,

        TypeInfo,

        Serialize,

        Deserialize,

        RuntimeDebug,

        MaxEncodedLen,

    )]

    pub enum ActivityTrackingStatus {

        Enabled {

            /// The session in which we will start recording the collator activity after enabling it

            start: SessionIndex,

            /// The session after which the activity tracking can be disabled

            end: SessionIndex,

        },

        Disabled {

            /// The session after which the activity tracking can be enabled

            end: SessionIndex,

        },

    }

    /// The offline status of a collator

    #[derive(

        Clone,

        PartialEq,

        Eq,

        Encode,

        DecodeWithMemTracking,

        Decode,

        TypeInfo,

        Serialize,

        Deserialize,

        RuntimeDebug,

        MaxEncodedLen,

    )]

    pub enum OfflineStatus {

        Disabled,

        Notified {

            /// The session in which the collator can become online again

            cooldown_end: SessionIndex,

        },

    }

    impl Default for ActivityTrackingStatus {

    }

    #[pallet::pallet]

    pub struct Pallet<T>(PhantomData<T>);

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// The maximum number of sessions for which a collator can be inactive

        /// before being moved to the offline queue

        #[pallet::constant]

        type MaxInactiveSessions: Get<u32>;

        /// The maximum amount of collators that can be stored for a session

        #[pallet::constant]

        type MaxCollatorsPerSession: Get<u32>;

        /// The maximum amount of container chains that can be stored

        #[pallet::constant]

        type MaxContainerChains: Get<u32>;

        /// Helper that returns the current session index.

        type CurrentSessionIndex: GetSessionIndex<SessionIndex>;

        /// Helper that fetches a list of collators eligible to produce blocks for the current session

        type CurrentCollatorsFetcher: GetContainerChainsWithCollators<Collator<Self>>;

        /// Helper that returns the block author for the orchestrator chain (if it exists)

        type GetSelfChainBlockAuthor: MaybeSelfChainBlockAuthor<Collator<Self>>;

        /// Helper that checks if a ParaId is a parathread

        type ParaFilter: ParathreadHelper;

        /// Helper for dealing with invulnerables.

        type InvulnerablesFilter: InvulnerablesHelper<Collator<Self>>;

        /// Helper for dealing with collator's stake

        type CollatorStakeHelper: StakingCandidateHelper<Collator<Self>>;

        /// The cooldown period length in sessions when a collator is notified as inactive.

        #[pallet::constant]

        type CooldownLength: Get<u32>;

        /// The weight information of this pallet.

        type WeightInfo: weights::WeightInfo;

    }

    /// Switch to enable/disable activity tracking

    #[pallet::storage]

    pub type CurrentActivityTrackingStatus<T: Config> =

        StorageValue<_, ActivityTrackingStatus, ValueQuery>;

    /// A storage map of inactive collators for a session

    #[pallet::storage]

    pub type InactiveCollators<T: Config> = StorageMap<

        _,

        Twox64Concat,

        SessionIndex,

        BoundedBTreeSet<Collator<T>, T::MaxCollatorsPerSession>,

        ValueQuery,

    >;

    /// A list of active collators for a session. Repopulated at the start of every session

    #[pallet::storage]

    pub type ActiveCollatorsForCurrentSession<T: Config> =

        StorageValue<_, BoundedBTreeSet<Collator<T>, T::MaxCollatorsPerSession>, ValueQuery>;

    /// A list of active container chains for a session. Repopulated at the start of every session

    #[pallet::storage]

    pub type ActiveContainerChainsForCurrentSession<T: Config> =

        StorageValue<_, BoundedBTreeSet<ParaId, T::MaxContainerChains>, ValueQuery>;

    /// Switch to enable/disable offline marking.

    #[pallet::storage]

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

    /// Storage map indicating the offline status of a collator

    #[pallet::storage]

    pub type OfflineCollators<T: Config> =

        StorageMap<_, Blake2_128Concat, Collator<T>, OfflineStatus, OptionQuery>;

    #[pallet::event]

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

    pub enum Event<T: Config> {

        /// Event emitted when the activity tracking status is updated

        ActivityTrackingStatusSet { status: ActivityTrackingStatus },

        /// Collator online status updated

        CollatorStatusUpdated {

            collator: Collator<T>,

            is_offline: bool,

        },

    }

    #[pallet::error]

    pub enum Error<T> {

        /// The size of a collator set for a session has already reached MaxCollatorsPerSession value

        MaxCollatorsPerSessionReached,

        /// Error returned when the activity tracking status is attempted to be updated before the end session

        ActivityTrackingStatusUpdateSuspended,

        /// Error returned when the activity tracking status is attempted to be enabled when it is already enabled

        ActivityTrackingStatusAlreadyEnabled,

        /// Error returned when the activity tracking status is attempted to be disabled when it is already disabled

        ActivityTrackingStatusAlreadyDisabled,

        /// Error returned when the collator status is attempted to be set to offline when offline marking is disabled

        MarkingOfflineNotEnabled,

        /// Error returned when the collator is not part of the sorted eligible candidates list

        CollatorNotEligibleCandidate,

        /// Error returned when the collator status is attempted to be set to offline when it is already offline

        CollatorNotOnline,

        /// Error returned when the collator status is attempted to be set to offline when it has already been notified as offline

        CollatorAlreadyNotifiedOffline,

        /// Error returned when the collator status is attempted to be set to online before its cooldown period is over

        CollatorNotReadyToBeOnline,

        /// Error returned when the collator status is attempted to be set to online when it is already online

        CollatorNotOffline,

        /// Error returned when the collator attempted to be set offline is invulnerable

        MarkingInvulnerableOfflineInvalid,

        /// Error returned when the collator attempted to be set offline is not inactive

        CollatorCannotBeNotifiedAsInactive,

    }

    #[pallet::call]

    impl<T: Config> Pallet<T> {

        /// Enables or disables inactivity tracking.

        #[pallet::call_index(0)]

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

        pub fn set_inactivity_tracking_status(

            origin: OriginFor<T>,

            enable_inactivity_tracking: bool,

                    );

                }

                    );

                }

            };

            );

            );

        }

        /// Enables or disables the marking of collators as offline.

        #[pallet::call_index(1)]

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

        }

        /// Allows a collator to mark itself offline.

        #[pallet::call_index(2)]

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

        #[allow(clippy::useless_conversion)]

        }

        /// Allows a collator to mark itself online.

        #[pallet::call_index(3)]

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

        #[allow(clippy::useless_conversion)]

        }

        /// Allows an account to notify inactive collator to be marked offline.

        #[pallet::call_index(4)]

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

        #[allow(clippy::useless_conversion)]

        pub fn notify_inactive_collator(

            origin: OriginFor<T>,

            collator: Collator<T>,

            );

        }

    }

    #[pallet::hooks]

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

            // Process the orchestrator chain block author (if it exists) and activity tracking is enabled

            {

                {

    }

    impl<T: Config> Pallet<T> {

        /// Internal function to set the activity tracking status and

        /// clear ActiveCollatorsForCurrentSession if disabled

            } else {

            };

        /// Internal function to clear the active collators for the current session

        /// and remove the collators records that are outside the activity period.

        /// Triggered at the beginning of each session.

            // Cleanup active collator info for sessions that are older than the maximum allowed

        /// Internal function to populate the inactivity tracking storage used for marking collator

        /// as inactive. Triggered at the end of a session.

                }

            }

        /// Internal function to populate the current session active collator records with collators

        /// part of inactive chains.

                }

            }

            // Removing the parathreads for the current session from the active chains array.

            // In this way we handle all parathreads as inactive chains.

            // This solution would only work if a collator either:

            // - is assigned to one chain only

            // - is assigned to multiple chains but all of them are parathreads

                        );

                            // Collators assigned to inactive chain are added

                            // to the current active collators storage

                                    // If we reach MaxCollatorsPerSession limit there must be a bug in the pallet

                                    // so we disable the activity tracking

                                        false,

                                    );

                            }

                    }

            );

        /// Internal update the current session active collator records.

        /// This function is called when a container chain or orchestrator chain collator is noted.

                {

                    }

                }

                Ok(_) => {

                }

                Err(_) => {

                    );

                    // If we reach MaxCollatorsPerSession limit there must be a bug in the pallet

                    // so we disable the activity tracking

                        false,

                    );

                }

            }

        /// Internal update the current session active chains records.

        /// This function is called when a container chain is noted.

                    }

                }

                Err(_) => {

                    // If we reach MaxContainerChains limit there must be a bug in the pallet

                    // so we disable the activity tracking

                    );

                        false,

                    );

                }

            }

        /// Internal function to mark a collator as offline.

            );

            );

            );

                    );

                    );

                }

                None => {

                    );

                }

            }

            // Updates the SortedEligibleCandidates list. Has to be called after the collator is marked offline.

        /// Internal function to mark a collator as online.

            );

            );

            // Updates the SortedEligibleCandidates list. Has to be called after the collator is marked online.

        /// Internal function helping to check if a collator is ready to be marked online

        /// based on its offline status.

                }

            }

    }

}

impl<T: Config> NodeActivityTrackingHelper<Collator<T>> for Pallet<T> {

        // If inactivity tracking is not enabled all nodes are considered active.

        // We don't need to check the activity records and can return false

        // Inactivity tracking is not enabled if

        // - the status is disabled

        // - the CurrentSessionIndex < start session + MaxInactiveSessions index since there won't be

        // sufficient activity records to determine inactivity

            }

        }

        }

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

    fn make_node_online(node: &Collator<T>) {

        let _ = Self::mark_collator_online(node);

    }

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

    fn make_node_inactive(node: &Collator<T>) {

        // First we need to make sure that eniugh sessions had pass

        // so the node can be marked as inactive

        let max_inactive_sessions = T::MaxInactiveSessions::get();

        if T::CurrentSessionIndex::session_index() < max_inactive_sessions {

            T::CurrentSessionIndex::skip_to_session(max_inactive_sessions)

        }

        // Now we can insert the node as inactive for all sessions in the current inactivity window

        let mut inactive_nodes_set: BoundedBTreeSet<

            Collator<T>,

            <T as Config>::MaxCollatorsPerSession,

        > = BoundedBTreeSet::new();

        let _ = inactive_nodes_set.try_insert(node.clone());

        for session_index in 0..max_inactive_sessions {

            <InactiveCollators<T>>::insert(session_index, inactive_nodes_set.clone());

        }

    }

}

impl<T: Config> AuthorNotingHook<Collator<T>> for Pallet<T> {

        {

                        |AuthorNotingInfo {

                             author, para_id, ..

                    )

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

    fn prepare_worst_case_for_bench(_a: &Collator<T>, _b: BlockNumber, _para_id: ParaId) {}

}