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

#![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 {

    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, GetCurrentContainerChains,

        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 (tanssi + container chain blocks)

            // TODO: this should be container_chains_with_collators to match author_noting

            // With the current impl we mint tokens for chains that don't have collators assigned

            // in the case where there aren't enough collators for all chains.

            // Or maybe that's desired, because it makes inflation depend on number of registered

            // chains.

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

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

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

        type ContainerChains: GetCurrentContainerChains;

        /// 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::ContainerChains as GetCurrentContainerChains>::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 index 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

                        }

                        }

                    }

            }

            // Keep track of chains to reward

        } else {

            // Should never happen because `AuthorNotingInfo` is created from the same list of

            // para_ids as the one we use in pallet_inflation_rewards::OnInitialize, so they cannot

            // mismatch.

            // TODO: actually it is not the same list, but the author_noting list is a subset of

            // this one, so the warning cannot happen. See TODO in this pallet 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");

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

            para_ids: alloc::collections::BTreeSet::from_iter([para_id])

                .try_into()

                .expect("to be in bound"),

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

        });

    }

}

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

// TODO: upstream this into BoundedVec crate