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

//! # Services Payment pallet

//!

//! This pallet allows for block creation services to be paid for by a

//! containerChain.

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

extern crate alloc;

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

use tp_traits::BlockNumber;

use {

    cumulus_primitives_core::ParaId,

    frame_support::{

        pallet_prelude::*,

        sp_runtime::{traits::Zero, Saturating},

        traits::{

            tokens::ExistenceRequirement, Currency, EnsureOriginWithArg, OnUnbalanced,

            WithdrawReasons,

        },

    },

    frame_system::pallet_prelude::*,

    scale_info::prelude::vec::Vec,

    serde::{Deserialize, Serialize},

    sp_io::hashing::blake2_256,

    sp_runtime::{traits::TrailingZeroInput, DispatchError},

    tp_traits::{AuthorNotingHook, CollatorAssignmentHook, CollatorAssignmentTip},

};

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

mod benchmarks;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub use weights::WeightInfo;

pub use pallet::*;

use tp_traits::AuthorNotingInfo;

#[frame_support::pallet]

pub mod pallet {

    use super::*;

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// Handlers for fees

        type OnChargeForBlock: OnUnbalanced<NegativeImbalanceOf<Self>>;

        type OnChargeForCollatorAssignment: OnUnbalanced<NegativeImbalanceOf<Self>>;

        type OnChargeForCollatorAssignmentTip: OnUnbalanced<NegativeImbalanceOf<Self>>;

        /// Currency type for fee payment

        type Currency: Currency<Self::AccountId>;

        /// Provider of a block cost which can adjust from block to block

        type ProvideBlockProductionCost: ProvideBlockProductionCost<Self>;

        /// Provider of a block cost which can adjust from block to block

        type ProvideCollatorAssignmentCost: ProvideCollatorAssignmentCost<Self>;

        /// The maximum number of block production credits that can be accumulated

        #[pallet::constant]

        type FreeBlockProductionCredits: Get<BlockNumberFor<Self>>;

        /// The maximum number of collator assigment production credits that can be accumulated

        #[pallet::constant]

        type FreeCollatorAssignmentCredits: Get<u32>;

        /// Owner of the container chain, can call some only-owner methods

        type ManagerOrigin: EnsureOriginWithArg<Self::RuntimeOrigin, ParaId>;

        type WeightInfo: WeightInfo;

    }

    #[pallet::error]

    pub enum Error<T> {

        InsufficientFundsToPurchaseCredits,

        InsufficientCredits,

        CreditPriceTooExpensive,

    }

    #[pallet::pallet]

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

    #[pallet::event]

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

    pub enum Event<T: Config> {

        CreditsPurchased {

            para_id: ParaId,

            payer: T::AccountId,

            credit: BalanceOf<T>,

        },

        BlockProductionCreditBurned {

            para_id: ParaId,

            credits_remaining: BlockNumberFor<T>,

        },

        CollatorAssignmentCreditBurned {

            para_id: ParaId,

            credits_remaining: u32,

        },

        CollatorAssignmentTipCollected {

            para_id: ParaId,

            payer: T::AccountId,

            tip: BalanceOf<T>,

        },

        BlockProductionCreditsSet {

            para_id: ParaId,

            credits: BlockNumberFor<T>,

        },

        RefundAddressUpdated {

            para_id: ParaId,

            refund_address: Option<T::AccountId>,

        },

        MaxCorePriceUpdated {

            para_id: ParaId,

            max_core_price: u128,

        },

        CollatorAssignmentCreditsSet {

            para_id: ParaId,

            credits: u32,

        },

    }

    #[pallet::storage]

    pub type BlockProductionCredits<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, BlockNumberFor<T>, OptionQuery>;

    #[pallet::storage]

    pub type CollatorAssignmentCredits<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, u32, OptionQuery>;

    /// List of para ids that have already been given free credits

    #[pallet::storage]

    pub type GivenFreeCredits<T: Config> = StorageMap<_, Blake2_128Concat, ParaId, (), OptionQuery>;

    /// Refund address

    #[pallet::storage]

    pub type RefundAddress<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, T::AccountId, OptionQuery>;

    /// Max core price for parathread in relay chain currency

    #[pallet::storage]

    pub type MaxCorePrice<T: Config> = StorageMap<_, Blake2_128Concat, ParaId, u128, OptionQuery>;

    /// Max tip for collator assignment on congestion

    #[pallet::storage]

    pub type MaxTip<T: Config> = StorageMap<_, Blake2_128Concat, ParaId, BalanceOf<T>, OptionQuery>;

    #[pallet::call]

    impl<T: Config> Pallet<T>

    where

        BlockNumberFor<T>: Into<BalanceOf<T>>,

    {

        #[pallet::call_index(0)]

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

        #[allow(clippy::useless_conversion)]

        pub fn purchase_credits(

            origin: OriginFor<T>,

            para_id: ParaId,

            credit: BalanceOf<T>,

        }

        /// Set the number of block production credits for this para_id without paying for them.

        /// Can only be called by root.

        #[pallet::call_index(1)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_block_production_credits(

            origin: OriginFor<T>,

            para_id: ParaId,

            free_block_credits: BlockNumberFor<T>,

        }

        /// Helper to set and cleanup the `GivenFreeCredits` storage.

        /// Can only be called by root.

        #[pallet::call_index(2)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_given_free_credits(

            origin: OriginFor<T>,

            para_id: ParaId,

            given_free_credits: bool,

        }

        /// Call index to set the refund address for non-spent tokens

        #[pallet::call_index(3)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_refund_address(

            origin: OriginFor<T>,

            para_id: ParaId,

            refund_address: Option<T::AccountId>,

        }

        /// Set the number of block production credits for this para_id without paying for them.

        /// Can only be called by root.

        #[pallet::call_index(4)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_collator_assignment_credits(

            origin: OriginFor<T>,

            para_id: ParaId,

            free_collator_assignment_credits: u32,

        }

        /// Max core price for parathread in relay chain currency

        #[pallet::call_index(5)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_max_core_price(

            origin: OriginFor<T>,

            para_id: ParaId,

            max_core_price: u128,

        }

        /// Set the maximum tip a container chain is willing to pay to be assigned a collator on congestion.

        /// Can only be called by container chain manager.

        #[pallet::call_index(6)]

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

        #[allow(clippy::useless_conversion)]

        pub fn set_max_tip(

            origin: OriginFor<T>,

            para_id: ParaId,

            max_tip: Option<BalanceOf<T>>,

        }

    }

    impl<T: Config> Pallet<T> {

        /// Burn a credit for the given para. Deducts one credit if possible, errors otherwise.

            );

        /// Burn a credit for the given para. Deducts one credit if possible, errors otherwise.

                // This para id has already received free credits

            // Set number of credits to FreeBlockProductionCredits

            // Do not update credits if for some reason this para id had more

            // Set number of credits to FreeCollatorAssignmentCredits

            // Do not update credits if for some reason this para id had more

            // We only allow to call this function once per para id, even if it didn't actually

            // receive all the free credits

            // Only charge the tip to the paras that had a max tip set

            // (aka were willing to tip for being assigned a collator)

                    WithdrawReasons::TIP,

    }

    #[pallet::genesis_config]

    pub struct GenesisConfig<T: Config> {

        pub para_id_credits: Vec<FreeCreditGenesisParams<BlockNumberFor<T>>>,

    }

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

    }

    #[pallet::genesis_build]

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

    }

}

// Params to be set in genesis

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

pub struct FreeCreditGenesisParams<BlockProductCredits> {

    pub para_id: ParaId,

    pub block_production_credits: BlockProductCredits,

    pub collator_assignment_credits: u32,

}

impl<BlockProductCredits> From<(ParaId, BlockProductCredits, u32)>

    for FreeCreditGenesisParams<BlockProductCredits>

{

}

/// Balance used by this pallet

pub type BalanceOf<T> =

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

pub type CurrencyOf<T> = <T as Config>::Currency;

/// Type alias to conveniently refer to the `Currency::NegativeImbalance` associated type.

pub type NegativeImbalanceOf<T> =

    <CurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;

/// Handler for fee charging. This will be invoked when fees need to be deducted from the fee

/// account for a given paraId.

/// Returns the cost for a given block credit at the current time. This can be a complex operation,

/// so it also returns the weight it consumes. (TODO: or just rely on benchmarking)

pub trait ProvideBlockProductionCost<T: Config> {

    fn block_cost(para_id: &ParaId) -> (BalanceOf<T>, Weight);

}

/// Returns the cost for a given block credit at the current time. This can be a complex operation,

/// so it also returns the weight it consumes. (TODO: or just rely on benchmarking)

pub trait ProvideCollatorAssignmentCost<T: Config> {

    fn collator_assignment_cost(para_id: &ParaId) -> (BalanceOf<T>, Weight);

}

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

    // This hook is called when pallet_author_noting sees that the block number of a container chain has increased.

    // Currently we always charge 1 credit, even if a container chain produced more that 1 block in between tanssi

    // blocks.

                        e

                    ),

                }

        }

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

    fn prepare_worst_case_for_bench(

        _author: &T::AccountId,

        _block_number: BlockNumber,

        para_id: ParaId,

    ) {

        let (amount_to_charge, _weight) = T::ProvideBlockProductionCost::block_cost(&para_id);

        // mint large amount (bigger than ED) to ensure withdraw will not fail.

        let mint = BalanceOf::<T>::from(2_000_000_000u32).saturating_add(amount_to_charge);

        // mint twice more to not have ED issues

        T::Currency::resolve_creating(&Self::parachain_tank(para_id), T::Currency::issue(mint));

    }

}

impl<T: Config> CollatorAssignmentHook<BalanceOf<T>> for Pallet<T> {

    // is_parathread parameter for future use to apply different logic

        // Withdraw assignment fee

                    WithdrawReasons::FEE,

            } else {

            };

            // Only charge the tip to the paras that had a max tip set

            // (aka were willing to tip for being assigned a collator)

                        // Return assignment imbalance to tank on error

                    }

                }

}

impl<T: Config> CollatorAssignmentTip<BalanceOf<T>> for Pallet<T> {

}

impl<T: Config> Pallet<T> {

    /// Derive a derivative account ID from the paraId.

    /// Hook to perform things on deregister

        // Drain the para-id account from tokens

        // Clean refund addres

        // Clean credits

}