lightcone 0.7.1

//! Account structures and deserialization for Lightcone Pinocchio.
//!
//! This module contains all on-chain account structures with their exact
//! byte layouts matching the program.

use solana_pubkey::Pubkey;

use crate::program::constants::{
    EXCHANGE_DISCRIMINATOR, EXCHANGE_SIZE, GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR,
    GLOBAL_DEPOSIT_TOKEN_SIZE, MARKET_DISCRIMINATOR, MARKET_SIZE, MAX_OUTCOMES,
    ORDERBOOK_DISCRIMINATOR, ORDERBOOK_SIZE, ORDER_STATUS_DISCRIMINATOR, ORDER_STATUS_SIZE,
    POSITION_DISCRIMINATOR, POSITION_SIZE, USER_NONCE_DISCRIMINATOR, USER_NONCE_SIZE,
};
use crate::program::error::{SdkError, SdkResult};
use crate::program::types::MarketStatus;

/// Helper to extract a fixed-size array from a slice
#[inline]
fn read_bytes<const N: usize>(data: &[u8], offset: usize) -> [u8; N] {
    let mut arr = [0u8; N];
    arr.copy_from_slice(&data[offset..offset + N]);
    arr
}

/// Helper to read a Pubkey from data
#[inline]
fn read_pubkey(data: &[u8], offset: usize) -> Pubkey {
    Pubkey::new_from_array(read_bytes::<32>(data, offset))
}

/// Helper to read a u64 from data (little-endian)
#[inline]
fn read_u64(data: &[u8], offset: usize) -> u64 {
    u64::from_le_bytes(read_bytes::<8>(data, offset))
}

/// Helper to read a u32 from data (little-endian)
#[inline]
fn read_u32(data: &[u8], offset: usize) -> u32 {
    u32::from_le_bytes(read_bytes::<4>(data, offset))
}

// ============================================================================
// Exchange Account (212 bytes)
// ============================================================================

/// Exchange account - singleton state for the exchange
///
/// Layout:
/// - [0..8]   discriminator (8 bytes)
/// - [8..40]  authority (32 bytes)
/// - [40..72] operator (32 bytes)
/// - [72..104] manager (32 bytes)
/// - [104..112] market_count (8 bytes)
/// - [112]    paused (1 byte)
/// - [113]    bump (1 byte)
/// - [114..116] deposit_token_count (2 bytes)
/// - [116..148] fee_receiver (32 bytes)
/// - [148..212] _reserved (64 bytes)
#[derive(Debug, Clone)]
pub struct Exchange {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Exchange authority (can pause and rotate privileged roles)
    pub authority: Pubkey,
    /// Operator (can match orders and run operational cleanup)
    pub operator: Pubkey,
    /// Manager (can create and activate markets/orderbooks)
    pub manager: Pubkey,
    /// Number of markets created
    pub market_count: u64,
    /// Whether the exchange is paused
    pub paused: bool,
    /// PDA bump seed
    pub bump: u8,
    /// Number of whitelisted deposit tokens
    pub deposit_token_count: u16,
    /// Protocol fee receiver for quote-leg fees.
    pub fee_receiver: Pubkey,
}

impl Exchange {
    /// Account size in bytes
    pub const LEN: usize = EXCHANGE_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != EXCHANGE_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(EXCHANGE_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            authority: read_pubkey(data, 8),
            operator: read_pubkey(data, 40),
            manager: read_pubkey(data, 72),
            market_count: read_u64(data, 104),
            paused: data[112] != 0,
            bump: data[113],
            deposit_token_count: u16::from_le_bytes(read_bytes::<2>(data, 114)),
            fee_receiver: read_pubkey(data, 116),
        })
    }

    /// Check if account data has the exchange discriminator
    pub fn is_exchange_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == EXCHANGE_DISCRIMINATOR
    }
}

// ============================================================================
// Market Account (212 bytes)
// ============================================================================

/// Market account - represents a market
///
/// Layout:
/// - [0..8]     discriminator (8 bytes)
/// - [8..16]   market_id (8 bytes)
/// - [16]       num_outcomes (1 byte)
/// - [17]       status (1 byte)
/// - [18]       bump (1 byte)
/// - [19]       _padding (1 byte)
/// - [20..22]   maker_fee_bps (i16)
/// - [22..24]   taker_fee_bps (i16)
/// - [24..56]   oracle (32 bytes)
/// - [56..88]   question_id (32 bytes)
/// - [88..120]  condition_id (32 bytes)
/// - [120..144] payout_numerators ([u32; 6])
/// - [144..148] payout_denominator (u32)
/// - [148..212] _reserved (64 bytes)
#[derive(Debug, Clone)]
pub struct Market {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Unique market ID
    pub market_id: u64,
    /// Number of possible outcomes (2-6)
    pub num_outcomes: u8,
    /// Current market status
    pub status: MarketStatus,
    /// PDA bump seed
    pub bump: u8,
    /// Maker fee in basis points. May be negative for rebates.
    pub maker_fee_bps: i16,
    /// Taker fee in basis points. May be negative for rebates.
    pub taker_fee_bps: i16,
    /// Oracle pubkey that can settle this market
    pub oracle: Pubkey,
    /// Question ID (32 bytes)
    pub question_id: [u8; 32],
    /// Condition ID derived from oracle + question_id + num_outcomes
    pub condition_id: [u8; 32],
    /// Payout numerators for each possible outcome. Only the first
    /// `num_outcomes` entries are meaningful.
    pub payout_numerators: [u32; MAX_OUTCOMES as usize],
    /// Payout denominator computed by the program as the numerator sum.
    pub payout_denominator: u32,
}

impl Market {
    /// Account size in bytes
    pub const LEN: usize = MARKET_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != MARKET_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(MARKET_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        let mut payout_numerators = [0u32; MAX_OUTCOMES as usize];
        for (index, numerator) in payout_numerators.iter_mut().enumerate() {
            *numerator = read_u32(data, 120 + (index * 4));
        }

        Ok(Self {
            discriminator,
            market_id: read_u64(data, 8),
            num_outcomes: data[16],
            status: MarketStatus::try_from(data[17])?,
            bump: data[18],
            maker_fee_bps: i16::from_le_bytes(read_bytes::<2>(data, 20)),
            taker_fee_bps: i16::from_le_bytes(read_bytes::<2>(data, 22)),
            oracle: read_pubkey(data, 24),
            question_id: read_bytes::<32>(data, 56),
            condition_id: read_bytes::<32>(data, 88),
            payout_numerators,
            payout_denominator: read_u32(data, 144),
        })
    }

    /// Check if account data has the market discriminator
    pub fn is_market_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == MARKET_DISCRIMINATOR
    }
}

// ============================================================================
// Position Account (80 bytes)
// ============================================================================

/// Position account - user's custody account for a market
///
/// Layout:
/// - [0..8]   discriminator (8 bytes)
/// - [8..40]  owner (32 bytes)
/// - [40..72] market (32 bytes)
/// - [72]     bump (1 byte)
/// - [73..80] _padding (7 bytes)
#[derive(Debug, Clone)]
pub struct Position {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Owner of this position
    pub owner: Pubkey,
    /// Market this position is for
    pub market: Pubkey,
    /// PDA bump seed
    pub bump: u8,
}

impl Position {
    /// Account size in bytes
    pub const LEN: usize = POSITION_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != POSITION_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(POSITION_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            owner: read_pubkey(data, 8),
            market: read_pubkey(data, 40),
            bump: data[72],
        })
    }

    /// Check if account data has the position discriminator
    pub fn is_position_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == POSITION_DISCRIMINATOR
    }
}

// ============================================================================
// OrderStatus Account (32 bytes)
// ============================================================================

/// Order status account - tracks partial fills and cancellations
///
/// Layout:
/// - [0..8]   discriminator (8 bytes)
/// - [8..16]  remaining (8 bytes)
/// - [16..24] base_remaining (8 bytes)
/// - [24]     is_cancelled (1 byte)
/// - [25..32] _padding (7 bytes)
#[derive(Debug, Clone)]
pub struct OrderStatus {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Remaining amount_in to be filled
    pub remaining: u64,
    /// Remaining base amount to be filled
    pub base_remaining: u64,
    /// Whether the order has been cancelled
    pub is_cancelled: bool,
}

impl OrderStatus {
    /// Account size in bytes
    pub const LEN: usize = ORDER_STATUS_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != ORDER_STATUS_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(ORDER_STATUS_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            remaining: read_u64(data, 8),
            base_remaining: read_u64(data, 16),
            is_cancelled: data[24] != 0,
        })
    }

    /// Check if account data has the order status discriminator
    pub fn is_order_status_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == ORDER_STATUS_DISCRIMINATOR
    }
}

// ============================================================================
// UserNonce Account (16 bytes)
// ============================================================================

/// User nonce account - tracks user's current nonce for mass cancellation
///
/// Layout:
/// - [0..8]  discriminator (8 bytes)
/// - [8..16] nonce (8 bytes)
#[derive(Debug, Clone)]
pub struct UserNonce {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Current nonce value
    pub nonce: u64,
}

impl UserNonce {
    /// Account size in bytes
    pub const LEN: usize = USER_NONCE_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != USER_NONCE_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(USER_NONCE_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            nonce: read_u64(data, 8),
        })
    }

    /// Check if account data has the user nonce discriminator
    pub fn is_user_nonce_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == USER_NONCE_DISCRIMINATOR
    }
}

// ============================================================================
// Orderbook Account (144 bytes)
// ============================================================================

/// Orderbook account - on-chain orderbook with lookup table
///
/// Layout:
/// - [0..8]     discriminator (8 bytes)
/// - [8..40]    market (32 bytes)
/// - [40..72]   mint_a (32 bytes)
/// - [72..104]  mint_b (32 bytes)
/// - [104..136] lookup_table (32 bytes)
/// - [136]      base_index (1 byte)
/// - [137]      bump (1 byte)
/// - [138..144] _padding (6 bytes)
#[derive(Debug, Clone)]
pub struct Orderbook {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// Market this orderbook is for
    pub market: Pubkey,
    /// Mint A
    pub mint_a: Pubkey,
    /// Mint B
    pub mint_b: Pubkey,
    /// Address lookup table
    pub lookup_table: Pubkey,
    /// Which mint is the base asset (0 = mint_a, 1 = mint_b)
    pub base_index: u8,
    /// PDA bump seed
    pub bump: u8,
}

impl Orderbook {
    /// Account size in bytes
    pub const LEN: usize = ORDERBOOK_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != ORDERBOOK_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(ORDERBOOK_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            market: read_pubkey(data, 8),
            mint_a: read_pubkey(data, 40),
            mint_b: read_pubkey(data, 72),
            lookup_table: read_pubkey(data, 104),
            base_index: data[136],
            bump: data[137],
        })
    }

    /// Check if account data has the orderbook discriminator
    pub fn is_orderbook_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == ORDERBOOK_DISCRIMINATOR
    }
}

// ============================================================================
// GlobalDepositToken Account (48 bytes)
// ============================================================================

/// GlobalDepositToken account - whitelist entry for global deposits
///
/// Layout:
/// - [0..8]   discriminator (8 bytes)
/// - [8..40]  mint (32 bytes)
/// - [40]     active (1 byte)
/// - [41]     bump (1 byte)
/// - [42..44] index (2 bytes)
/// - [44..48] _padding (4 bytes)
#[derive(Debug, Clone)]
pub struct GlobalDepositToken {
    /// Account discriminator
    pub discriminator: [u8; 8],
    /// The whitelisted token mint
    pub mint: Pubkey,
    /// Whether this deposit token is currently active
    pub active: bool,
    /// PDA bump seed
    pub bump: u8,
    /// Sequential index assigned at whitelist time
    pub index: u16,
}

impl GlobalDepositToken {
    /// Account size in bytes
    pub const LEN: usize = GLOBAL_DEPOSIT_TOKEN_SIZE;

    /// Deserialize from account data
    pub fn deserialize(data: &[u8]) -> SdkResult<Self> {
        if data.len() < Self::LEN {
            return Err(SdkError::InvalidDataLength {
                expected: Self::LEN,
                actual: data.len(),
            });
        }

        let discriminator = read_bytes::<8>(data, 0);
        if discriminator != GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR {
            return Err(SdkError::InvalidDiscriminator {
                expected: hex::encode(GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR),
                actual: hex::encode(discriminator),
            });
        }

        Ok(Self {
            discriminator,
            mint: read_pubkey(data, 8),
            active: data[40] != 0,
            bump: data[41],
            index: u16::from_le_bytes(read_bytes::<2>(data, 42)),
        })
    }

    /// Check if account data has the global deposit token discriminator
    pub fn is_global_deposit_token_account(data: &[u8]) -> bool {
        data.len() >= 8 && data[0..8] == GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_exchange_deserialization() {
        let mut data = vec![0u8; EXCHANGE_SIZE];
        data[0..8].copy_from_slice(&EXCHANGE_DISCRIMINATOR);
        // authority at offset 8
        data[8..40].copy_from_slice(&[1u8; 32]);
        // operator at offset 40
        data[40..72].copy_from_slice(&[2u8; 32]);
        // manager at offset 72
        data[72..104].copy_from_slice(&[3u8; 32]);
        // market_count at offset 104
        data[104..112].copy_from_slice(&5u64.to_le_bytes());
        // paused at offset 112
        data[112] = 0;
        // bump at offset 113
        data[113] = 255;
        // deposit_token_count at offset 114
        data[114..116].copy_from_slice(&7u16.to_le_bytes());
        // fee_receiver at offset 116
        data[116..148].copy_from_slice(&[4u8; 32]);

        let exchange = Exchange::deserialize(&data).unwrap();
        assert_eq!(exchange.manager, Pubkey::new_from_array([3u8; 32]));
        assert_eq!(exchange.market_count, 5);
        assert!(!exchange.paused);
        assert_eq!(exchange.bump, 255);
        assert_eq!(exchange.deposit_token_count, 7);
        assert_eq!(exchange.fee_receiver, Pubkey::new_from_array([4u8; 32]));
    }

    #[test]
    fn test_market_deserialization() {
        let mut data = vec![0u8; MARKET_SIZE];
        data[0..8].copy_from_slice(&MARKET_DISCRIMINATOR);
        // market_id at offset 8
        data[8..16].copy_from_slice(&42u64.to_le_bytes());
        // num_outcomes at offset 16
        data[16] = 3;
        // status at offset 17
        data[17] = 1; // Active
                      // bump at offset 18
        data[18] = 254;
        // fees at offsets 20 and 22
        data[20..22].copy_from_slice(&(-10i16).to_le_bytes());
        data[22..24].copy_from_slice(&25i16.to_le_bytes());
        // payout_numerators at offset 120
        data[120..124].copy_from_slice(&7u32.to_le_bytes());
        data[124..128].copy_from_slice(&3u32.to_le_bytes());
        // payout_denominator at offset 144
        data[144..148].copy_from_slice(&10u32.to_le_bytes());

        let market = Market::deserialize(&data).unwrap();
        assert_eq!(market.market_id, 42);
        assert_eq!(market.num_outcomes, 3);
        assert_eq!(market.status, MarketStatus::Active);
        assert_eq!(market.bump, 254);
        assert_eq!(market.maker_fee_bps, -10);
        assert_eq!(market.taker_fee_bps, 25);
        assert_eq!(market.payout_numerators[0], 7);
        assert_eq!(market.payout_numerators[1], 3);
        assert_eq!(market.payout_denominator, 10);
    }

    #[test]
    fn test_position_deserialization() {
        let mut data = vec![0u8; POSITION_SIZE];
        data[0..8].copy_from_slice(&POSITION_DISCRIMINATOR);
        // owner at offset 8
        data[8..40].copy_from_slice(&[1u8; 32]);
        // market at offset 40
        data[40..72].copy_from_slice(&[2u8; 32]);
        // bump at offset 72
        data[72] = 253;

        let position = Position::deserialize(&data).unwrap();
        assert_eq!(position.bump, 253);
    }

    #[test]
    fn test_order_status_deserialization() {
        let mut data = vec![0u8; ORDER_STATUS_SIZE];
        data[0..8].copy_from_slice(&ORDER_STATUS_DISCRIMINATOR);
        // remaining at offset 8
        data[8..16].copy_from_slice(&1000u64.to_le_bytes());
        // base_remaining at offset 16
        data[16..24].copy_from_slice(&750u64.to_le_bytes());
        // is_cancelled at offset 24
        data[24] = 0;

        let order_status = OrderStatus::deserialize(&data).unwrap();
        assert_eq!(order_status.remaining, 1000);
        assert_eq!(order_status.base_remaining, 750);
        assert!(!order_status.is_cancelled);
    }

    #[test]
    fn test_user_nonce_deserialization() {
        let mut data = vec![0u8; USER_NONCE_SIZE];
        data[0..8].copy_from_slice(&USER_NONCE_DISCRIMINATOR);
        // nonce at offset 8
        data[8..16].copy_from_slice(&99u64.to_le_bytes());

        let user_nonce = UserNonce::deserialize(&data).unwrap();
        assert_eq!(user_nonce.nonce, 99);
    }

    #[test]
    fn test_orderbook_deserialization() {
        let mut data = vec![0u8; ORDERBOOK_SIZE];
        data[0..8].copy_from_slice(&ORDERBOOK_DISCRIMINATOR);
        // market at offset 8
        data[8..40].copy_from_slice(&[1u8; 32]);
        // mint_a at offset 40
        data[40..72].copy_from_slice(&[2u8; 32]);
        // mint_b at offset 72
        data[72..104].copy_from_slice(&[3u8; 32]);
        // lookup_table at offset 104
        data[104..136].copy_from_slice(&[4u8; 32]);
        // base_index at offset 136
        data[136] = 1;
        // bump at offset 137
        data[137] = 252;

        let orderbook = Orderbook::deserialize(&data).unwrap();
        assert_eq!(orderbook.market, Pubkey::new_from_array([1u8; 32]));
        assert_eq!(orderbook.mint_a, Pubkey::new_from_array([2u8; 32]));
        assert_eq!(orderbook.mint_b, Pubkey::new_from_array([3u8; 32]));
        assert_eq!(orderbook.lookup_table, Pubkey::new_from_array([4u8; 32]));
        assert_eq!(orderbook.base_index, 1);
        assert_eq!(orderbook.bump, 252);
    }

    #[test]
    fn test_orderbook_is_orderbook_account() {
        let mut data = vec![0u8; ORDERBOOK_SIZE];
        data[0..8].copy_from_slice(&ORDERBOOK_DISCRIMINATOR);
        assert!(Orderbook::is_orderbook_account(&data));

        let bad_data = vec![0u8; ORDERBOOK_SIZE];
        assert!(!Orderbook::is_orderbook_account(&bad_data));
    }

    #[test]
    fn test_global_deposit_token_deserialization() {
        let mut data = vec![0u8; GLOBAL_DEPOSIT_TOKEN_SIZE];
        data[0..8].copy_from_slice(&GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR);
        data[8..40].copy_from_slice(&[5u8; 32]);
        data[40] = 1;
        data[41] = 251;

        let gdt = GlobalDepositToken::deserialize(&data).unwrap();
        assert_eq!(gdt.mint, Pubkey::new_from_array([5u8; 32]));
        assert!(gdt.active);
        assert_eq!(gdt.bump, 251);
        assert_eq!(gdt.index, 0);
    }

    #[test]
    fn test_global_deposit_token_inactive() {
        let mut data = vec![0u8; GLOBAL_DEPOSIT_TOKEN_SIZE];
        data[0..8].copy_from_slice(&GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR);
        data[40] = 0;

        let gdt = GlobalDepositToken::deserialize(&data).unwrap();
        assert!(!gdt.active);
    }

    #[test]
    fn test_global_deposit_token_is_account() {
        let mut data = vec![0u8; GLOBAL_DEPOSIT_TOKEN_SIZE];
        data[0..8].copy_from_slice(&GLOBAL_DEPOSIT_TOKEN_DISCRIMINATOR);
        assert!(GlobalDepositToken::is_global_deposit_token_account(&data));

        let bad_data = vec![0u8; GLOBAL_DEPOSIT_TOKEN_SIZE];
        assert!(!GlobalDepositToken::is_global_deposit_token_account(
            &bad_data
        ));
    }
}