lb_clmm_fork 0.5.2

use crate::constants::MAX_BIN_PER_POSITION;
use crate::errors::LBError;
use crate::manager::bin_array_manager::BinArrayManager;
use crate::math::safe_math::SafeMath;
use crate::math::weight_to_amounts::{to_amount_ask_side, to_amount_bid_side, to_amount_both_side};
use crate::ModifyLiquidity;
use anchor_lang::prelude::*;

const DEFAULT_MIN_WEIGHT: u16 = 200;
const DEFAULT_MAX_WEIGHT: u16 = 2000;

#[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Debug, Default)]
pub struct LiquidityParameterByStrategy {
    /// Amount of X token to deposit
    pub amount_x: u64,
    /// Amount of Y token to deposit
    pub amount_y: u64,
    /// Active bin that integrator observe off-chain
    pub active_id: i32,
    /// max active bin slippage allowed
    pub max_active_bin_slippage: i32,
    /// strategy parameters
    pub strategy_parameters: StrategyParameters,
}

pub fn validate_add_liquidity_by_strategy_params(
    active_id: i32,
    current_active_id: i32,
    max_active_bin_slippage: i32,
    strategy_parameters: &StrategyParameters,
) -> Result<()> {
    let bin_count = strategy_parameters.bin_count()?;
    require!(bin_count > 0, LBError::InvalidInput);

    require!(bin_count <= MAX_BIN_PER_POSITION, LBError::InvalidInput);

    let bin_shift = if active_id > current_active_id {
        active_id - current_active_id
    } else {
        current_active_id - active_id
    };

    require!(
        bin_shift <= max_active_bin_slippage,
        LBError::ExceededBinSlippageTolerance
    );
    Ok(())
}

impl LiquidityParameterByStrategy {
    pub fn to_amounts_into_bin(
        &self,
        active_id: i32,
        bin_step: u16,
        amount_x_in_active_bin: u64,
        amount_y_in_active_bin: u64,
    ) -> Result<Vec<(i32, u64, u64)>> {
        let min_bin_id = self.strategy_parameters.min_bin_id;
        let max_bin_id = self.strategy_parameters.max_bin_id;

        match self.strategy_parameters.strategy_type {
            StrategyType::SpotImBalanced => {
                if active_id < min_bin_id || active_id > max_bin_id {
                    let weights = to_weight_spot_balanced(min_bin_id, max_bin_id);
                    return to_amount_both_side(
                        active_id,
                        bin_step,
                        amount_x_in_active_bin,
                        amount_y_in_active_bin,
                        self.amount_x,
                        self.amount_y,
                        &weights,
                    );
                }
                let mut amounts_in_bin = vec![];
                if min_bin_id <= active_id {
                    let weights = to_weight_spot_balanced(min_bin_id, active_id);
                    let amounts_into_bid_side =
                        to_amount_bid_side(active_id, self.amount_y, &weights)?;
                    for &(bin_id, amount) in amounts_into_bid_side.iter() {
                        amounts_in_bin.push((bin_id, 0, amount))
                    }
                }
                if active_id < max_bin_id {
                    let weights = to_weight_spot_balanced(active_id + 1, max_bin_id);
                    let amounts_into_ask_side =
                        to_amount_ask_side(active_id, self.amount_x, bin_step, &weights)?;

                    for &(bin_id, amount) in amounts_into_ask_side.iter() {
                        amounts_in_bin.push((bin_id, amount, 0))
                    }
                }
                Ok(amounts_in_bin)
            }
            StrategyType::CurveImBalanced => {
                // ask side
                if active_id < min_bin_id {
                    let weights = to_weight_descending_order(min_bin_id, max_bin_id);
                    return to_amount_both_side(
                        active_id,
                        bin_step,
                        amount_x_in_active_bin,
                        amount_y_in_active_bin,
                        self.amount_x,
                        self.amount_y,
                        &weights,
                    );
                }
                // bid side
                if active_id > max_bin_id {
                    let weights = to_weight_ascending_order(min_bin_id, max_bin_id);
                    return to_amount_both_side(
                        active_id,
                        bin_step,
                        amount_x_in_active_bin,
                        amount_y_in_active_bin,
                        self.amount_x,
                        self.amount_y,
                        &weights,
                    );
                }
                let mut amounts_in_bin = vec![];
                if min_bin_id <= active_id {
                    let weights = to_weight_ascending_order(min_bin_id, active_id);
                    let amounts_into_bid_side =
                        to_amount_bid_side(active_id, self.amount_y, &weights)?;
                    for &(bin_id, amount) in amounts_into_bid_side.iter() {
                        amounts_in_bin.push((bin_id, 0, amount))
                    }
                }
                if active_id < max_bin_id {
                    let weights = to_weight_descending_order(active_id + 1, max_bin_id);
                    let amounts_into_ask_side =
                        to_amount_ask_side(active_id, self.amount_x, bin_step, &weights)?;

                    for &(bin_id, amount) in amounts_into_ask_side.iter() {
                        amounts_in_bin.push((bin_id, amount, 0))
                    }
                }
                Ok(amounts_in_bin)
            }
            StrategyType::BidAskImBalanced => {
                // ask side
                if active_id < min_bin_id {
                    let weights = to_weight_ascending_order(min_bin_id, max_bin_id);
                    return to_amount_both_side(
                        active_id,
                        bin_step,
                        amount_x_in_active_bin,
                        amount_y_in_active_bin,
                        self.amount_x,
                        self.amount_y,
                        &weights,
                    );
                }
                // bid side
                if active_id > max_bin_id {
                    let weights = to_weight_descending_order(min_bin_id, max_bin_id);
                    return to_amount_both_side(
                        active_id,
                        bin_step,
                        amount_x_in_active_bin,
                        amount_y_in_active_bin,
                        self.amount_x,
                        self.amount_y,
                        &weights,
                    );
                }
                let mut amounts_in_bin = vec![];
                if min_bin_id <= active_id {
                    let weights = to_weight_descending_order(min_bin_id, active_id);
                    let amounts_into_bid_side =
                        to_amount_bid_side(active_id, self.amount_y, &weights)?;
                    for &(bin_id, amount) in amounts_into_bid_side.iter() {
                        amounts_in_bin.push((bin_id, 0, amount))
                    }
                }
                if active_id < max_bin_id {
                    let weights = to_weight_ascending_order(active_id + 1, max_bin_id);
                    let amounts_into_ask_side =
                        to_amount_ask_side(active_id, self.amount_x, bin_step, &weights)?;

                    for &(bin_id, amount) in amounts_into_ask_side.iter() {
                        amounts_in_bin.push((bin_id, amount, 0))
                    }
                }
                Ok(amounts_in_bin)
            }
            StrategyType::SpotBalanced => {
                let weights = to_weight_spot_balanced(min_bin_id, max_bin_id);
                to_amount_both_side(
                    active_id,
                    bin_step,
                    amount_x_in_active_bin,
                    amount_y_in_active_bin,
                    self.amount_x,
                    self.amount_y,
                    &weights,
                )
            }
            StrategyType::CurveBalanced => {
                let weights = to_weight_curve(min_bin_id, max_bin_id, active_id)?;
                to_amount_both_side(
                    active_id,
                    bin_step,
                    amount_x_in_active_bin,
                    amount_y_in_active_bin,
                    self.amount_x,
                    self.amount_y,
                    &weights,
                )
            }
            StrategyType::BidAskBalanced => {
                let weights = to_weight_bid_ask(min_bin_id, max_bin_id, active_id)?;
                to_amount_both_side(
                    active_id,
                    bin_step,
                    amount_x_in_active_bin,
                    amount_y_in_active_bin,
                    self.amount_x,
                    self.amount_y,
                    &weights,
                )
            }
            _ => Err(LBError::InvalidStrategyParameters.into()),
        }
    }
}

pub fn handle<'a, 'b, 'c, 'info>(
    ctx: Context<'a, 'b, 'c, 'info, ModifyLiquidity<'info>>,
    liquidity_parameter: &LiquidityParameterByStrategy,
) -> Result<()> {
    Ok(())
}

#[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Debug)]
pub struct StrategyParameters {
    /// min bin id
    pub min_bin_id: i32,
    /// max bin id
    pub max_bin_id: i32,
    /// strategy type
    pub strategy_type: StrategyType,
    /// parameters
    pub parameteres: [u8; 64],
}

#[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Debug)]
pub enum StrategyType {
    // spot one side
    SpotOneSide,
    // curve one side
    CurveOneSide,
    // bidAsk one side
    BidAskOneSide,
    // spot both side, balanced deposit
    SpotBalanced,
    // curve both side, balanced deposit
    CurveBalanced,
    // bid ask both side, balanced deposit
    BidAskBalanced,
    // spot both side, imbalanced deposit, only token y is added in active bin
    SpotImBalanced,
    // curve both side, imbalanced deposit, only token y is added in active bin
    CurveImBalanced,
    // bid ask both side, imbalanced deposit, only token y is added in active bin
    BidAskImBalanced,
}

pub fn to_weight_descending_order(min_bin_id: i32, max_bin_id: i32) -> Vec<(i32, u16)> {
    let mut weights = vec![];
    for i in min_bin_id..=max_bin_id {
        weights.push((i, (max_bin_id - i + 1) as u16));
    }
    weights
}

pub fn to_weight_ascending_order(min_bin_id: i32, max_bin_id: i32) -> Vec<(i32, u16)> {
    let mut weights = vec![];
    for i in min_bin_id..=max_bin_id {
        weights.push((i, (i - min_bin_id + 1) as u16));
    }
    weights
}

pub fn to_weight_spot_balanced(min_bin_id: i32, max_bin_id: i32) -> Vec<(i32, u16)> {
    let mut weights = vec![];
    for i in min_bin_id..=max_bin_id {
        weights.push((i, 1));
    }
    weights
}

pub fn to_weight_curve(
    min_bin_id: i32,
    max_bin_id: i32,
    active_id: i32,
) -> Result<Vec<(i32, u16)>> {
    // only bid side
    if active_id > max_bin_id {
        return Ok(to_weight_ascending_order(min_bin_id, max_bin_id));
    }
    // only ask side
    if active_id < min_bin_id {
        return Ok(to_weight_descending_order(min_bin_id, max_bin_id));
    }
    let max_weight = DEFAULT_MAX_WEIGHT;
    let min_weight = DEFAULT_MIN_WEIGHT;

    let diff_weight = max_weight.safe_sub(min_weight)?;
    let diff_min_weight = if active_id > min_bin_id {
        diff_weight.safe_div(active_id.safe_sub(min_bin_id)? as u16)?
    } else {
        0
    };
    let diff_max_weight = if max_bin_id > active_id {
        diff_weight.safe_div(max_bin_id.safe_sub(active_id)? as u16)?
    } else {
        0
    };

    let mut weights = vec![];
    for i in min_bin_id..=max_bin_id {
        if i < active_id {
            let delta_bin = (active_id - i) as u16;
            let weight = max_weight - delta_bin * diff_min_weight;
            weights.push((i, weight));
        } else if i > active_id {
            let delta_bin = (i - active_id) as u16;
            let weight = max_weight - delta_bin * diff_max_weight;
            weights.push((i, weight));
        } else {
            weights.push((i, max_weight));
        }
    }
    Ok(weights)
}

pub fn to_weight_bid_ask(
    min_bin_id: i32,
    max_bin_id: i32,
    active_id: i32,
) -> Result<Vec<(i32, u16)>> {
    // only bid side
    if active_id > max_bin_id {
        return Ok(to_weight_descending_order(min_bin_id, max_bin_id));
    }
    // only ask side
    if active_id < min_bin_id {
        return Ok(to_weight_ascending_order(min_bin_id, max_bin_id));
    }

    let max_weight = DEFAULT_MAX_WEIGHT;
    let min_weight = DEFAULT_MIN_WEIGHT;

    let diff_weight = max_weight.safe_sub(min_weight)?;

    let diff_min_weight = if active_id > min_bin_id {
        diff_weight.safe_div(active_id.safe_sub(min_bin_id)? as u16)?
    } else {
        0
    };
    let diff_max_weight = if max_bin_id > active_id {
        diff_weight.safe_div(max_bin_id.safe_sub(active_id)? as u16)?
    } else {
        0
    };

    let mut weights = vec![];
    for i in min_bin_id..=max_bin_id {
        if i < active_id {
            let delta_bin = (active_id - i) as u16;
            let weight = min_weight + delta_bin * diff_min_weight;
            weights.push((i, weight));
        } else if i > active_id {
            let delta_bin = (i - active_id) as u16;
            let weight = min_weight + delta_bin * diff_max_weight;
            weights.push((i, weight));
        } else {
            weights.push((i, min_weight));
        }
    }
    Ok(weights)
}

impl StrategyParameters {
    pub fn bin_count(&self) -> Result<usize> {
        let bin_count = self.max_bin_id.safe_sub(self.min_bin_id)?.safe_add(1)?;
        Ok(bin_count as usize)
    }
}

impl Default for StrategyParameters {
    fn default() -> Self {
        StrategyParameters {
            min_bin_id: 0,
            max_bin_id: 0,
            strategy_type: StrategyType::SpotBalanced,
            parameteres: [0; 64],
        }
    }
}