use super::{OracleConfig, TokenIndex, TokenPosition};
use crate::error::MangoError;
use crate::util::checked_math as cm;
use anchor_lang::prelude::*;
use fixed::types::I80F48;
use fixed_macro::types::I80F48;
use static_assertions::const_assert_eq;

use std::mem::size_of;

pub const DAY: I80F48 = I80F48!(86400);
pub const YEAR: I80F48 = I80F48!(31536000);

#[account(zero_copy)]
pub struct Bank {
    // ABI: Clients rely on this being at offset 8
    pub group: Pubkey,

    pub name: [u8; 16],

    pub mint: Pubkey,
    pub vault: Pubkey,
    pub oracle: Pubkey,

    pub oracle_config: OracleConfig,

    /// the index used to scale the value of an IndexedPosition
    /// TODO: should always be >= 0, add checks?
    pub deposit_index: I80F48,
    pub borrow_index: I80F48,

    /// total deposits/borrows, only updated during UpdateIndex
    /// TODO: These values could be dropped from the bank, they're written in UpdateIndex
    ///       and never read.
    pub cached_indexed_total_deposits: I80F48,
    pub cached_indexed_total_borrows: I80F48,

    /// deposits/borrows for this bank
    ///
    /// Note that these may become negative. It's perfectly fine for users to borrow one one bank
    /// (increasing indexed_borrows there) and paying back on another (possibly decreasing indexed_borrows
    /// below zero).
    ///
    /// The vault amount is not deducable from these values.
    ///
    /// These become meaningful when summed over all banks (like in update_index).
    pub indexed_deposits: I80F48,
    pub indexed_borrows: I80F48,

    pub last_updated: i64,
    pub util0: I80F48,
    pub rate0: I80F48,
    pub util1: I80F48,
    pub rate1: I80F48,
    pub max_rate: I80F48,

    // TODO: add ix/logic to regular send this to DAO
    pub collected_fees_native: I80F48,
    pub loan_origination_fee_rate: I80F48,
    pub loan_fee_rate: I80F48,

    // This is a _lot_ of bytes (64) - seems unnecessary
    // (could maybe store them in one byte each, as an informal U1F7?
    // that could store values between 0-2 and converting to I80F48 would be a cheap expand+shift)
    pub maint_asset_weight: I80F48,
    pub init_asset_weight: I80F48,
    pub maint_liab_weight: I80F48,
    pub init_liab_weight: I80F48,

    // a fraction of the price, like 0.05 for a 5% fee during liquidation
    //
    // Liquidation always involves two tokens, and the sum of the two configured fees is used.
    pub liquidation_fee: I80F48,

    // Collection of all fractions-of-native-tokens that got rounded away
    pub dust: I80F48,

    pub flash_loan_vault_initial: u64,
    pub flash_loan_approved_amount: u64,

    // Index into TokenInfo on the group
    pub token_index: TokenIndex,

    pub bump: u8,

    pub mint_decimals: u8,

    pub reserved: [u8; 4],

    pub bank_num: u64,
    // TODO: add space for an oracle which services interest rate for the bank's mint
    // interest rate tied to oracle might help reduce spreads between deposits and borrows
}
const_assert_eq!(
    size_of::<Bank>(),
    16 + 32 * 4 + 8 + 16 * 21 + 2 * 8 + 2 + 1 + 1 + 4 + 8
);
const_assert_eq!(size_of::<Bank>() % 8, 0);

impl std::fmt::Debug for Bank {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Bank")
            .field("name", &self.name())
            .field("group", &self.group)
            .field("mint", &self.mint)
            .field("vault", &self.vault)
            .field("oracle", &self.oracle)
            .field("oracle_config", &self.oracle_config)
            .field("deposit_index", &self.deposit_index)
            .field("borrow_index", &self.borrow_index)
            .field(
                "cached_indexed_total_deposits",
                &self.cached_indexed_total_deposits,
            )
            .field(
                "cached_indexed_total_borrows",
                &self.cached_indexed_total_borrows,
            )
            .field("indexed_deposits", &self.indexed_deposits)
            .field("indexed_borrows", &self.indexed_borrows)
            .field("last_updated", &self.last_updated)
            .field("util0", &self.util0)
            .field("rate0", &self.rate0)
            .field("util1", &self.util1)
            .field("rate1", &self.rate1)
            .field("max_rate", &self.max_rate)
            .field("collected_fees_native", &self.collected_fees_native)
            .field("loan_origination_fee_rate", &self.loan_origination_fee_rate)
            .field("loan_fee_rate", &self.loan_fee_rate)
            .field("maint_asset_weight", &self.maint_asset_weight)
            .field("init_asset_weight", &self.init_asset_weight)
            .field("maint_liab_weight", &self.maint_liab_weight)
            .field("init_liab_weight", &self.init_liab_weight)
            .field("liquidation_fee", &self.liquidation_fee)
            .field("dust", &self.dust)
            .field("token_index", &self.token_index)
            .field(
                "flash_loan_approved_amount",
                &self.flash_loan_approved_amount,
            )
            .field("flash_loan_vault_initial", &self.flash_loan_vault_initial)
            .field("reserved", &self.reserved)
            .finish()
    }
}

impl Bank {
    pub fn from_existing_bank(existing_bank: &Bank, vault: Pubkey, bank_num: u64) -> Self {
        Self {
            name: existing_bank.name,
            group: existing_bank.group,
            mint: existing_bank.mint,
            vault: vault,
            oracle: existing_bank.oracle,
            oracle_config: existing_bank.oracle_config,
            deposit_index: existing_bank.deposit_index,
            borrow_index: existing_bank.borrow_index,
            cached_indexed_total_deposits: existing_bank.cached_indexed_total_deposits,
            cached_indexed_total_borrows: existing_bank.cached_indexed_total_borrows,
            indexed_deposits: I80F48::ZERO,
            indexed_borrows: I80F48::ZERO,
            last_updated: existing_bank.last_updated,
            util0: existing_bank.util0,
            rate0: existing_bank.rate0,
            util1: existing_bank.util1,
            rate1: existing_bank.rate1,
            max_rate: existing_bank.max_rate,
            collected_fees_native: existing_bank.collected_fees_native,
            loan_origination_fee_rate: existing_bank.loan_origination_fee_rate,
            loan_fee_rate: existing_bank.loan_fee_rate,
            maint_asset_weight: existing_bank.maint_asset_weight,
            init_asset_weight: existing_bank.init_asset_weight,
            maint_liab_weight: existing_bank.maint_liab_weight,
            init_liab_weight: existing_bank.init_liab_weight,
            liquidation_fee: existing_bank.liquidation_fee,
            dust: I80F48::ZERO,
            flash_loan_approved_amount: 0,
            flash_loan_vault_initial: u64::MAX,
            token_index: existing_bank.token_index,
            bump: existing_bank.bump,
            mint_decimals: existing_bank.mint_decimals,
            reserved: Default::default(),
            bank_num,
        }
    }

    pub fn name(&self) -> &str {
        std::str::from_utf8(&self.name)
            .unwrap()
            .trim_matches(char::from(0))
    }

    pub fn native_borrows(&self) -> I80F48 {
        self.borrow_index * self.indexed_borrows
    }

    pub fn native_deposits(&self) -> I80F48 {
        self.deposit_index * self.indexed_deposits
    }

    /// Returns whether the position is active
    ///
    /// native_amount must be >= 0
    /// fractional deposits can be relevant during liquidation, for example
    pub fn deposit(
        &mut self,
        position: &mut TokenPosition,
        mut native_amount: I80F48,
    ) -> Result<bool> {
        require!(native_amount >= 0, MangoError::SomeError);
        let native_position = position.native(self);

        // Adding DELTA to amount/index helps because (amount/index)*index <= amount, but
        // we want to ensure that users can withdraw the same amount they have deposited, so
        // (amount/index + delta)*index >= amount is a better guarantee.
        // Additionally, we require that we don't adjust values if
        // (native / index) * index == native, because we sometimes call this function with
        // values that are products of index.
        let div_rounding_up = |native: I80F48, index: I80F48| {
            let indexed = cm!(native / index);
            if cm!(indexed * index) < native {
                cm!(indexed + I80F48::DELTA)
            } else {
                indexed
            }
        };

        if native_position.is_negative() {
            let new_native_position = cm!(native_position + native_amount);
            let indexed_change = div_rounding_up(native_amount, self.borrow_index);
            // this is only correct if it's not positive, because it scales the whole amount by borrow_index
            let new_indexed_value = cm!(position.indexed_position + indexed_change);
            if new_indexed_value.is_negative() {
                // pay back borrows only, leaving a negative position
                self.indexed_borrows = cm!(self.indexed_borrows - indexed_change);
                position.indexed_position = cm!(position.indexed_position + indexed_change);
                return Ok(true);
            } else if new_native_position < I80F48::ONE && !position.is_in_use() {
                // if there's less than one token deposited, zero the position
                self.dust = cm!(self.dust + new_native_position);
                self.indexed_borrows = cm!(self.indexed_borrows + position.indexed_position);
                position.indexed_position = I80F48::ZERO;
                return Ok(false);
            }

            // pay back all borrows
            self.indexed_borrows = cm!(self.indexed_borrows + position.indexed_position); // position.value is negative
            position.indexed_position = I80F48::ZERO;
            // deposit the rest
            native_amount = cm!(native_amount + native_position);
        }

        // add to deposits
        let indexed_change = div_rounding_up(native_amount, self.deposit_index);
        self.indexed_deposits = cm!(self.indexed_deposits + indexed_change);
        position.indexed_position = cm!(position.indexed_position + indexed_change);

        Ok(true)
    }

    /// Returns whether the position is active after withdrawing from a position
    /// without applying the loan origination fee.
    ///
    /// native_amount must be >= 0
    /// fractional withdraws can be relevant during liquidation, for example
    pub fn withdraw_without_fee(
        &mut self,
        position: &mut TokenPosition,
        native_amount: I80F48,
    ) -> Result<bool> {
        self.withdraw_internal(position, native_amount, false)
    }

    /// Returns whether the position is active after withdrawing from a position
    /// while applying the loan origination fee if a borrow is created.
    ///
    /// native_amount must be >= 0
    /// fractional withdraws can be relevant during liquidation, for example
    pub fn withdraw_with_fee(
        &mut self,
        position: &mut TokenPosition,
        native_amount: I80F48,
    ) -> Result<bool> {
        self.withdraw_internal(position, native_amount, true)
    }

    fn withdraw_internal(
        &mut self,
        position: &mut TokenPosition,
        mut native_amount: I80F48,
        with_loan_origination_fee: bool,
    ) -> Result<bool> {
        require!(native_amount >= 0, MangoError::SomeError);
        let native_position = position.native(self);

        if native_position.is_positive() {
            let new_native_position = cm!(native_position - native_amount);
            if !new_native_position.is_negative() {
                // withdraw deposits only
                if new_native_position < I80F48::ONE && !position.is_in_use() {
                    // zero the account collecting the leftovers in `dust`
                    self.dust = cm!(self.dust + new_native_position);
                    self.indexed_deposits = cm!(self.indexed_deposits - position.indexed_position);
                    position.indexed_position = I80F48::ZERO;
                    return Ok(false);
                } else {
                    // withdraw some deposits leaving a positive balance
                    let indexed_change = cm!(native_amount / self.deposit_index);
                    self.indexed_deposits = cm!(self.indexed_deposits - indexed_change);
                    position.indexed_position = cm!(position.indexed_position - indexed_change);
                    return Ok(true);
                }
            }

            // withdraw all deposits
            self.indexed_deposits = cm!(self.indexed_deposits - position.indexed_position);
            position.indexed_position = I80F48::ZERO;
            // borrow the rest
            native_amount = -new_native_position;
        }

        if with_loan_origination_fee {
            self.charge_loan_origination_fee(position, native_amount)?;
        }

        // add to borrows
        let indexed_change = cm!(native_amount / self.borrow_index);
        self.indexed_borrows = cm!(self.indexed_borrows + indexed_change);
        position.indexed_position = cm!(position.indexed_position - indexed_change);

        Ok(true)
    }

    // charge only loan origination fee, assuming borrow has already happened
    pub fn charge_loan_origination_fee(
        &mut self,
        position: &mut TokenPosition,
        already_borrowed_native_amount: I80F48,
    ) -> Result<()> {
        let loan_origination_fee =
            cm!(self.loan_origination_fee_rate * already_borrowed_native_amount);
        self.collected_fees_native = cm!(self.collected_fees_native + loan_origination_fee);

        let indexed_change = cm!(loan_origination_fee / self.borrow_index);
        self.indexed_borrows = cm!(self.indexed_borrows + indexed_change);
        position.indexed_position = cm!(position.indexed_position - indexed_change);

        Ok(())
    }

    /// Change a position without applying the loan origination fee
    pub fn change_without_fee(
        &mut self,
        position: &mut TokenPosition,
        native_amount: I80F48,
    ) -> Result<bool> {
        if native_amount >= 0 {
            self.deposit(position, native_amount)
        } else {
            self.withdraw_without_fee(position, -native_amount)
        }
    }

    /// Change a position, while taking the loan origination fee into account
    pub fn change_with_fee(
        &mut self,
        position: &mut TokenPosition,
        native_amount: I80F48,
    ) -> Result<bool> {
        if native_amount >= 0 {
            self.deposit(position, native_amount)
        } else {
            self.withdraw_with_fee(position, -native_amount)
        }
    }

    // Borrows continously expose insurance fund to risk, collect fees from borrowers
    pub fn charge_loan_fee(&mut self, diff_ts: I80F48) {
        let native_borrows_old = self.native_borrows();
        self.indexed_borrows =
            cm!((self.indexed_borrows * (I80F48::ONE + self.loan_fee_rate * (diff_ts / YEAR))));
        self.collected_fees_native =
            cm!(self.collected_fees_native + self.native_borrows() - native_borrows_old);
    }

    pub fn compute_index(
        &mut self,
        indexed_total_deposits: I80F48,
        indexed_total_borrows: I80F48,
        diff_ts: I80F48,
    ) -> Result<(I80F48, I80F48)> {
        // compute index based on utilization
        let native_total_deposits = self.deposit_index * indexed_total_deposits;
        let native_total_borrows = self.borrow_index * indexed_total_borrows;

        let utilization = if native_total_deposits == I80F48::ZERO {
            I80F48::ZERO
        } else {
            cm!(native_total_borrows / native_total_deposits)
        };

        let interest_rate = self.compute_interest_rate(utilization);

        let borrow_interest: I80F48 = cm!(interest_rate * diff_ts);
        let deposit_interest = cm!(borrow_interest * utilization);

        // msg!("utilization {}", utilization);
        // msg!("interest_rate {}", interest_rate);
        // msg!("borrow_interest {}", borrow_interest);
        // msg!("deposit_interest {}", deposit_interest);

        if borrow_interest <= I80F48::ZERO || deposit_interest <= I80F48::ZERO {
            return Ok((self.deposit_index, self.borrow_index));
        }

        let borrow_index = cm!((self.borrow_index * borrow_interest) / YEAR + self.borrow_index);
        let deposit_index =
            cm!((self.deposit_index * deposit_interest) / YEAR + self.deposit_index);

        Ok((deposit_index, borrow_index))
    }

    /// returns the current interest rate in APR
    #[inline(always)]
    pub fn compute_interest_rate(&self, utilization: I80F48) -> I80F48 {
        Bank::interest_rate_curve_calculator(
            utilization,
            self.util0,
            self.rate0,
            self.util1,
            self.rate1,
            self.max_rate,
        )
    }

    /// calcualtor function that can be used to compute an interest
    /// rate based on the given parameters
    #[inline(always)]
    pub fn interest_rate_curve_calculator(
        utilization: I80F48,
        util0: I80F48,
        rate0: I80F48,
        util1: I80F48,
        rate1: I80F48,
        max_rate: I80F48,
    ) -> I80F48 {
        // TODO: daffy: use optimal interest from oracle
        if utilization <= util0 {
            let slope = cm!(rate0 / util0);
            cm!(slope * utilization)
        } else if utilization <= util1 {
            let extra_util = cm!(utilization - util0);
            let slope = cm!((rate1 - rate0) / (util1 - util0));
            cm!(rate0 + slope * extra_util)
        } else {
            let extra_util = cm!(utilization - util1);
            let slope = cm!((max_rate - rate1) / (I80F48::ONE - util1));
            cm!(rate1 + slope * extra_util)
        }
    }
}

#[macro_export]
macro_rules! bank_seeds {
    ( $bank:expr ) => {
        &[
            $bank.group.as_ref(),
            b"Bank".as_ref(),
            $bank.token_index.to_le_bytes(),
            &bank.bank_num.to_le_bytes(),
            &[$bank.bump],
        ]
    };
}

pub use bank_seeds;

#[cfg(test)]
mod tests {
    use bytemuck::Zeroable;
    use std::cmp::min;

    use super::*;

    #[test]
    pub fn change() -> Result<()> {
        let epsilon = I80F48::from_bits(1);
        let cases = [
            (-10.1, 1),
            (-10.1, 10),
            (-10.1, 11),
            (-10.1, 50),
            (-10.0, 10),
            (-10.0, 11),
            (-2.0, 2),
            (-2.0, 3),
            (-0.1, 1),
            (0.0, 1),
            (0.1, 1),
            (10.1, -1),
            (10.1, -9),
            (10.1, -10),
            (10.1, -11),
            (10.0, -10),
            (10.0, -9),
            (1.0, -1),
            (0.1, -1),
            (0.0, -1),
            (-0.1, -1),
            (-1.1, -10),
        ];

        for is_in_use in [false, true] {
            for (start, change) in cases {
                println!(
                    "testing: in use: {}, start: {}, change: {}",
                    is_in_use, start, change
                );

                //
                // SETUP
                //

                let mut bank = Bank::zeroed();
                bank.deposit_index = I80F48::from_num(100.0);
                bank.borrow_index = I80F48::from_num(10.0);
                bank.loan_origination_fee_rate = I80F48::from_num(0.1);
                let indexed = |v: I80F48, b: &Bank| {
                    if v > 0 {
                        v / b.deposit_index
                    } else {
                        v / b.borrow_index
                    }
                };

                let mut account = TokenPosition {
                    indexed_position: I80F48::ZERO,
                    token_index: 0,
                    in_use_count: if is_in_use { 1 } else { 0 },
                    reserved: Default::default(),
                };

                account.indexed_position = indexed(I80F48::from_num(start), &bank);
                if start >= 0.0 {
                    bank.indexed_deposits = account.indexed_position;
                } else {
                    bank.indexed_borrows = -account.indexed_position;
                }

                // get the rounded start value
                let start_native = account.native(&bank);

                //
                // TEST
                //

                let change = I80F48::from(change);
                let is_active = bank.change_with_fee(&mut account, change)?;

                let mut expected_native = start_native + change;
                if expected_native >= 0.0 && expected_native < 1.0 && !is_in_use {
                    assert!(!is_active);
                    assert_eq!(bank.dust, expected_native);
                    expected_native = I80F48::ZERO;
                } else {
                    assert!(is_active);
                    assert_eq!(bank.dust, I80F48::ZERO);
                }
                if change < 0 && expected_native < 0 {
                    let new_borrow = -(expected_native - min(start_native, I80F48::ZERO));
                    expected_native -= new_borrow * bank.loan_origination_fee_rate;
                }
                let expected_indexed = indexed(expected_native, &bank);

                // at most one epsilon error in the resulting indexed value
                assert!((account.indexed_position - expected_indexed).abs() <= epsilon);

                if account.indexed_position.is_positive() {
                    assert_eq!(bank.indexed_deposits, account.indexed_position);
                    assert_eq!(bank.indexed_borrows, I80F48::ZERO);
                } else {
                    assert_eq!(bank.indexed_deposits, I80F48::ZERO);
                    assert_eq!(bank.indexed_borrows, -account.indexed_position);
                }
            }
        }
        Ok(())
    }
}