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

#![doc = include_str!("../README.md")]

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

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmarking;

#[cfg(feature = "migrations")]

pub mod migrations;

pub mod weights;

pub use weights::WeightInfo;

use {

    core::cmp::min,

    frame_support::{

        dispatch::DispatchErrorWithPostInfo,

        pallet,

        pallet_prelude::*,

        storage::types::{StorageDoubleMap, StorageMap},

        traits::{

            fungible::{Inspect, MutateHold},

            tokens::{Balance, Precision},

        },

        Blake2_128Concat,

    },

    frame_system::pallet_prelude::*,

    parity_scale_codec::{FullCodec, MaxEncodedLen},

    scale_info::TypeInfo,

    serde::{Deserialize, Serialize},

    sp_runtime::{

        traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, One, Saturating, Zero},

        ArithmeticError,

    },

    sp_std::{fmt::Debug, marker::PhantomData},

};

pub use pallet::*;

/// Type able to provide the current time for given unit.

/// For each unit the returned number should monotonically increase and not

/// overflow.

pub trait TimeProvider<Unit, Number> {

    fn now(unit: &Unit) -> Option<Number>;

    /// Benchmarks: should return the time unit which has the worst performance calling

    /// `TimeProvider::now(unit)` with.

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

    fn bench_worst_case_time_unit() -> Unit;

    /// Benchmarks: sets the "now" time for time unit returned by `bench_worst_case_time_unit`.

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

    fn bench_set_now(instant: Number);

}

/// Interactions the pallet needs with assets.

pub trait Assets<AccountId, AssetId, Balance> {

    /// Transfer assets deposited by an account to another account.

    /// Those assets should not be considered deposited in the target account.

    fn transfer_deposit(

        asset_id: &AssetId,

        from: &AccountId,

        to: &AccountId,

        amount: Balance,

    ) -> DispatchResult;

    /// Increase the deposit for an account and asset id. Should fail if account doesn't have

    /// enough of that asset. Funds should be safe and not slashable.

    fn increase_deposit(asset_id: &AssetId, account: &AccountId, amount: Balance)

        -> DispatchResult;

    /// Decrease the deposit for an account and asset id. Should fail on underflow.

    fn decrease_deposit(asset_id: &AssetId, account: &AccountId, amount: Balance)

        -> DispatchResult;

    /// Return the deposit for given asset and account.

    fn get_deposit(asset_id: &AssetId, account: &AccountId) -> Balance;

    /// Benchmarks: should return the asset id which has the worst performance when interacting

    /// with it.

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

    fn bench_worst_case_asset_id() -> AssetId;

    /// Benchmarks: should return the another asset id which has the worst performance when interacting

    /// with it afther `bench_worst_case_asset_id`. This is to benchmark the worst case when changing config

    /// from one asset to another. If there is only one asset id it is fine to return it in both

    /// `bench_worst_case_asset_id` and `bench_worst_case_asset_id2`.

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

    fn bench_worst_case_asset_id2() -> AssetId;

    /// Benchmarks: should set the balance.

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

    fn bench_set_balance(asset_id: &AssetId, account: &AccountId, amount: Balance);

}

pub mod pallet {

    use super::*;

    /// Pooled Staking pallet.

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

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// Overarching event type

        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

        /// Type used to represent stream ids. Should be large enough to not overflow.

        type StreamId: AtLeast32BitUnsigned

            + Default

            + Debug

            + Copy

            + Clone

            + FullCodec

            + TypeInfo

            + MaxEncodedLen;

        /// The balance type, which is also the type representing time (as this

        /// pallet will do math with both time and balances to compute how

        /// much should be paid).

        type Balance: Balance;

        /// Type representing an asset id, a identifier allowing distinguishing assets.

        type AssetId: Debug + Clone + FullCodec + TypeInfo + MaxEncodedLen + PartialEq + Eq;

        /// Provide interaction with assets.

        type Assets: Assets<Self::AccountId, Self::AssetId, Self::Balance>;

        /// Currency for the opening balance hold for the storage used by the Stream.

        /// NOT to be confused with Assets.

        type Currency: Inspect<Self::AccountId, Balance = Self::Balance>

            + MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;

        type RuntimeHoldReason: From<HoldReason>;

        #[pallet::constant]

        type OpenStreamHoldAmount: Get<Self::Balance>;

        /// Represents which units of time can be used. Designed to be an enum

        /// with a variant for each kind of time source/scale supported.

        type TimeUnit: Debug + Clone + FullCodec + TypeInfo + MaxEncodedLen + Eq;

        /// Provide the current time in given unit.

        type TimeProvider: TimeProvider<Self::TimeUnit, Self::Balance>;

        type WeightInfo: weights::WeightInfo;

    }

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

    pub type AssetIdOf<T> = <T as Config>::AssetId;

    pub type RequestNonce = u32;

    /// A stream payment from source to target.

    /// Stores the last time the stream was updated, which allows to compute

    /// elapsed time and perform payment.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Decode,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub struct Stream<AccountId, Unit, AssetId, Balance> {

        /// Payer, source of the stream.

        pub source: AccountId,

        /// Payee, target of the stream.

        pub target: AccountId,

        /// Stream config

        pub config: StreamConfig<Unit, AssetId, Balance>,

        /// How much is deposited to fund this stream.

        pub deposit: Balance,

        /// Last time the stream was updated in `config.time_unit`.

        pub last_time_updated: Balance,

        /// Nonce for requests. This prevents a request to make a first request

        /// then change it to another request to frontrun the other party

        /// accepting.

        pub request_nonce: RequestNonce,

        /// A pending change request if any.

        pub pending_request: Option<ChangeRequest<Unit, AssetId, Balance>>,

        /// One-time opening deposit. Will be released on close.

        pub opening_deposit: Balance,

    }

    impl<AccountId: PartialEq, Unit, AssetId, Balance> Stream<AccountId, Unit, AssetId, Balance> {

            }

    }

    /// Stream configuration.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Decode,

        Copy,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub struct StreamConfig<Unit, AssetId, BalanceOrDuration> {

        /// Unit in which time is measured using a `TimeProvider`.

        pub time_unit: Unit,

        /// Asset used for payment.

        pub asset_id: AssetId,

        /// Amount of asset / unit.

        pub rate: BalanceOrDuration,

        /// Minimum amount of time that can be used for mandatory change requests.

        pub minimum_request_deadline_delay: BalanceOrDuration,

        /// Minimal amount the source must deposit in the stream. Deposit can go

        /// lower due to time passing, but deposit cannot be **decreased** lower

        /// explicitly by the source. If this is non-zero, the stream can only

        /// be closed by the target or if the deposit is zero. If deposit is lower

        /// than minimum due to time passing, source is allowed to **increase** the

        /// deposit to a value lower than the soft minimum.

        ///

        /// This system guarantees to the target that the source cannot instantly

        /// stop paying, and may prepare for termination of service if the deposit

        /// is below this minimum.

        pub soft_minimum_deposit: BalanceOrDuration,

    }

    /// Origin of a change request.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Copy,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub enum Party {

    }

    impl Party {

            }

    }

    /// Kind of change requested.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Copy,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub enum ChangeKind<Time> {

        /// need to accept it.

        Suggestion,

        /// accept the change or close the stream. Reaching the deadline will

        /// close the stream too.

        Mandatory { deadline: Time },

    }

    /// Describe how the deposit should change.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Copy,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub enum DepositChange<Balance> {

        Increase(Balance),

        Decrease(Balance),

        Absolute(Balance),

    }

    /// A request to change a stream config.

    #[derive(

        PartialEq,

        Eq,

        Encode,

        Decode,

        Clone,

        Serialize,

        Deserialize,

    )]

    pub struct ChangeRequest<Unit, AssetId, Balance> {

        pub requester: Party,

        pub kind: ChangeKind<Balance>,

        pub new_config: StreamConfig<Unit, AssetId, Balance>,

        pub deposit_change: Option<DepositChange<Balance>>,

    }

    pub type StreamOf<T> =

        Stream<AccountIdOf<T>, <T as Config>::TimeUnit, AssetIdOf<T>, <T as Config>::Balance>;

    pub type StreamConfigOf<T> =

        StreamConfig<<T as Config>::TimeUnit, AssetIdOf<T>, <T as Config>::Balance>;

    pub type ChangeRequestOf<T> =

        ChangeRequest<<T as Config>::TimeUnit, AssetIdOf<T>, <T as Config>::Balance>;

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

    pub struct StreamPaymentStatus<Balance> {

        pub payment: Balance,

        pub deposit_left: Balance,

        /// Whenever the stream is stalled, which can occur either when no funds are left or

        /// if the time is past a mandatory request deadline.

        pub stalled: bool,

    }

    /// Store the next available stream id.

    pub type NextStreamId<T: Config> = StorageValue<Value = T::StreamId, QueryKind = ValueQuery>;

    /// Store each stream indexed by an Id.

    pub type Streams<T: Config> = StorageMap<

        Hasher = Blake2_128Concat,

        Key = T::StreamId,

        Value = StreamOf<T>,

        QueryKind = OptionQuery,

    >;

    /// Lookup for all streams with given source.

    /// To avoid maintaining a growing list of stream ids, they are stored in

    /// the form of an entry (AccountId, StreamId). If such entry exists then

    /// this AccountId is a source in StreamId. One can iterate over all storage

    /// keys starting with the AccountId to find all StreamIds.

    pub type LookupStreamsWithSource<T: Config> = StorageDoubleMap<

        Key1 = AccountIdOf<T>,

        Hasher1 = Blake2_128Concat,

        Key2 = T::StreamId,

        Hasher2 = Blake2_128Concat,

        Value = (),

        QueryKind = OptionQuery,

    >;

    /// Lookup for all streams with given target.

    /// To avoid maintaining a growing list of stream ids, they are stored in

    /// the form of an entry (AccountId, StreamId). If such entry exists then

    /// this AccountId is a target in StreamId. One can iterate over all storage

    /// keys starting with the AccountId to find all StreamIds.

    pub type LookupStreamsWithTarget<T: Config> = StorageDoubleMap<

        Key1 = AccountIdOf<T>,

        Hasher1 = Blake2_128Concat,

        Key2 = T::StreamId,

        Hasher2 = Blake2_128Concat,

        Value = (),

        QueryKind = OptionQuery,

    >;

    #[derive(Clone, PartialEq, Eq)]

    pub enum Error<T> {

    }

    pub enum Event<T: Config> {

            stream_id: T::StreamId,

        },

            stream_id: T::StreamId,

            refunded: T::Balance,

        },

            stream_id: T::StreamId,

            source: AccountIdOf<T>,

            target: AccountIdOf<T>,

            amount: T::Balance,

            stalled: bool,

        },

            stream_id: T::StreamId,

            request_nonce: RequestNonce,

            requester: Party,

            old_config: StreamConfigOf<T>,

            new_config: StreamConfigOf<T>,

        },

            stream_id: T::StreamId,

            old_config: StreamConfigOf<T>,

            new_config: StreamConfigOf<T>,

            deposit_change: Option<DepositChange<T::Balance>>,

        },

    }

    /// Freeze reason to use if needed.

    #[pallet::composite_enum]

    pub enum FreezeReason {

    }

    /// Hold reason to use if needed.

    #[pallet::composite_enum]

    pub enum HoldReason {

    }

    impl<T: Config> Pallet<T> {

        /// Create a payment stream from the origin to the target with provided config

        /// and initial deposit (in the asset defined in the config).

        #[pallet::call_index(0)]

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

        pub fn open_stream(

            origin: OriginFor<T>,

            target: AccountIdOf<T>,

            config: StreamConfigOf<T>,

            initial_deposit: T::Balance,

        }

        /// Close a given stream in which the origin is involved. It performs the pending payment

        /// before closing the stream.

        #[pallet::call_index(1)]

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

        pub fn close_stream(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

            // Only source or target can close a stream.

            );

            // Update stream before closing it to ensure fair payment.

            // If there is a soft minimum deposit, stream can be closed only by target or if deposit is empty.

            );

            // Unfreeze funds left in the stream.

            // Release opening deposit

            // Remove stream from storage.

        }

        /// Perform the pending payment of a stream. Anyone can call this.

        #[pallet::call_index(2)]

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

        pub fn perform_payment(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

        }

        /// Requests a change to a stream config or deposit.

        ///

        /// If the new config don't change the time unit and asset id, the change will be applied

        /// immediately if it is at the desadvantage of the caller. Otherwise, the request is stored

        /// in the stream and will have to be approved by the other party.

        ///

        /// This call accepts a deposit change, which can only be provided by the source of the

        /// stream. An absolute change is required when changing asset id, as the current deposit

        /// will be released and a new deposit is required in the new asset.

        #[pallet::call_index(3)]

        #[pallet::weight(

            T::WeightInfo::request_change_immediate()

            .max(T::WeightInfo::request_change_delayed())

        )]

        pub fn request_change(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

            kind: ChangeKind<T::Balance>,

            new_config: StreamConfigOf<T>,

            deposit_change: Option<DepositChange<T::Balance>>,

            );

                };

                );

            // If asset id and time unit are the same, we allow to make the change

            // immediatly if the origin is at a disadvantage.

            // We allow this even if there is already a pending request.

            // This checks that the deposit can't be **decreased** under

            // config.soft_minimum_deposit.

            {

            // If there is already a mandatory change request, only the origin

            // of this request can change it.

            if let Some(ChangeRequest {

                kind: ChangeKind::Mandatory { .. },

                ..

            {

                );

        }

        /// Accepts a change requested before by the other party. Takes a nonce to prevent

        /// frontrunning attacks. If the target made a request, the source is able to change their

        /// deposit.

        #[pallet::call_index(4)]

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

        pub fn accept_requested_change(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

            request_nonce: RequestNonce,

            deposit_change: Option<DepositChange<T::Balance>>,

            };

            );

            );

            );

            // Perform pending payment before changing config.

            // Apply change.

            // It is safe to override config now as we have already performed the payment.

            // Checks made in apply_deposit_change needs to be done with new config.

            ) {

                // Same asset and a change, we apply it like in `change_deposit` call.

                }

                // Same asset and no change, no problem.

                // Change in asset with absolute new amount

                    );

                    // Release deposit in old asset.

                    // Make deposit in new asset.

                }

                // It doesn't make sense to change asset while not providing an absolute new

                // amount.

            }

            // If time unit changes we need to update `last_time_updated` to be in the

            // new unit.

            // Event

        }

        #[pallet::call_index(5)]

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

        pub fn cancel_change_request(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

            };

            );

            // Update storage.

            // Pending request is removed by calling `.take()`.

        }

        /// Allows immediately changing the deposit for a stream, which is simpler than

        /// calling `request_change` with the proper parameters.

        /// The call takes an asset id to ensure it has not changed (by an accepted request) before

        /// the call is included in a block, in which case the unit is no longer the same and quantities

        /// will not have the same scale/value.

        #[pallet::call_index(6)]

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

        pub fn immediately_change_deposit(

            origin: OriginFor<T>,

            stream_id: T::StreamId,

            asset_id: T::AssetId,

            change: DepositChange<T::Balance>,

            );

            // Perform pending payment before changing deposit.

            // Apply change.

            // Event

        }

    }

    impl<T: Config> Pallet<T> {

        /// Try to open a stream and returns its id.

        /// Prefers calling this function from other pallets instead of `open_stream` as the

        /// latter can't return the id.

            );

            // Generate a new stream id.

            // Freeze initial deposit.

            // Create stream data.

        /// Get the stream payment current status, telling how much payment is

        /// pending, how much deposit will be left and whenever the stream is stalled.

        /// The stream is considered stalled if no funds are left or if the provided

        /// time is past a mandatory request deadline. If the provided `now` is `None`

        /// then the current time will be fetched. Being able to provide a custom `now`

        /// allows to check the status in the future. It is invalid to provide a `now` that is

        /// before `last_time_updated`.

            };

            );

            // Take into account mandatory change request deadline. Note that

            // while it'll perform payment up to deadline,

            // `stream.last_time_updated` is still the "real now" to avoid

            // retroactive payment in case the deadline changes.

            if let Some(ChangeRequest {

                ..

            {

            // If deposit is zero the stream is fully drained and there is nothing to transfer.

            // Dont perform payment if now is before or equal to `last_time_updated`.

            // It can be before due to the deadline adjustment.

            };

            // We compute the amount due to the target according to the rate, which may be

            // lowered if the stream deposit is lower.

            // Saturating is fine as it'll be clamped to the source deposit. It is also safer as

            // considering it an error can make a stream un-updatable if too much time has passed

            // without updates.

            // We compute the new amount of locked funds. If it underflows it

            // means that there is more to pay that what is left, in which case

            // we pay all that is left.

                None => {

                }

            };

        /// Behavior:

        /// A stream payment consist of a locked deposit, a rate per unit of time and the

        /// last time the stream was updated. When updating the stream, **at most**

        /// `elapsed_time * rate` is unlocked from the source account and transfered to the target

        /// account. If this amount is greater than the left deposit, the stream is considered

        /// drained **but not closed**. The source can come back later and refill the stream,

        /// however there will be no retroactive payment for the time spent as drained.

        /// If the stream payment is used to rent a service, the target should pause the service

        /// while the stream is drained, and resume it once it is refilled.

            // We want to update `stream.last_time_updated` to `now` as soon

            // as possible to avoid forgetting to do it. We copy the old value

            // for payment computation.

            let StreamPaymentStatus {

            // Update stream info.

                }

                }

                }

            }

        /// Tries to apply a possibly immediate change. Return if that change was immediate and

        /// applied or not.

        ///

        /// If asset id and time unit are the same, we allow to make the change

        /// immediatly if the origin is at a disadvantage.

        /// We allow this even if there is already a pending request.

            {

            // We apply the requested deposit change.

            // Emit event.

    }

}