//! # Equilibrium Primitives Pallet
//!
//! Equilibrium's Primitives Pallet is a module containing basic data types
//! and interfaces for Equilibrium pallets

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

pub mod currency;
pub mod signed_balance;
use crate::currency::Currency;
pub use crate::signed_balance::SignedBalance;

use core::slice::Iter;
use frame_support::codec::{Codec, Decode, Encode, FullCodec};
use frame_support::{debug, Parameter};
use impl_trait_for_tuples::impl_for_tuples;
#[cfg(feature = "std")]
use serde::{Deserialize, Serialize};
use sp_runtime::traits::AtLeast32Bit;
use sp_runtime::{
    traits::{AtLeast32BitUnsigned, MaybeSerializeDeserialize, Member, Zero},
    RuntimeDebug,
};
use sp_std::fmt::Debug;
use sp_std::prelude::*;

/// Errors during fee calculation
#[derive(PartialEq, Debug, Clone)]
pub enum InterestRateError {
    /// Error during fetching data for calculations from external sources
    ExternalError,
    /// Math errors
    MathError,
    /// Some of values used is calculations are out of bound
    ValueError,
}

/// Generic interface for calculating and charging fees. Used in Treasury and
/// Bailsman pallets
pub trait FeeManager<AccountId, Balance> {
    /// Calculates fee that must be charged from account `owner` due
    /// `last_update` timestamp
    fn calc_fee(owner: &AccountId, last_update: &u64) -> Result<Balance, InterestRateError>;

    /// Withdraws fee from `owner` account. Amount that should be withdrawn is
    /// passed as `debt`
    fn charge_fee_inner(owner: &AccountId, debt: &Balance);

    /// Calculates and withdraws fee due `last_update` timestamp from `owner`.
    /// Calls `calc_fee` and `charge_fee_inner`. Withdrawn amount is returned
    /// in `Result`
    fn charge_fee(owner: &AccountId, last_update: &u64) -> Result<Balance, InterestRateError> {
        let debt_delta = Self::calc_fee(owner, last_update)?;
        Self::charge_fee_inner(owner, &debt_delta);
        Ok(debt_delta)
    }
}

#[impl_for_tuples(5)]
impl<AccountId, Balance: AtLeast32Bit + Clone> FeeManager<AccountId, Balance> for Tuple {
    fn calc_fee(owner: &AccountId, last_update: &u64) -> Result<Balance, InterestRateError> {
        let mut debt = Balance::zero();
        for_tuples!( #( debt = debt + Tuple::calc_fee(owner, last_update)?; )* );
        Ok(debt)
    }
    fn charge_fee_inner(owner: &AccountId, debt: &Balance) {
        panic!("don't use this in tuple!");
    }
    fn charge_fee(owner: &AccountId, last_update: &u64) -> Result<Balance, InterestRateError> {
        let mut debt = Balance::zero();
        let mut fees = Vec::<Balance>::new();
        for_tuples!( #( {
            let fee = Tuple::calc_fee(owner, last_update)?;
            debt = debt + fee.clone();
            fees.push(fee);
        } )* );

        let mut index: usize = 0;
        for_tuples!( #( {
            let debt_delta = Tuple::charge_fee_inner(owner, &fees[index]);
            index += 1;
        } )* );
        Ok(debt)
    }
}

/// Supports getting account id
pub trait AccountGetter<AccountId> {
    fn get_account_id() -> AccountId;
}

/// User groups used in Equilibrium substrate
#[derive(Encode, Decode, Clone, Copy, PartialEq, RuntimeDebug, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[repr(u8)]
pub enum UserGroup {
    Unknown = 0,
    /// User can have balances and transfer currencies
    Balances = 1,
    /// User is a bailsman
    Bailsmen = 2,
}

impl Eq for UserGroup {}

impl Default for UserGroup {
    fn default() -> UserGroup {
        UserGroup::Unknown
    }
}

impl UserGroup {
    /// Iterator over user groups excluding group `Unknown`
    pub fn iterator() -> Iter<'static, UserGroup> {
        static USERGROUPS: [UserGroup; 2] = [UserGroup::Balances, UserGroup::Bailsmen];
        USERGROUPS.iter()
    }
}

impl From<u8> for UserGroup {
    fn from(orig: u8) -> Self {
        match orig {
            0x0 => UserGroup::Unknown,
            0x1 => UserGroup::Balances,
            0x2 => UserGroup::Bailsmen,
            _ => UserGroup::Unknown,
        }
    }
}

/// Aggregated USD values of positive (collateral) and negative (debt) balances
/// for a group of users
#[derive(Encode, Decode, Clone, Default, PartialEq, Debug)]
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
pub struct TotalAggregates<Balance> {
    pub collateral: Balance,
    pub debt: Balance,
}

/// When implemented, pallet can work with `TotalAggregates`
pub trait Aggregates<AccountId, Balance>
where
    Balance: Member
        + AtLeast32BitUnsigned
        + FullCodec
        + Copy
        + MaybeSerializeDeserialize
        + Debug
        + Default,
{
    /// Checks wether `account_id` is in a group `user_group`
    fn in_usergroup(account_id: &AccountId, user_group: &UserGroup) -> bool;

    /// Adds `account_id` to a `user_group` or removes it from a group based on
    /// passed `is_in` bool
    fn set_usergroup(account_id: &AccountId, user_group: &UserGroup, is_in: &bool);

    /// Updates `TotalAggregates` of a group when balance of `account_id`
    /// changes for `delta_balance`
    fn update_total(
        account_id: &AccountId,
        currency: &Currency,
        prev_balance: &SignedBalance<Balance>,
        delta_balance: &SignedBalance<Balance>,
    );

    /// Used to iterate over all accounts of a user group
    fn iter_account(user_group: &UserGroup) -> Box<dyn Iterator<Item = AccountId>>;

    /// Used to iterate over currency total of a user group
    fn iter_total(
        user_group: &UserGroup,
    ) -> Box<dyn Iterator<Item = (Currency, TotalAggregates<Balance>)>>;

    // TODO: remove later
    /// Deprecated, will be removed
    fn get_total(user_group: &UserGroup, currency: &Currency) -> TotalAggregates<Balance>;
}

#[derive(Encode, Decode, Clone, Copy, PartialEq, RuntimeDebug, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[repr(u8)]
/// Describe the reason for the transfer.
pub enum TransferReason {
    /// Usual transfer from user to another.
    Common,

    /// Charging Interest fee for borrowing assets.
    InterestFee,

    /// Margincall of user position.
    MarginCall,

    /// Redistribution of bailsmen temp balances.
    BailsmenRedistribution,

    /// Buyout treasury eq tokens to pay off borrower interest (if user has not enough eq tokens on balance).
    TreasuryEqBuyout,

    /// Buyout treasury non eq tokens to return eq tokens, that was sold on TreasuryEqBuy.
    TreasuryBuyEq,
}

impl Eq for TransferReason {}

impl Default for TransferReason {
    fn default() -> TransferReason {
        TransferReason::Common
    }
}