use std::fmt;

use std::mem::size_of;

use anchor_lang::prelude::*;
use arrayref::array_ref;

use fixed::types::I80F48;
use num_enum::IntoPrimitive;
use num_enum::TryFromPrimitive;
use solana_program::program_memory::sol_memmove;
use static_assertions::const_assert_eq;

use crate::error::Contextable;
use crate::error::MangoError;
use crate::error_msg;

use super::dynamic_account::*;
use super::FillEvent;
use super::LeafNode;
use super::PerpMarket;
use super::PerpMarketIndex;
use super::PerpOpenOrders;
use super::Serum3MarketIndex;
use super::Side;
use super::TokenIndex;
use super::FREE_ORDER_SLOT;
use super::{PerpPositions, Serum3Orders, TokenPosition};
use checked_math as cm;

type BorshVecLength = u32;
const BORSH_VEC_PADDING_BYTES: usize = 4;
const BORSH_VEC_SIZE_BYTES: usize = 4;

#[derive(
    Debug,
    Eq,
    PartialEq,
    Clone,
    Copy,
    TryFromPrimitive,
    IntoPrimitive,
    AnchorSerialize,
    AnchorDeserialize,
)]
#[repr(u8)]

pub enum AccountSize {
    Small = 0,
    Large = 1,
}

impl fmt::Display for AccountSize {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            AccountSize::Small => write!(f, "Small"),
            AccountSize::Large => write!(f, "Large"),
        }
    }
}

impl AccountSize {
    pub fn space(&self) -> (u8, u8, u8, u8) {
        match self {
            AccountSize::Small => (8, 2, 2, 2),
            AccountSize::Large => (16, 8, 8, 8),
        }
    }
}

// Mango Account
// This struct definition is only for clients e.g. typescript, so that they can easily use out of the box
// deserialization and not have to do custom deserialization
// On chain, we would prefer zero-copying to optimize for compute
#[account]
pub struct MangoAccount {
    // fixed
    // note: keep MangoAccountFixed in sync with changes here
    // ABI: Clients rely on this being at offset 8
    pub group: Pubkey,

    // ABI: Clients rely on this being at offset 40
    pub owner: Pubkey,

    pub name: [u8; 32],

    // Alternative authority/signer of transactions for a mango account
    pub delegate: Pubkey,

    /// This account cannot open new positions or borrow until `init_health >= 0`
    being_liquidated: u8,

    /// This account cannot do anything except go through `resolve_bankruptcy`
    is_bankrupt: u8,

    pub account_num: u8,
    pub bump: u8,

    // pub info: [u8; INFO_LEN], // TODO: Info could be in a separate PDA?
    pub reserved: [u8; 4],

    // Cumulative (deposits - withdraws)
    // using USD prices at the time of the deposit/withdraw
    // in UI USD units
    pub net_deposits: f32,
    // Cumulative settles on perp positions
    // TODO: unimplemented
    pub net_settled: f32,

    // dynamic
    // note: padding is required for TokenPosition, etc. to be aligned
    pub padding1: u32,
    // Maps token_index -> deposit/borrow account for each token
    // that is active on this MangoAccount.
    pub tokens: Vec<TokenPosition>,
    pub padding2: u32,
    // Maps serum_market_index -> open orders for each serum market
    // that is active on this MangoAccount.
    pub serum3: Vec<Serum3Orders>,
    pub padding3: u32,
    pub perps: Vec<PerpPositions>,
    pub padding4: u32,
    pub perp_open_orders: Vec<PerpOpenOrders>,
}

impl Default for MangoAccount {
    fn default() -> Self {
        Self {
            name: Default::default(),
            group: Pubkey::default(),
            owner: Pubkey::default(),
            delegate: Pubkey::default(),
            being_liquidated: 0,
            is_bankrupt: 0,
            account_num: 0,
            bump: 0,
            reserved: Default::default(),
            net_deposits: 0.0,
            net_settled: 0.0,
            padding1: Default::default(),
            tokens: vec![TokenPosition::default(); 3],
            padding2: Default::default(),
            serum3: vec![Serum3Orders::default(); 5],
            padding3: Default::default(),
            perps: vec![PerpPositions::default(); 2],
            padding4: Default::default(),
            perp_open_orders: vec![PerpOpenOrders::default(); 2],
        }
    }
}

impl MangoAccount {
    pub fn space(account_size: AccountSize) -> usize {
        let (token_count, serum3_count, perp_count, perp_oo_count) = account_size.space();

        8 + size_of::<MangoAccountFixed>()
            + Self::dynamic_size(token_count, serum3_count, perp_count, perp_oo_count)
    }

    pub fn dynamic_token_vec_offset() -> usize {
        BORSH_VEC_PADDING_BYTES
    }

    pub fn dynamic_serum3_vec_offset(token_count: u8) -> usize {
        Self::dynamic_token_vec_offset()
            + (BORSH_VEC_SIZE_BYTES + size_of::<TokenPosition>() * usize::from(token_count))
            + BORSH_VEC_PADDING_BYTES
    }

    pub fn dynamic_perp_vec_offset(token_count: u8, serum3_count: u8) -> usize {
        Self::dynamic_serum3_vec_offset(token_count)
            + (BORSH_VEC_SIZE_BYTES + size_of::<Serum3Orders>() * usize::from(serum3_count))
            + BORSH_VEC_PADDING_BYTES
    }

    pub fn dynamic_perp_oo_vec_offset(token_count: u8, serum3_count: u8, perp_count: u8) -> usize {
        Self::dynamic_perp_vec_offset(token_count, serum3_count)
            + (BORSH_VEC_SIZE_BYTES + size_of::<PerpPositions>() * usize::from(perp_count))
            + BORSH_VEC_PADDING_BYTES
    }

    pub fn dynamic_size(
        token_count: u8,
        serum3_count: u8,
        perp_count: u8,
        perp_oo_count: u8,
    ) -> usize {
        Self::dynamic_perp_oo_vec_offset(token_count, serum3_count, perp_count)
            + (BORSH_VEC_SIZE_BYTES + size_of::<PerpOpenOrders>() * usize::from(perp_oo_count))
    }
}

#[test]
fn test_dynamic_offsets() {
    let mut account = MangoAccount::default();
    account.tokens.resize(16, TokenPosition::default());
    account.serum3.resize(8, Serum3Orders::default());
    account.perps.resize(8, PerpPositions::default());
    account
        .perp_open_orders
        .resize(8, PerpOpenOrders::default());
    assert_eq!(
        8 + AnchorSerialize::try_to_vec(&account).unwrap().len(),
        MangoAccount::space(AccountSize::Large.try_into().unwrap())
    );
}

// Mango Account fixed part for easy zero copy deserialization
#[derive(Copy, Clone, bytemuck::Zeroable, bytemuck::Pod)]
#[repr(C)]
pub struct MangoAccountFixed {
    pub group: Pubkey,
    pub owner: Pubkey,
    pub name: [u8; 32],
    pub delegate: Pubkey,
    being_liquidated: u8,
    is_bankrupt: u8,
    pub account_num: u8,
    pub bump: u8,
    pub reserved: [u8; 4],
    pub net_deposits: f32,
    pub net_settled: f32,
}
const_assert_eq!(size_of::<MangoAccountFixed>(), 32 * 4 + 4 + 4 + 2 * 4);
const_assert_eq!(size_of::<MangoAccountFixed>() % 8, 0);

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

    pub fn is_owner_or_delegate(&self, ix_signer: Pubkey) -> bool {
        self.owner == ix_signer || self.delegate == ix_signer
    }

    pub fn is_bankrupt(&self) -> bool {
        self.is_bankrupt != 0
    }

    pub fn set_bankrupt(&mut self, b: bool) {
        self.is_bankrupt = if b { 1 } else { 0 };
    }

    pub fn being_liquidated(&self) -> bool {
        self.being_liquidated != 0
    }

    pub fn set_being_liquidated(&mut self, b: bool) {
        self.being_liquidated = if b { 1 } else { 0 };
    }
}

impl DynamicAccountType for MangoAccount {
    type Header = MangoAccountDynamicHeader;
    type Fixed = MangoAccountFixed;
}

#[derive(Clone)]
pub struct MangoAccountDynamicHeader {
    pub token_count: u8,
    pub serum3_count: u8,
    pub perp_count: u8,
    pub perp_oo_count: u8,
}

impl DynamicHeader for MangoAccountDynamicHeader {
    fn from_bytes(data: &[u8]) -> Result<Self> {
        let token_count = u8::try_from(BorshVecLength::from_le_bytes(*array_ref![
            data,
            MangoAccount::dynamic_token_vec_offset(),
            BORSH_VEC_SIZE_BYTES
        ]))
        .unwrap();

        let serum3_count = u8::try_from(BorshVecLength::from_le_bytes(*array_ref![
            data,
            MangoAccount::dynamic_serum3_vec_offset(token_count),
            BORSH_VEC_SIZE_BYTES
        ]))
        .unwrap();

        let perp_count = u8::try_from(BorshVecLength::from_le_bytes(*array_ref![
            data,
            MangoAccount::dynamic_perp_vec_offset(token_count, serum3_count),
            BORSH_VEC_SIZE_BYTES
        ]))
        .unwrap();

        let perp_oo_count = u8::try_from(BorshVecLength::from_le_bytes(*array_ref![
            data,
            MangoAccount::dynamic_perp_oo_vec_offset(token_count, serum3_count, perp_count),
            BORSH_VEC_SIZE_BYTES
        ]))
        .unwrap();

        Ok(Self {
            token_count,
            serum3_count,
            perp_count,
            perp_oo_count,
        })
    }

    fn initialize(_data: &mut [u8]) -> Result<()> {
        Ok(())
    }
}

fn get_helper<T: bytemuck::Pod>(data: &[u8], index: usize) -> &T {
    bytemuck::from_bytes(&data[index..index + size_of::<T>()])
}

fn get_helper_mut<T: bytemuck::Pod>(data: &mut [u8], index: usize) -> &mut T {
    bytemuck::from_bytes_mut(&mut data[index..index + size_of::<T>()])
}

impl MangoAccountDynamicHeader {
    // offset into dynamic data where 1st TokenPosition would be found
    // todo make fn private
    pub fn token_offset(&self, raw_index: usize) -> usize {
        MangoAccount::dynamic_token_vec_offset()
            + BORSH_VEC_SIZE_BYTES
            + raw_index * size_of::<TokenPosition>()
    }

    // offset into dynamic data where 1st Serum3Orders would be found
    // todo make fn private
    pub fn serum3_offset(&self, raw_index: usize) -> usize {
        MangoAccount::dynamic_serum3_vec_offset(self.token_count)
            + BORSH_VEC_SIZE_BYTES
            + raw_index * size_of::<Serum3Orders>()
    }

    // offset into dynamic data where 1st PerpPositions would be found
    fn perp_offset(&self, raw_index: usize) -> usize {
        MangoAccount::dynamic_perp_vec_offset(self.token_count, self.serum3_count)
            + BORSH_VEC_SIZE_BYTES
            + raw_index * size_of::<PerpPositions>()
    }

    fn perp_oo_offset(&self, raw_index: usize) -> usize {
        MangoAccount::dynamic_perp_oo_vec_offset(
            self.token_count,
            self.serum3_count,
            self.perp_count,
        ) + BORSH_VEC_SIZE_BYTES
            + raw_index * size_of::<PerpOpenOrders>()
    }

    pub fn token_count(&self) -> usize {
        self.token_count.into()
    }
    pub fn serum3_count(&self) -> usize {
        self.serum3_count.into()
    }
    pub fn perp_count(&self) -> usize {
        self.perp_count.into()
    }
    pub fn perp_oo_count(&self) -> usize {
        self.perp_oo_count.into()
    }
}

pub type MangoAccountValue = DynamicAccountValue<MangoAccount>;
pub type MangoAccountRef<'a> = DynamicAccountRef<'a, MangoAccount>;
pub type MangoAccountRefMut<'a> = DynamicAccountRefMut<'a, MangoAccount>;
pub type MangoAccountRefWithHeader<'a> =
    DynamicAccount<MangoAccountDynamicHeader, &'a MangoAccountFixed, &'a [u8]>;

impl MangoAccountValue {
    // bytes without discriminator
    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        let (fixed, dynamic) = bytes.split_at(size_of::<MangoAccountFixed>());
        Ok(Self {
            fixed: *bytemuck::from_bytes(&fixed),
            header: MangoAccountDynamicHeader::from_bytes(dynamic)?,
            dynamic: dynamic.to_vec(),
        })
    }
}

impl<'a> MangoAccountRefWithHeader<'a> {
    // bytes without discriminator
    pub fn from_bytes(bytes: &'a [u8]) -> Result<Self> {
        let (fixed, dynamic) = bytes.split_at(size_of::<MangoAccountFixed>());
        Ok(Self {
            fixed: bytemuck::from_bytes(&fixed),
            header: MangoAccountDynamicHeader::from_bytes(dynamic)?,
            dynamic,
        })
    }
}

// This generic impl covers MangoAccountRef, MangoAccountRefMut and other
// DynamicAccountValue variants that allow read access.
impl<
        Header: DerefOrBorrow<MangoAccountDynamicHeader>,
        Fixed: DerefOrBorrow<MangoAccountFixed>,
        Dynamic: DerefOrBorrow<[u8]>,
    > DynamicAccount<Header, Fixed, Dynamic>
{
    fn header(&self) -> &MangoAccountDynamicHeader {
        self.header.deref_or_borrow()
    }
    fn fixed(&self) -> &MangoAccountFixed {
        self.fixed.deref_or_borrow()
    }
    fn dynamic(&self) -> &[u8] {
        self.dynamic.deref_or_borrow()
    }

    /// Returns
    /// - the position
    /// - the raw index into the token positions list (for use with get_raw/deactivate)
    pub fn token_get(&self, token_index: TokenIndex) -> Result<(&TokenPosition, usize)> {
        self.token_iter()
            .enumerate()
            .find_map(|(raw_index, p)| p.is_active_for_token(token_index).then(|| (p, raw_index)))
            .ok_or_else(|| error_msg!("position for token index {} not found", token_index))
    }

    // get TokenPosition at raw_index
    pub fn token_get_raw(&self, raw_index: usize) -> &TokenPosition {
        get_helper(self.dynamic(), self.header().token_offset(raw_index))
    }

    // get iter over all TokenPositions (including inactive)
    pub fn token_iter(&self) -> impl Iterator<Item = &TokenPosition> + '_ {
        (0..self.header().token_count()).map(|i| self.token_get_raw(i))
    }

    // get iter over all active TokenPositions
    pub fn token_iter_active(&self) -> impl Iterator<Item = &TokenPosition> + '_ {
        (0..self.header().token_count())
            .map(|i| self.token_get_raw(i))
            .filter(|token| token.is_active())
    }

    pub fn token_find(&self, token_index: TokenIndex) -> Option<&TokenPosition> {
        self.token_iter_active()
            .find(|p| p.is_active_for_token(token_index))
    }

    // get Serum3Orders at raw_index
    pub fn serum3_get_raw(&self, raw_index: usize) -> &Serum3Orders {
        get_helper(self.dynamic(), self.header().serum3_offset(raw_index))
    }

    pub fn serum3_iter(&self) -> impl Iterator<Item = &Serum3Orders> + '_ {
        (0..self.header().serum3_count()).map(|i| self.serum3_get_raw(i))
    }

    pub fn serum3_iter_active(&self) -> impl Iterator<Item = &Serum3Orders> + '_ {
        (0..self.header().serum3_count())
            .map(|i| self.serum3_get_raw(i))
            .filter(|serum3_order| serum3_order.is_active())
    }

    pub fn serum3_find(&self, market_index: Serum3MarketIndex) -> Option<&Serum3Orders> {
        self.serum3_iter_active()
            .find(|p| p.is_active_for_market(market_index))
    }

    // get PerpPosition at raw_index
    pub fn perp_get_raw(&self, raw_index: usize) -> &PerpPositions {
        get_helper(self.dynamic(), self.header().perp_offset(raw_index))
    }

    pub fn perp_iter(&self) -> impl Iterator<Item = &PerpPositions> {
        (0..self.header().perp_count()).map(|i| self.perp_get_raw(i))
    }

    pub fn perp_iter_active_accounts(&self) -> impl Iterator<Item = &PerpPositions> {
        (0..self.header().perp_count())
            .map(|i| self.perp_get_raw(i))
            .filter(|p| p.is_active())
    }

    pub fn perp_find_account(&self, market_index: PerpMarketIndex) -> Option<&PerpPositions> {
        self.perp_iter_active_accounts()
            .find(|p| p.is_active_for_market(market_index))
    }

    pub fn perp_oo_get_raw(&self, raw_index: usize) -> &PerpOpenOrders {
        get_helper(self.dynamic(), self.header().perp_oo_offset(raw_index))
    }

    pub fn perp_oo_iter(&self) -> impl Iterator<Item = &PerpOpenOrders> {
        (0..self.header().perp_oo_count()).map(|i| self.perp_oo_get_raw(i))
    }

    pub fn perp_next_order_slot(&self) -> Option<usize> {
        self.perp_oo_iter()
            .position(|&oo| oo.order_market == FREE_ORDER_SLOT)
    }

    pub fn perp_find_order_with_client_order_id(
        &self,
        market_index: PerpMarketIndex,
        client_order_id: u64,
    ) -> Option<(i128, Side)> {
        for i in 0..self.header().perp_oo_count() {
            let oo = self.perp_oo_get_raw(i);
            if oo.order_market == market_index && oo.client_order_id == client_order_id {
                return Some((oo.order_id, oo.order_side));
            }
        }
        None
    }

    pub fn perp_find_order_side(
        &self,
        market_index: PerpMarketIndex,
        order_id: i128,
    ) -> Option<Side> {
        for i in 0..self.header().perp_oo_count() {
            let oo = self.perp_oo_get_raw(i);
            if oo.order_market == market_index && oo.order_id == order_id {
                return Some(oo.order_side);
            }
        }
        None
    }

    pub fn being_liquidated(&self) -> bool {
        self.fixed().being_liquidated()
    }

    pub fn is_bankrupt(&self) -> bool {
        self.fixed().is_bankrupt()
    }

    pub fn borrow<'b>(&'b self) -> DynamicAccountRef<'b, MangoAccount> {
        DynamicAccount {
            header: self.header(),
            fixed: self.fixed(),
            dynamic: self.dynamic(),
        }
    }

    pub fn size(&self) -> AccountSize {
        if self.header().perp_count() > 4 {
            return AccountSize::Large;
        }
        AccountSize::Small
    }
}

impl<
        Header: DerefOrBorrowMut<MangoAccountDynamicHeader> + DerefOrBorrow<MangoAccountDynamicHeader>,
        Fixed: DerefOrBorrowMut<MangoAccountFixed> + DerefOrBorrow<MangoAccountFixed>,
        Dynamic: DerefOrBorrowMut<[u8]> + DerefOrBorrow<[u8]>,
    > DynamicAccount<Header, Fixed, Dynamic>
{
    fn header_mut(&mut self) -> &mut MangoAccountDynamicHeader {
        self.header.deref_or_borrow_mut()
    }
    fn dynamic_mut(&mut self) -> &mut [u8] {
        self.dynamic.deref_or_borrow_mut()
    }

    pub fn borrow_mut<'b>(&'b mut self) -> DynamicAccountRefMut<'b, MangoAccount> {
        DynamicAccount {
            header: self.header.deref_or_borrow_mut(),
            fixed: self.fixed.deref_or_borrow_mut(),
            dynamic: self.dynamic.deref_or_borrow_mut(),
        }
    }

    /// Returns
    /// - the position
    /// - the raw index into the token positions list (for use with get_raw/deactivate)
    pub fn token_get_mut(
        &mut self,
        token_index: TokenIndex,
    ) -> Result<(&mut TokenPosition, usize)> {
        let raw_index = self
            .token_iter()
            .enumerate()
            .find_map(|(raw_index, p)| p.is_active_for_token(token_index).then(|| raw_index))
            .ok_or_else(|| error_msg!("position for token index {} not found", token_index))?;
        Ok((self.token_get_mut_raw(raw_index), raw_index))
    }

    // get mut TokenPosition at raw_index
    pub fn token_get_mut_raw(&mut self, raw_index: usize) -> &mut TokenPosition {
        let offset = self.header().token_offset(raw_index);
        get_helper_mut(self.dynamic_mut(), offset)
    }

    /// Creates or retrieves a TokenPosition for the token_index.
    /// Returns:
    /// - the position
    /// - the raw index into the token positions list (for use with get_raw)
    /// - the active index, for use with FixedOrderAccountRetriever
    pub fn token_get_mut_or_create(
        &mut self,
        token_index: TokenIndex,
    ) -> Result<(&mut TokenPosition, usize, usize)> {
        let mut active_index = 0;
        let mut match_or_free = None;
        for (raw_index, position) in self.token_iter().enumerate() {
            if position.is_active_for_token(token_index) {
                // Can't return early because of lifetimes
                match_or_free = Some((raw_index, active_index));
                break;
            }
            if position.is_active() {
                active_index += 1;
            } else if match_or_free.is_none() {
                match_or_free = Some((raw_index, active_index));
            }
        }
        if let Some((raw_index, bank_index)) = match_or_free {
            let v = self.token_get_mut_raw(raw_index);
            if !v.is_active_for_token(token_index) {
                *v = TokenPosition {
                    indexed_position: I80F48::ZERO,
                    token_index,
                    in_use_count: 0,
                    reserved: Default::default(),
                };
            }
            Ok((v, raw_index, bank_index))
        } else {
            err!(MangoError::NoFreeTokenPositionIndex)
                .context(format!("when looking for token index {}", token_index))
        }
    }

    pub fn token_deactivate(&mut self, raw_index: usize) {
        assert!(self.token_get_mut_raw(raw_index).in_use_count == 0);
        self.token_get_mut_raw(raw_index).token_index = TokenIndex::MAX;
    }

    // get mut Serum3Orders at raw_index
    pub fn serum3_get_mut_raw(&mut self, raw_index: usize) -> &mut Serum3Orders {
        let offset = self.header().serum3_offset(raw_index);
        get_helper_mut(self.dynamic_mut(), offset)
    }

    pub fn serum3_create(&mut self, market_index: Serum3MarketIndex) -> Result<&mut Serum3Orders> {
        if self.serum3_find(market_index).is_some() {
            return err!(MangoError::Serum3OpenOrdersExistAlready);
        }

        let raw_index_opt = self.serum3_iter().position(|p| !p.is_active());
        if let Some(raw_index) = raw_index_opt {
            *(self.serum3_get_mut_raw(raw_index)) = Serum3Orders {
                market_index: market_index as Serum3MarketIndex,
                ..Serum3Orders::default()
            };
            return Ok(self.serum3_get_mut_raw(raw_index));
        } else {
            return err!(MangoError::NoFreeSerum3OpenOrdersIndex);
        }
    }

    pub fn serum3_deactivate(&mut self, market_index: Serum3MarketIndex) -> Result<()> {
        let raw_index = self
            .serum3_iter()
            .position(|p| p.is_active_for_market(market_index))
            .ok_or_else(|| error_msg!("serum3 open orders index {} not found", market_index))?;
        self.serum3_get_mut_raw(raw_index).market_index = Serum3MarketIndex::MAX;
        Ok(())
    }

    pub fn serum3_find_mut(
        &mut self,
        market_index: Serum3MarketIndex,
    ) -> Option<&mut Serum3Orders> {
        let raw_index_opt = self
            .serum3_iter_active()
            .position(|p| p.is_active_for_market(market_index));
        raw_index_opt.map(|raw_index| self.serum3_get_mut_raw(raw_index))
    }

    // get mut PerpPosition at raw_index
    pub fn perp_get_mut_raw(&mut self, raw_index: usize) -> &mut PerpPositions {
        let offset = self.header().perp_offset(raw_index);
        get_helper_mut(self.dynamic_mut(), offset)
    }

    pub fn perp_oo_get_mut_raw(&mut self, raw_index: usize) -> &mut PerpOpenOrders {
        let offset = self.header().perp_oo_offset(raw_index);
        get_helper_mut(self.dynamic_mut(), offset)
    }

    pub fn perp_get_account_mut_or_create(
        &mut self,
        perp_market_index: PerpMarketIndex,
    ) -> Result<(&mut PerpPositions, usize)> {
        let mut raw_index_opt = self
            .perp_iter_active_accounts()
            .position(|p| p.is_active_for_market(perp_market_index));
        if raw_index_opt.is_none() {
            raw_index_opt = self.perp_iter().position(|p| !p.is_active());
            if let Some(raw_index) = raw_index_opt {
                *(self.perp_get_mut_raw(raw_index)) = PerpPositions {
                    market_index: perp_market_index,
                    ..Default::default()
                };
            }
        }
        if let Some(raw_index) = raw_index_opt {
            Ok((self.perp_get_mut_raw(raw_index), raw_index))
        } else {
            err!(MangoError::NoFreePerpPositionIndex)
        }
    }

    pub fn perp_deactivate_account(&mut self, raw_index: usize) {
        self.perp_get_mut_raw(raw_index).market_index = PerpMarketIndex::MAX;
    }

    pub fn perp_add_order(
        &mut self,
        perp_market_index: PerpMarketIndex,
        side: Side,
        order: &LeafNode,
    ) -> Result<()> {
        let mut perp_account = self
            .perp_get_account_mut_or_create(perp_market_index)
            .unwrap()
            .0;
        match side {
            Side::Bid => {
                perp_account.bids_base_lots = cm!(perp_account.bids_base_lots + order.quantity);
            }
            Side::Ask => {
                perp_account.asks_base_lots = cm!(perp_account.asks_base_lots + order.quantity);
            }
        };
        let slot = order.owner_slot as usize;

        let mut oo = self.perp_oo_get_mut_raw(slot);
        oo.order_market = perp_market_index;
        oo.order_side = side;
        oo.order_id = order.key;
        oo.client_order_id = order.client_order_id;
        Ok(())
    }

    pub fn perp_remove_order(&mut self, slot: usize, quantity: i64) -> Result<()> {
        {
            let oo = self.perp_oo_get_mut_raw(slot);
            require_neq!(oo.order_market, FREE_ORDER_SLOT);
            let order_side = oo.order_side;
            let perp_market_index = oo.order_market;
            let perp_account = self
                .perp_get_account_mut_or_create(perp_market_index)
                .unwrap()
                .0;

            // accounting
            match order_side {
                Side::Bid => {
                    perp_account.bids_base_lots = cm!(perp_account.bids_base_lots - quantity);
                }
                Side::Ask => {
                    perp_account.asks_base_lots = cm!(perp_account.asks_base_lots - quantity);
                }
            }
        }

        // release space
        let oo = self.perp_oo_get_mut_raw(slot);
        oo.order_market = FREE_ORDER_SLOT;
        oo.order_side = Side::Bid;
        oo.order_id = 0i128;
        oo.client_order_id = 0u64;
        Ok(())
    }

    pub fn perp_execute_maker(
        &mut self,
        perp_market_index: PerpMarketIndex,
        perp_market: &mut PerpMarket,
        fill: &FillEvent,
    ) -> Result<()> {
        let pa = self
            .perp_get_account_mut_or_create(perp_market_index)
            .unwrap()
            .0;
        pa.settle_funding(perp_market);

        let side = fill.taker_side.invert_side();
        let (base_change, quote_change) = fill.base_quote_change(side);
        pa.change_base_position(perp_market, base_change);
        let quote = I80F48::from_num(
            perp_market
                .quote_lot_size
                .checked_mul(quote_change)
                .unwrap(),
        );
        let fees = quote.abs() * fill.maker_fee;
        if !fill.market_fees_applied {
            perp_market.fees_accrued += fees;
        }
        pa.quote_position_native = pa.quote_position_native.checked_add(quote - fees).unwrap();

        if fill.maker_out {
            self.perp_remove_order(fill.maker_slot as usize, base_change.abs())
        } else {
            match side {
                Side::Bid => {
                    pa.bids_base_lots = cm!(pa.bids_base_lots - base_change.abs());
                }
                Side::Ask => {
                    pa.asks_base_lots = cm!(pa.asks_base_lots - base_change.abs());
                }
            }
            Ok(())
        }
    }

    pub fn perp_execute_taker(
        &mut self,
        perp_market_index: PerpMarketIndex,
        perp_market: &mut PerpMarket,
        fill: &FillEvent,
    ) -> Result<()> {
        let pa = self
            .perp_get_account_mut_or_create(perp_market_index)
            .unwrap()
            .0;
        pa.settle_funding(perp_market);

        let (base_change, quote_change) = fill.base_quote_change(fill.taker_side);
        pa.remove_taker_trade(base_change, quote_change);
        pa.change_base_position(perp_market, base_change);
        let quote = I80F48::from_num(perp_market.quote_lot_size * quote_change);

        // fees are assessed at time of trade; no need to assess fees here

        pa.quote_position_native += quote;
        Ok(())
    }

    // writes length of tokens vec at appropriate offset so that borsh can infer the vector length
    // length used is that present in the header
    fn write_token_length(&mut self) {
        let tokens_offset = self.header().token_offset(0);
        // msg!(
        //     "writing tokens length at {}",
        //     tokens_offset - size_of::<BorshVecLength>()
        // );
        let count = self.header().token_count;
        let dst: &mut [u8] =
            &mut self.dynamic_mut()[tokens_offset - BORSH_VEC_SIZE_BYTES..tokens_offset];
        dst.copy_from_slice(&BorshVecLength::from(count).to_le_bytes());
    }

    fn write_serum3_length(&mut self) {
        let serum3_offset = self.header().serum3_offset(0);
        // msg!(
        //     "writing serum3 length at {}",
        //     serum3_offset - size_of::<BorshVecLength>()
        // );
        let count = self.header().serum3_count;
        let dst: &mut [u8] =
            &mut self.dynamic_mut()[serum3_offset - BORSH_VEC_SIZE_BYTES..serum3_offset];
        dst.copy_from_slice(&BorshVecLength::from(count).to_le_bytes());
    }

    fn write_perp_length(&mut self) {
        let perp_offset = self.header().perp_offset(0);
        // msg!(
        //     "writing perp length at {}",
        //     perp_offset - size_of::<BorshVecLength>()
        // );
        let count = self.header().perp_count;
        let dst: &mut [u8] =
            &mut self.dynamic_mut()[perp_offset - BORSH_VEC_SIZE_BYTES..perp_offset];
        dst.copy_from_slice(&BorshVecLength::from(count).to_le_bytes());
    }

    fn write_perp_oo_length(&mut self) {
        let perp_oo_offset = self.header().perp_oo_offset(0);
        // msg!(
        //     "writing perp length at {}",
        //     perp_offset - size_of::<BorshVecLength>()
        // );
        let count = self.header().perp_oo_count;
        let dst: &mut [u8] =
            &mut self.dynamic_mut()[perp_oo_offset - BORSH_VEC_SIZE_BYTES..perp_oo_offset];
        dst.copy_from_slice(&BorshVecLength::from(count).to_le_bytes());
    }

    pub fn expand_dynamic_content(&mut self, account_size: AccountSize) -> Result<()> {
        let (new_token_count, new_serum3_count, new_perp_count, new_perp_oo_count) =
            account_size.space();

        require_gt!(new_token_count, self.header().token_count);
        require_gt!(new_serum3_count, self.header().serum3_count);
        require_gt!(new_perp_count, self.header().perp_count);
        require_gt!(new_perp_oo_count, self.header().perp_oo_count);

        // create a temp copy to compute new starting offsets
        let new_header = MangoAccountDynamicHeader {
            token_count: new_token_count,
            serum3_count: new_serum3_count,
            perp_count: new_perp_count,
            perp_oo_count: new_perp_oo_count,
        };
        let old_header = self.header().clone();
        let dynamic = self.dynamic_mut();

        // expand dynamic components by first moving existing positions, and then setting new ones to defaults

        // perp oo
        unsafe {
            sol_memmove(
                &mut dynamic[new_header.perp_oo_offset(0)],
                &mut dynamic[old_header.perp_oo_offset(0)],
                size_of::<PerpOpenOrders>() * old_header.perp_oo_count(),
            );
        }
        for i in old_header.perp_oo_count..new_perp_oo_count {
            *get_helper_mut(dynamic, new_header.perp_oo_offset(i.into())) =
                PerpOpenOrders::default();
        }

        // perp positions
        unsafe {
            sol_memmove(
                &mut dynamic[new_header.perp_offset(0)],
                &mut dynamic[old_header.perp_offset(0)],
                size_of::<PerpPositions>() * old_header.perp_count(),
            );
        }
        for i in old_header.perp_count..new_perp_count {
            *get_helper_mut(dynamic, new_header.perp_offset(i.into())) = PerpPositions::default();
        }

        // serum3 positions
        unsafe {
            sol_memmove(
                &mut dynamic[new_header.serum3_offset(0)],
                &mut dynamic[old_header.serum3_offset(0)],
                size_of::<Serum3Orders>() * old_header.serum3_count(),
            );
        }
        for i in old_header.serum3_count..new_serum3_count {
            *get_helper_mut(dynamic, new_header.serum3_offset(i.into())) = Serum3Orders::default();
        }

        // token positions
        unsafe {
            sol_memmove(
                &mut dynamic[new_header.token_offset(0)],
                &mut dynamic[old_header.token_offset(0)],
                size_of::<TokenPosition>() * old_header.token_count(),
            );
        }
        for i in old_header.token_count..new_token_count {
            *get_helper_mut(dynamic, new_header.token_offset(i.into())) = TokenPosition::default();
        }

        // update header
        let header_mut = self.header_mut();
        header_mut.token_count = new_token_count;
        header_mut.serum3_count = new_serum3_count;
        header_mut.perp_count = new_perp_count;
        header_mut.perp_oo_count = new_perp_oo_count;

        // write new lengths (uses header)
        self.write_token_length();
        self.write_serum3_length();
        self.write_perp_length();
        self.write_perp_oo_length();

        Ok(())
    }
}