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

//! # Inflation Rewards Pallet

//!

//! This pallet handle native token inflation and rewards distribution.

//!

//! Inflation is minted once in `on_initialize`, using

//! `T::Currency::issue(T::InflationRate::get() * T::Currency::total_issuance());`.

//!

//! Note that this is `Perbill` `Mul`, so it rounds to the nearest integer.

//! Search for `rational_mul_correction` in polkadot-sdk for more info.

//!

//! Then, the inflation is split into 2 parts based on `T::RewardsPortion::get()`.

//! The rewards portion is transferred first to `T::PendingRewardsAccount` in `on_initialize`,

//! and then to each collator in `on_container_authors_noted`. If a chain doesn't produce blocks,

//! the reward stays in that account and is transferred to `T::OnUnbalanced` on the next block

//! `on_initialize`.

//!

//! The `T::OnUnbalanced` handles inflation that doesn't go to block rewards, this is usually the

//! parachain bond account.

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

extern crate alloc;

pub use pallet::*;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

use tp_traits::BlockNumber;

use {

    alloc::vec::Vec,

    dp_core::ParaId,

    frame_support::{

        pallet_prelude::*,

        traits::{

            fungible::{Balanced, Credit, Inspect},

            tokens::{Fortitude, Precision, Preservation},

            Imbalance, OnUnbalanced,

        },

    },

    frame_system::pallet_prelude::*,

    sp_runtime::{

        traits::{Get, Saturating, Zero},

        Perbill,

    },

    tp_traits::{

        AuthorNotingHook, AuthorNotingInfo, DistributeRewards, ForSession,

        GetContainerChainsWithCollators, MaybeSelfChainBlockAuthor,

    },

};

#[frame_support::pallet]

pub mod pallet {

    use super::*;

    pub type BalanceOf<T> =

        <<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;

    pub type CreditOf<T> = Credit<<T as frame_system::Config>::AccountId, <T as Config>::Currency>;

    /// Inflation rewards pallet.

    #[pallet::pallet]

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

    #[pallet::hooks]

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

            // Collect indistributed rewards, if any

            // Any parachain we have not rewarded is handled by onUnbalanced

                    // Collect and sum all undistributed rewards

                    )

                } else {

                };

            // Get the number of chains at this block (container chain blocks)

            // Convert to BoundedBTreeSet. If the number of chains is greater than the limit, truncate

            // and emit a warning. This should never happen because we assume that

            // MaxContainerChains has the same value in all the pallets, but that's not enforced.

            // A better solution would be for container_chains_with_collators to return an already

            // bounded data structure.

            );

            // We only add 1 extra chain to number_of_chains if we are

            // in a parachain context with an orchestrator configured.

            // Only create new supply and rewards if number_of_chains is not zero.

                // Issue new supply

                // Split staking reward portion

                        // This is unreachable because we checked `number_of_chains.is_zero()` above

                // rewards_credit must be a multiple of number_of_chains, because the reward is split

                // evenly between all chains. So take the remainder (total_rewards % number_of_chains)

                // and move it to total_remainder, like this:

                // total_remainder = reminder_credit + (total_rewards % number_of_chains)

                // staking_rewards = rewards_credit - (total_rewards % number_of_chains)

                // This guarantees that `staking_rewards - rewards_per_chain * number_of_chains == 0`

                // Deposit the new supply dedicated to rewards in the pending rewards account

                // Keep track of chains to reward

                // Let the runtime handle the non-staking part, plus the non distributed rewards

                // from the previous block, plus the dust from total_rewards % number_of_chains.

                // We don't reward the orchestrator in solochain mode

    }

    #[pallet::config]

    pub trait Config: frame_system::Config {

        type Currency: Inspect<Self::AccountId> + Balanced<Self::AccountId>;

        /// Get container chains with collators. The number of chains returned affects inflation:

        /// we mint tokens to reward the collator of each chain.

        type ContainerChains: GetContainerChainsWithCollators<Self::AccountId>;

        /// Hard limit on number of container chains with collators. Used to define bounded storage.

        type MaxContainerChains: Get<u32>;

        /// Get block author for self chain

        type GetSelfChainBlockAuthor: MaybeSelfChainBlockAuthor<Self::AccountId>;

        /// Inflation rate per orchestrator block (proportion of the total issuance)

        #[pallet::constant]

        type InflationRate: Get<Perbill>;

        /// What to do with the new supply not dedicated to staking

        type OnUnbalanced: OnUnbalanced<CreditOf<Self>>;

        /// The account that will store rewards waiting to be paid out

        #[pallet::constant]

        type PendingRewardsAccount: Get<Self::AccountId>;

        /// Staking rewards distribution implementation

        type StakingRewardsDistributor: DistributeRewards<Self::AccountId, CreditOf<Self>>;

        /// Proportion of the new supply dedicated to staking

        #[pallet::constant]

        type RewardsPortion: Get<Perbill>;

    }

    #[pallet::event]

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

    pub enum Event<T: Config> {

        /// Rewarding orchestrator author

        RewardedOrchestrator {

            account_id: T::AccountId,

            balance: BalanceOf<T>,

        },

        /// Rewarding container author

        RewardedContainer {

            account_id: T::AccountId,

            para_id: ParaId,

            balance: BalanceOf<T>,

        },

    }

    /// Container chains to reward per block.

    /// This gets initialized to the list of chains that should be producing blocks.

    /// Then, in the `set_latest_author_data` inherent, the chains that actually have produced

    /// blocks are rewarded and removed from this list, in the `on_container_authors_noted` hook.

    /// Chains that have not produced blocks stay in this list, and their rewards get accumulated as

    /// `not_distributed_rewards` and handled by `OnUnbalanced` in the next block `on_initialize`.

    #[pallet::storage]

    pub(super) type ChainsToReward<T: Config> =

        StorageValue<_, ChainsToRewardValue<T>, OptionQuery>;

    #[derive(

        Clone, Encode, Decode, PartialEq, sp_core::RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen,

    )]

    #[scale_info(skip_type_params(T))]

    pub struct ChainsToRewardValue<T: Config> {

        pub para_ids: BoundedBTreeSet<ParaId, <T as Config>::MaxContainerChains>,

        pub rewards_per_chain: BalanceOf<T>,

    }

    impl<T: Config> Pallet<T> {

                )

                    }

                    }

                }

            } else {

            }

    }

}

// This function should only be used to **reward** a container author.

// There will be no additional check other than checking if we have already

// rewarded this author for **in this tanssi block**

// Any additional check should be done in the calling function

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

        // We take chains to reward, to see what containers are left to reward

                // If we find the para id is because we still have not rewarded it

                // this makes sure we dont reward it twice in the same block

                    // we distribute rewards to the author

                    )

                        }

                        }

                    }

                } else {

                    // para id not found in list, either

                    // * tried to reward a chain that doesn't have any collators assigned

                    // * tried to reward the same chain twice in the same block

                }

            }

            // Keep track of chains to reward

        } else {

            // Unreachable because we always write ChainsToReward in on_initialize

        }

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

    fn prepare_worst_case_for_bench(a: &T::AccountId, _b: BlockNumber, para_id: ParaId) {

        // arbitrary amount to perform rewarding

        // we mint twice as much to the rewards account to make it possible

        let reward_amount = 1_000_000_000u32;

        let mint = reward_amount.saturating_mul(2);

        T::Currency::resolve(

            &T::PendingRewardsAccount::get(),

            T::Currency::issue(BalanceOf::<T>::from(mint)),

        )

        .expect("to mint tokens");

        // TODO: this API doesn't make sense, we want to add a para id to the list of chains to

        // reward. So change `prepare_worst_case_for_bench` into something that takes a list

        let old_para_ids: alloc::vec::Vec<_> = ChainsToReward::<T>::get()

            .map(|x| x.para_ids.into_iter().collect())

            .unwrap_or_default();

        ChainsToReward::<T>::put(ChainsToRewardValue {

            para_ids: alloc::collections::BTreeSet::from_iter(

                old_para_ids.into_iter().chain([para_id]),

            )

            .try_into()

            .expect("to be in bound"),

            rewards_per_chain: BalanceOf::<T>::from(reward_amount),

        });

        T::StakingRewardsDistributor::prepare_worst_case_for_bench(a);

    }

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

    fn bench_advance_block() {

        T::StakingRewardsDistributor::bench_advance_block()

    }

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

    fn bench_execute_pending() {

        T::StakingRewardsDistributor::bench_execute_pending()

    }

}

/// Convert a `BoundedVec` into a `BoundedBTreeSet` with the same bound.

// TODO: upstream this into BoundedVec crate