LP Token Model

use exponent_tranching::{
    ExponentTranchingMarket,
    MARKET_STATUS_FLAG_PAUSED,
};
use precise_number::Number;

fn read_market_inputs(
    market: &ExponentTranchingMarket,
) -> (bool, Number, Number, u64, u64, Number, i64) {
    let is_paused = (market.status_flags & MARKET_STATUS_FLAG_PAUSED) != 0;

    let senior_effective_nav: Number = market.financials.sr_effective_net_asset;
    let junior_effective_nav: Number = market.financials.jr_effective_net_asset;

    let senior_lp_supply = market.tranche_supply_state.total_senior_lp_supply;
    let junior_lp_supply = market.tranche_supply_state.total_junior_lp_supply;

    let utilization: Number = market.financials.utilization;
    let fixed_term_end_ts = market.financials.fixed_term_end_ts;

    (
        is_paused,
        senior_effective_nav,
        junior_effective_nav,
        senior_lp_supply,
        junior_lp_supply,
        utilization,
        fixed_term_end_ts,
    )
}

use exponent_tranching::ExponentTranchingMarket;
use precise_number::Number;

struct CapacityPreview {
    senior_remaining_nav: Number,
    junior_remaining_nav: Option<Number>,
}

// `lp_price`, `lp_out`, and `mul_div_number` should mirror program rounding.
// `mul_div_number(..., true)` rounds up; `false` rounds down.
fn calculate_capacity(market: &ExponentTranchingMarket) -> Option<CapacityPreview> {
    let financials = &market.financials;
    let supply = &market.tranche_supply_state;
    let risk = &market.risk_config;

    let senior_lp_price = lp_price(
        financials.sr_effective_net_asset,
        supply.total_senior_lp_supply,
    )?;
    let junior_lp_price = lp_price(
        financials.jr_effective_net_asset,
        supply.total_junior_lp_supply,
    )?;

    let beta_adjusted_junior_nav =
        mul_div_number(financials.jr_raw_net_asset, risk.beta, Number::ONE, true)?;
    let current_protected_exposure =
        financials.sr_raw_net_asset.checked_add(&beta_adjusted_junior_nav)?;
    let max_protected_exposure = if risk.min_coverage == Number::ZERO
        || financials.jr_effective_net_asset == Number::ZERO
    {
        Number::ZERO
    } else {
        mul_div_number(
            financials.jr_effective_net_asset,
            Number::ONE,
            risk.min_coverage,
            false,
        )?
    };
    let senior_coverage_remaining_nav = max_protected_exposure
        .checked_sub(&current_protected_exposure)
        .unwrap_or(Number::ZERO);

    let remaining_coverage_lp = lp_out(
        senior_coverage_remaining_nav,
        supply.total_senior_lp_supply,
        financials.sr_effective_net_asset,
    )?;
    let coverage_lp_capacity = supply
        .total_senior_lp_supply
        .checked_add(remaining_coverage_lp)?;
    let senior_lp_capacity = if supply.max_senior_lp_supply == 0 {
        coverage_lp_capacity
    } else {
        supply.max_senior_lp_supply.min(coverage_lp_capacity)
    };
    let senior_remaining_lp_capacity =
        senior_lp_capacity.saturating_sub(supply.total_senior_lp_supply);
    let senior_remaining_nav_by_lp =
        senior_lp_price.checked_mul(&Number::from(senior_remaining_lp_capacity as u128))?;
    let senior_remaining_nav = if senior_remaining_nav_by_lp <= senior_coverage_remaining_nav {
        senior_remaining_nav_by_lp
    } else {
        senior_coverage_remaining_nav
    };

    let junior_remaining_nav = if supply.max_junior_lp_supply == 0 {
        None
    } else {
        let junior_remaining_lp_capacity =
            supply.max_junior_lp_supply.saturating_sub(supply.total_junior_lp_supply);
        Some(junior_lp_price.checked_mul(&Number::from(
            junior_remaining_lp_capacity as u128,
        ))?)
    };

    Some(CapacityPreview {
        senior_remaining_nav,
        junior_remaining_nav,
    })
}