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

//! This pallet keep tracks of the validators reward points.

//! Storage will be cleared after a period of time.

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

extern crate alloc;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmarking;

pub mod weights;

pub use pallet::*;

use {

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

    frame_support::traits::{

        fungible::{self, Mutate},

        Defensive, Get, ValidatorSet,

    },

    parity_scale_codec::Encode,

    polkadot_primitives::ValidatorIndex,

    runtime_parachains::session_info,

    snowbridge_core::{ChannelId, TokenId},

    snowbridge_merkle_tree::{merkle_proof, merkle_root, verify_proof, MerkleProof},

    sp_core::H256,

    sp_runtime::traits::{Hash, MaybeEquivalence, Zero},

    sp_staking::SessionIndex,

    tp_bridge::{Command, DeliverMessage, TanssiMessage, TicketInfo, ValidateMessage},

    tp_traits::ExternalIndexProvider,

    xcm::prelude::*,

};

/// Utils needed to generate/verify merkle roots/proofs inside this pallet.

#[derive(Debug, PartialEq, Eq, Clone)]

pub struct EraRewardsUtils {

    pub rewards_merkle_root: H256,

    pub leaves: Vec<H256>,

    pub leaf_index: Option<u64>,

    pub total_points: u128,

}

#[frame_support::pallet]

pub mod pallet {

    pub use crate::weights::WeightInfo;

    use {

        super::*, alloc::collections::btree_map::BTreeMap, frame_support::pallet_prelude::*,

        sp_runtime::Saturating, tp_traits::EraIndexProvider,

    };

    /// The current storage version.

    const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);

    pub type RewardPoints = u32;

    pub type EraIndex = u32;

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// How to fetch the current era info.

        type EraIndexProvider: EraIndexProvider;

        /// For how many eras points are kept in storage.

        #[pallet::constant]

        type HistoryDepth: Get<EraIndex>;

        /// The amount of era points given by backing a candidate that is included.

        #[pallet::constant]

        type BackingPoints: Get<u32>;

        /// The amount of era points given by dispute voting on a candidate.

        #[pallet::constant]

        type DisputeStatementPoints: Get<u32>;

        /// Provider to know how may tokens were inflated (added) in a specific era.

        type EraInflationProvider: Get<u128>;

        /// Provider to retrieve the current external index indetifying the validators

        type ExternalIndexProvider: ExternalIndexProvider;

        type GetWhitelistedValidators: Get<Vec<Self::AccountId>>;

        /// Hashing tool used to generate/verify merkle roots and proofs.

        type Hashing: Hash<Output = H256>;

        /// Validate a message that will be sent to Ethereum.

        type ValidateMessage: ValidateMessage;

        /// Send a message to Ethereum. Needs to be validated first.

        type OutboundQueue: DeliverMessage<

            Ticket = <<Self as pallet::Config>::ValidateMessage as ValidateMessage>::Ticket,

        >;

        /// Currency the rewards are minted in

        type Currency: fungible::Inspect<Self::AccountId, Balance: From<u128>>

            + fungible::Mutate<Self::AccountId>;

        /// Ethereum Sovereign Account where rewards will be minted

        type RewardsEthereumSovereignAccount: Get<Self::AccountId>;

        /// Token Location from the external chain's point of view.

        type TokenLocationReanchored: Get<Location>;

        /// How to convert from a given Location to a specific TokenId.

        type TokenIdFromLocation: MaybeEquivalence<TokenId, Location>;

        /// The weight information of this pallet.

        type WeightInfo: WeightInfo;

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

        type BenchmarkHelper: tp_bridge::TokenChannelSetterBenchmarkHelperTrait;

    }

    #[pallet::pallet]

    #[pallet::storage_version(STORAGE_VERSION)]

    pub struct Pallet<T>(_);

    #[pallet::event]

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

    pub enum Event<T: Config> {

        /// The rewards message was sent correctly.

        RewardsMessageSent {

            message_id: H256,

            rewards_command: Command,

        },

    }

    /// Keep tracks of distributed points per validator and total.

    #[derive(RuntimeDebug, Encode, Decode, PartialEq, Eq, TypeInfo)]

    pub struct EraRewardPoints<AccountId> {

        pub total: RewardPoints,

        pub individual: BTreeMap<AccountId, RewardPoints>,

    }

    impl<AccountId: Ord + sp_runtime::traits::Debug + Parameter> EraRewardPoints<AccountId> {

        // Helper function used to generate the following utils:

        //  - rewards_merkle_root: merkle root corresponding [(validatorId, rewardPoints)]

        //      for the era_index specified.

        //  - leaves: that were used to generate the previous merkle root.

        //  - leaf_index: index of the validatorId's leaf in the previous leaves array (if any).

        //  - total_points: number of total points of the era_index specified.

                        account,

                        era_index

                    );

            }

    }

    impl<AccountId> Default for EraRewardPoints<AccountId> {

    }

    /// Store reward points per era.

    /// Note: EraRewardPoints is actually bounded by the amount of validators.

    #[pallet::storage]

    #[pallet::unbounded]

    pub type RewardPointsForEra<T: Config> =

        StorageMap<_, Twox64Concat, EraIndex, EraRewardPoints<T::AccountId>, ValueQuery>;

    impl<T: Config> Pallet<T> {

        /// Reward validators. Does not check if the validators are valid, caller needs to make sure of that.

            )

    }

    impl<T: Config> tp_traits::OnEraStart for Pallet<T> {

            };

    }

    impl<T: Config> tp_traits::OnEraEnd for Pallet<T> {

            // Will send a ReportRewards message to Ethereum unless:

            // - the reward token is misconfigured

            // - the tokens inflation is 0 (misconfigured inflation)

            // - the total points is 0 (no rewards to distribute)

            // - it fails to mint the tokens in the Ethereum Sovereign Account

            // - the generated message doesn't pass validation

                {

                    {

                    // Validate and deliver the message

                        }

                        }

                    }

                    );

                } else {

                    // Unreachable, this should never happen as we are sending

                    // None as the second param in Self::generate_era_rewards_utils.

                        era_index

                    );

                }

            } else {

            }

    }

}

/// Rewards validators for participating in parachains with era points in pallet-staking.

pub struct RewardValidatorsWithEraPoints<C>(core::marker::PhantomData<C>);

impl<C> RewardValidatorsWithEraPoints<C>

where

    C: pallet::Config + session_info::Config,

    C::ValidatorSet: ValidatorSet<C::AccountId, ValidatorId = C::AccountId>,

{

    /// Reward validators in session with points, but only if they are in the active set.

        {

        };

        // limit rewards to the active validator set

        // Remove whitelisted validators, we don't want to reward them

}

impl<C> runtime_parachains::inclusion::RewardValidators for RewardValidatorsWithEraPoints<C>

where

    C: pallet::Config + runtime_parachains::shared::Config + session_info::Config,

    C::ValidatorSet: ValidatorSet<C::AccountId, ValidatorId = C::AccountId>,

{

}

impl<C> runtime_parachains::disputes::RewardValidators for RewardValidatorsWithEraPoints<C>

where

    C: pallet::Config + session_info::Config,

    C::ValidatorSet: ValidatorSet<C::AccountId, ValidatorId = C::AccountId>,

{

}