use anchor_lang::prelude::*;
use enumflags2::bitflags;
use static_assertions as sa;

#[account]
pub struct GlobalConfigAccount {
    pub dflow_admin: Pubkey,
}

#[account]
pub struct RecoveryStateAccount {
    pub mint: Pubkey,
}

pub enum AuctionStateAccountEvent {
    Initialized = 0,
    NewBestBid = 1,
    NewAuctionWinner = 2,
    NextOrderIdIncremented = 3,
    AuctionStateChanged = 4,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AuctionStatus {
    Trading = 0,
    Halted = 1,
    Expired = 2,
    Draining = 3,
}

#[derive(Debug, Clone, Copy)]
pub enum Side {
    Ask = -1,
    Bid = 1
}

#[derive(AnchorSerialize, AnchorDeserialize, Debug, Clone, Eq, PartialEq)]
pub struct CurrencyPair {
    pub base: Pubkey,
    pub base_oracle: Pubkey,
    pub quote: Pubkey,
    pub quote_oracle: Pubkey,
}
sa::const_assert_eq!(std::mem::size_of::<CurrencyPair>(), 128);

#[derive(AnchorSerialize, AnchorDeserialize, Debug, Clone, Copy)]
pub struct MantissaExp {
    pub mantissa: i64,
    pub exponent: i32,
}

#[account]
pub struct AuctionMapper {
    pub auction_ids: Vec<u64>,
}

#[account]
pub struct AuctionStateAccount {
    pub event: u8,
    pub status: u8,
    pub supported_pairs_count: u8,
    pub auction_winner: Option<Pubkey>,
    pub auction_leader: Option<Pubkey>,
    pub bid_mint: Pubkey,
    pub vote_reward_mint: Pubkey,
    pub auction_owner: Pubkey,
    pub vote_size: u64,
    pub auction_id: u64,
    // The epoch currently accepting bids in an ongoing auction
    // The epoch that new orders are submitted to is this `epoch - 1`
    pub epoch: u64,
    pub min_notional_order_size: u64,
    pub max_notional_order_size: u64,
    pub notional_decimals: u8,
    pub best_bid: u64,
    pub winning_bid: u64,
    pub batch_notional_size: u64,
    pub next_order_id: u64,
    pub vote_period: u32,
    pub claim_period: u32,
    pub num_open_epochs: u32,
    pub pairs: Vec<CurrencyPair>,
}
sa::const_assert_eq!(std::mem::size_of::<AuctionStateAccount>(), 280);

#[account]
pub struct AuctionEpochState {
    pub routed_notional: u64,
    pub bid_size: u64,
    pub epoch: u64,
    pub winner: Option<Pubkey>,
    pub num_open_orders: u16,
    pub num_unsettled_fills: u16,
    pub owner: Pubkey,
}

#[derive(AnchorSerialize, AnchorDeserialize, Debug, Copy, Clone, Default)]
pub struct OrderDetails {
    pub y_mint: Pubkey,
    pub min_fill_price: u64,
}

#[account]
#[derive(Default)]
pub struct FillRecordAccount {
    // Return lamports for creating this account to this key
    pub market_maker_account_owner: Pubkey,
    pub retail_account_owner: Pubkey,
    // This is the order associated with this FillRecordAccount
    pub vault_meta_account: Pubkey,
    pub fill_x_amount: u64,
    pub fill_notional: u64,
    pub order_details: OrderDetails,
    pub auction_id: u64,
    pub fill_timestamp: u64,
    pub retail_nonce: u64,
    pub fill_nonce: u16,
    pub fair_votes: u32,
    pub unfair_votes: u32,
}

#[account]
pub struct MarketMakerDataAccount {
    pub owner: Pubkey,
    pub encryption_pub_key: [u8; 32],
    pub max_orders_supported: u64,
    pub events_head: u8,
    pub events: Vec<MarketMakerEvent>,
    pub orders: Vec<Pubkey>,
}

pub enum MarketMakerEventKind {
    None = 0,
    OrderPlaced = 1,
    OrderCancelled = 2,
    OrderPartiallyFilled = 3,
    OrderFilled = 4,
}

pub const MARKET_MAKER_EVENT_DATA_LENGTH: usize = 128;

#[derive(AnchorSerialize, AnchorDeserialize, Debug, Copy, Clone)]
pub struct MarketMakerEvent {
    pub event: u8,
    pub data: [u8; MARKET_MAKER_EVENT_DATA_LENGTH],
}

pub enum RetailDataAccountEvent {
    Initialized = 0,
    NewOrder = 1,
    OrderCancelled = 2,
    OrderFilled = 3,
    OrderPartiallyFilled = 4,
    AccountClosed = 5,
}

#[account]
pub struct RetailDataAccount {
    pub retail_account_owner: Pubkey,
    pub event: u8,
    pub nonce: u64,
    pub num_unsettled_fills: u64,
    pub max_orders_supported: u64,
    pub orders: Vec<Pubkey>,
}

#[account]
pub struct VaultMetaAccount {
    pub retail_encryption_pub_key: [u8; 32],
    pub mm_encryption_pub_key: [u8; 32],
    pub retail_signing_pub_key: [u8; 32],
    pub retail_signature: [u8; 64],
    pub vault_token_account: Pubkey,
    pub rebate_receiver_token_account: Pubkey,
    pub market_maker_data_account: Pubkey,
    pub retail_data_account: Pubkey,
    pub retail_account_owner: Pubkey,
    pub retail_x_token_account: Pubkey,
    pub x_mint: Pubkey,
    pub deposit_notional: u64,
    pub deposit_amount: u64,
    pub filled_x_amount: u64,
    pub filled_y_amount: u64,
    pub auction_id: u64,
    pub auction_epoch: u64,
    pub nonce: u64,
    pub order_id: u64,
    pub order_type: u8,
    pub fill_nonce: u16,
    pub basket_prices: Vec<MantissaExp>,
    pub encrypted_order_details: String,
}

#[account]
pub struct VoteRecordAccount {
    pub vote: u8,
}

#[account]
pub struct BidRecordAccount {
    pub bid_size: u64,
}

#[account]
pub struct SignatoryRecord {
    pub signatory_server: Pubkey,
    pub stake_size: u64,
}

#[account]
#[derive(Default)]
pub struct SignatoryState {
    pub stake_mint: Pubkey,
}

#[bitflags]
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u16)]
pub enum Role {
    AuctionOwner = 1 << 0,
    Arbiter = 1 << 1,
    SignatoryServer = 1 << 2,
    MarketMaker = 1 << 3,
}

#[account]
pub struct WhitelistEntry {
    pub principal: Pubkey,
    pub role_flags: u16,
}