public(friend) fun new_bulk_order_book<M: store + copy + drop>(): BulkOrderBook<M> {
    BulkOrderBook::V1 {
        orders: order_book_utils::new_default_big_ordered_map(),
        order_id_to_address: order_book_utils::new_default_big_ordered_map()
    }
}

public(friend) fun get_single_match_for_taker<M: store + copy + drop>(
    self: &mut BulkOrderBook<M>,
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    active_matched_order: ActiveMatchedOrder,
    is_bid: bool
): OrderMatch<M> {
    let (order_id, matched_size, remaining_size, order_book_type) =
        active_matched_order.destroy_active_matched_order();
    assert!(order_book_type == bulk_order_type(), ENOT_BULK_ORDER);
    let order_address = self.order_id_to_address.get(&order_id).destroy_some();
    let order = self.orders.remove(&order_address);
    let order_match = new_bulk_order_match<M>(&order, !is_bid, matched_size);
    let (next_price, next_size) =
        bulk_order_utils::match_order_and_get_next_from_bulk_order(
            &mut order, !is_bid, matched_size
        );
    if (remaining_size == 0 && next_price.is_some()) {
        let price = next_price.destroy_some();
        let size = next_size.destroy_some();
        price_time_idx.place_maker_order(
            order_id,
            bulk_order_type(),
            price,
            order.get_unique_priority_idx(),
            size,
            !is_bid
        );
    };
    self.orders.add(order_address, order);
    return order_match
}

fun cancel_active_order_for_side<M: store + copy + drop>(
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    order: &BulkOrder<M>,
    is_bid: bool
) {
    let active_price = order.get_order_request().get_active_price(is_bid);
    if (active_price.is_some()) {
        price_time_idx.cancel_active_order(
            active_price.destroy_some(),
            order.get_unique_priority_idx(),
            is_bid
        );
    };
}

fun cancel_active_orders<M: store + copy + drop>(
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    order: &BulkOrder<M>
) {
    cancel_active_order_for_side(price_time_idx, order, true); // cancel bid
    cancel_active_order_for_side(price_time_idx, order, false); // cancel ask
}

fun activate_first_price_level_for_side<M: store + copy + drop>(
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    order: &BulkOrder<M>,
    order_id: OrderId,
    is_bid: bool
) {
    let order_request = order.get_order_request();
    let active_price = order_request.get_active_price(is_bid);
    let active_size = order_request.get_active_size(is_bid);
    if (active_price.is_some()) {
        price_time_idx.place_maker_order(
            order_id,
            bulk_order_type(),
            active_price.destroy_some(),
            order.get_unique_priority_idx(),
            active_size.destroy_some(),
            is_bid
        );
    }
}

fun activate_first_price_levels<M: store + copy + drop>(
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    order: &BulkOrder<M>,
    order_id: OrderId
) {
    activate_first_price_level_for_side(price_time_idx, order, order_id, true); // activate bid
    activate_first_price_level_for_side(price_time_idx, order, order_id, false); // activate ask
}

public(friend) fun reinsert_order<M: store + copy + drop>(
    self: &mut BulkOrderBook<M>,
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    reinsert_order: OrderMatchDetails<M>,
    original_order: &OrderMatchDetails<M>
) {
    assert!(
        reinsert_order.validate_bulk_order_reinsertion_request(original_order),
        E_REINSERT_ORDER_MISMATCH
    );
    let account = reinsert_order.get_account_from_match_details();
    let order_option = self.orders.remove_or_none(&account);
    assert!(order_option.is_some(), EORDER_NOT_FOUND);
    let order = order_option.destroy_some();
    cancel_active_orders(price_time_idx, &order);
    bulk_order_utils::reinsert_order_into_bulk_order(&mut order, &reinsert_order);
    activate_first_price_levels(
        price_time_idx, &order, reinsert_order.get_order_id_from_match_details()
    );
    self.orders.add(account, order);
}

public(friend) fun cancel_bulk_order<M: store + copy + drop>(
    self: &mut BulkOrderBook<M>,
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    account: address
): BulkOrder<M> {
    // For cancellation, instead of removing the order, we will just cancel the active orders and set the sizes to 0.
    // This allows us to reuse the order id for the same account in the future without creating a new order.
    let order_opt = self.orders.remove_or_none(&account);
    assert!(order_opt.is_some(), EORDER_NOT_FOUND);
    let order = order_opt.destroy_some();
    let order_copy = order;
    cancel_active_orders(price_time_idx, &order);
    order.set_empty();
    self.orders.add(account, order);
    order_copy
}

public(friend) fun cancel_bulk_order_at_price<M: store + copy + drop>(
    self: &mut BulkOrderBook<M>,
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    account: address,
    price: u64,
    is_bid: bool
): (u64, BulkOrder<M>) {
    let order_opt = self.orders.remove_or_none(&account);
    assert!(order_opt.is_some(), EORDER_NOT_FOUND);
    let order = order_opt.destroy_some();

    // Check if the price to cancel is the currently active price
    let active_price = order.get_order_request().get_active_price(is_bid);
    let was_active = active_price.is_some() && active_price.destroy_some() == price;

    // If this was the active price level, we need to cancel it from the active order book first
    if (was_active) {
        cancel_active_order_for_side(price_time_idx, &order, is_bid);
    };

    // Cancel the specific price level
    let cancelled_size =
        bulk_order_utils::cancel_at_price_level(&mut order, price, is_bid);

    // If this was the active price level, activate the next price level if available
    if (was_active) {
        let order_id = order.get_order_id();
        activate_first_price_level_for_side(price_time_idx, &order, order_id, is_bid);
    };

    let order_copy = order;
    self.orders.add(account, order);
    (cancelled_size, order_copy)
}

public(friend) fun get_bulk_order<M: store + copy + drop>(
    self: &BulkOrderBook<M>, account: address
): BulkOrder<M> {
    let result = self.orders.get(&account);
    assert!(result.is_some(), EORDER_NOT_FOUND);
    result.destroy_some()
}

public(friend) fun get_remaining_size<M: store + copy + drop>(
    self: &BulkOrderBook<M>, account: address, is_bid: bool
): u64 {
    let result_option =
        self.orders.get_and_map(
            &account,
            |order| order.get_order_request().get_total_remaining_size(is_bid)
        );
    assert!(result_option.is_some(), EORDER_NOT_FOUND);
    result_option.destroy_some()
}

public(friend) fun get_prices<M: store + copy + drop>(
    self: &BulkOrderBook<M>, account: address, is_bid: bool
): vector<u64> {
    let result_option =
        self.orders.get_and_map(
            &account,
            |order| order.get_order_request().get_all_prices(is_bid)
        );
    assert!(result_option.is_some(), EORDER_NOT_FOUND);
    result_option.destroy_some()
}

public(friend) fun get_sizes<M: store + copy + drop>(
    self: &BulkOrderBook<M>, account: address, is_bid: bool
): vector<u64> {
    let result_option =
        self.orders.get_and_map(
            &account,
            |order| order.get_order_request().get_all_sizes(is_bid)
        );
    assert!(result_option.is_some(), EORDER_NOT_FOUND);
    result_option.destroy_some()
}

public(friend) fun place_bulk_order<M: store + copy + drop>(
    self: &mut BulkOrderBook<M>,
    price_time_idx: &mut aptos_experimental::price_time_index::PriceTimeIndex,
    order_req: BulkOrderRequest<M>
): BulkOrderPlaceResponse<M> {
    let account = order_req.get_account();
    let new_sequence_number = order_req.get_sequence_number();
    let order_option = self.orders.remove_or_none(&account);
    let (order_id, previous_seq_num) =
        if (order_option.is_some()) {
            let old_order = order_option.destroy_some();
            let existing_sequence_number =
                old_order.get_order_request().get_sequence_number();
            // Return rejection response instead of aborting
            if (new_sequence_number <= existing_sequence_number) {
                // Put the old order back
                self.orders.add(account, old_order);
                return new_bulk_order_place_response_rejection(
                    account,
                    new_sequence_number,
                    existing_sequence_number
                )
            };
            cancel_active_orders(price_time_idx, &old_order);
            (old_order.get_order_id(), std::option::some(existing_sequence_number))
        } else {
            let order_id = next_order_id();
            self.order_id_to_address.add(order_id, account);
            (order_id, std::option::none())
        };
    let (
        bulk_order,
        cancelled_bid_prices,
        cancelled_bid_sizes,
        cancelled_ask_prices,
        cancelled_ask_sizes
    ) =
        bulk_order_utils::new_bulk_order_with_sanitization(
            order_id,
            next_increasing_idx_type(),
            order_req,
            price_time_idx.best_bid_price(),
            price_time_idx.best_ask_price()
        );
    self.orders.add(account, bulk_order);
    // Activate the first price levels in the active order book
    activate_first_price_levels(price_time_idx, &bulk_order, order_id);
    new_bulk_order_place_response_success(
        bulk_order,
        cancelled_bid_prices,
        cancelled_bid_sizes,
        cancelled_ask_prices,
        cancelled_ask_sizes,
        previous_seq_num
    )
}