use std::collections::BTreeSet;
use networking::serverstate::{ClientId, ServerState};
use entity::gateway::{EntityGateway, InMemoryGateway};
use entity::item;
use elseware::ship::ship::{ShipServerState, RecvShipPacket, SendShipPacket};

use libpso::packet::ship::*;
use libpso::packet::messages::*;

#[path = "common.rs"]
mod common;
use common::*;

#[async_std::test]
async fn test_bank_items_sent_in_character_login() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let item = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Vulcan,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap();

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;

    let packets = ship.handle(ClientId(1), RecvShipPacket::MenuSelect(MenuSelect {
        menu: BLOCK_MENU_ID,
        item: 1,
    })).await.unwrap();

    assert!(matches!(&packets[0], (_, SendShipPacket::FullCharacter(fc)) if fc.character.bank.items[0].data1[0..3] == [0x00, 0x08, 0x04] ));
}

#[async_std::test]
async fn test_request_bank_items() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut bank = Vec::new();
    for _ in 0..3 {
        bank.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
                     if bank_item_list.item_count == 3
                     && bank_item_list.size == 0x18 * 3 + 0x14
                     && bank_item_list.items[0].data1[0..3] == [0x00, 0x08, 0x04]
                     && bank_item_list.items[1].data1[0..3] == [0x00, 0x08, 0x04]
                     && bank_item_list.items[2].data1[0..3] == [0x00, 0x08, 0x04]
    ));
}


#[async_std::test]
async fn test_request_stacked_bank_items() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..3usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool (
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
                     if bank_item_list.item_count == 1
                     && bank_item_list.size == 0x18 + 0x14
                     && bank_item_list.items[0].data1[0..3] == [0x03, 0x00, 0x00]
                     && bank_item_list.items[0].amount == 3
    ));
}


#[async_std::test]
async fn test_request_bank_items_sorted() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let item1 = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Vulcan,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap();
    let monomate = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Tool (
                item::tool::Tool {
                    tool: item::tool::ToolType::Monomate,
                }
            ),
        }).await.unwrap();
    let item2 = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Calibur,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap();

    let bank = vec![item::BankItemEntity::Individual(item1), vec![monomate].into(), item2.into()];
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
                     if bank_item_list.item_count == 3
                     && bank_item_list.size == 0x18 * 3 + 0x14
                     && bank_item_list.items[0].data1[0..3] == [0x00, 0x02, 0x04]
                     && bank_item_list.items[1].data1[0..3] == [0x00, 0x08, 0x04]
                     && bank_item_list.items[2].data1[0..3] == [0x03, 0x00, 0x00]
    ));
}


#[async_std::test]
async fn test_deposit_individual_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let item0 = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Saber,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap();
    let item1 = entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Handgun,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap();

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![item0, item1])).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10001,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::PlayerNoLongerHasItem(player_no_longer_has_item)}))
                     if player_no_longer_has_item.item_id == 0x10001
                     && player_no_longer_has_item.amount == 0
    ));

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(1));
    }).unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(2));
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_stacked_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..3usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 3,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::PlayerNoLongerHasItem(player_no_longer_has_item)}))
                     if player_no_longer_has_item.item_id == 0x10000
                     && player_no_longer_has_item.amount == 3
    ));

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3)]);
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_partial_stacked_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..3usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::PlayerNoLongerHasItem(player_no_longer_has_item)}))
                     if player_no_longer_has_item.item_id == 0x10000
                     && player_no_longer_has_item.amount == 2
    ));


    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(3)]);
    }).unwrap();
}


#[async_std::test]
async fn test_deposit_stacked_item_with_stack_already_in_bank() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut bank_monomates = Vec::new();
    let mut inventory_monomates = Vec::new();
    for _ in 0..2usize {
        inventory_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());

        bank_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::PlayerNoLongerHasItem(player_no_longer_has_item)}))
                     if player_no_longer_has_item.item_id == 0x10000
                     && player_no_longer_has_item.amount == 2
    ));

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<BTreeSet<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3), item::ItemEntityId(4)].into_iter().collect::<BTreeSet<_>>() );
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_stacked_item_with_full_stack_in_bank() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut inventory_monomates = Vec::new();
    for _ in 0..2usize {
        inventory_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut bank_monomates = Vec::new();
    for _ in 0..10 {
        bank_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.len(), 10);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_individual_item_in_full_bank() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut inventory = Vec::new();
    inventory.push(entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Vulcan,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap());

    let mut bank = Vec::new();
    for _ in 0..200usize {
        bank.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 200);

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(1));
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_stacked_item_in_full_bank() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..2usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut full_bank = Vec::new();
    for _ in 0..200usize {
        full_bank.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(full_bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 200);

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();
}

#[async_std::test]
async fn test_deposit_stacked_item_in_full_bank_with_partial_stack() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..2usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut bank_monomates = Vec::new();
    for _ in 0..2usize {
        bank_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut almost_full_bank: Vec<item::BankItemEntity> = Vec::new();
    for _ in 0..199usize {
        almost_full_bank.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap().into());
    }
    almost_full_bank.push(bank_monomates.into());

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(almost_full_bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 200);
    bank_items.items[199].with_stacked(|items| {
        assert_eq!(items.len(), 4);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 0);
}

#[async_std::test]
async fn test_deposit_meseta() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await.unwrap();

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 277);
    assert!(c1_bank_meseta.0 == 23);
}

#[async_std::test]
async fn test_deposit_too_much_meseta() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(999980)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 300);
    assert!(c1_bank_meseta.0 == 999980);
}

#[async_std::test]
async fn test_deposit_meseta_when_bank_is_maxed() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(999999)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 300);
    assert!(c1_bank_meseta.0 == 999999);
}


#[async_std::test]
async fn test_withdraw_individual_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut bank = Vec::new();
    bank.push(entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Saber,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap());

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::CreateItem(create_item)}))
                     if create_item.item_id == 0x20000
    ));


    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(1));
    }).unwrap();
}

#[async_std::test]
async fn test_withdraw_stacked_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..3usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 3,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::CreateItem(create_item)}))
                     if create_item.item_id == 0x20000
    ));

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3)]);
    }).unwrap();
}

#[async_std::test]
async fn test_withdraw_partial_stacked_item() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..3usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::CreateItem(create_item)}))
                     if create_item.item_id == 0x20001
    ));

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(3)]);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();
}

#[async_std::test]
async fn test_withdraw_stacked_item_with_stack_already_in_inventory() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;

    let mut inventory_monomates = Vec::new();
    let mut bank_monomates = Vec::new();
    for _ in 0..2usize {
        inventory_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());

        bank_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    log_in_char(&mut ship, ClientId(2), "a2", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    join_lobby(&mut ship, ClientId(2)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;
    join_room(&mut ship, ClientId(2), 0).await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    assert!(packets.len() == 2);
    assert!(matches!(&packets[1], (ClientId(2), SendShipPacket::Message(Message {msg: GameMessage::CreateItem(create_item)}))
                     if create_item.item_id == 0x20000
    ));

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 0);

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<BTreeSet<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3), item::ItemEntityId(4)].into_iter().collect::<BTreeSet<_>>());
    }).unwrap();
}

#[async_std::test]
async fn test_withdraw_stacked_item_with_full_stack_in_inventory() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut bank_monomates = Vec::new();
    for _ in 0..2usize {
        bank_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut inventory_monomates = Vec::new();
    for _ in 0..10usize {
        inventory_monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_stacked(|items| {
        assert_eq!(items.len(), 10);
    }).unwrap();
}

#[async_std::test]
async fn test_withdraw_individual_item_in_full_inventory() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut bank = Vec::new();
    bank.push(entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Weapon(
                item::weapon::Weapon {
                    weapon: item::weapon::WeaponType::Vulcan,
                    grind: 0,
                    special: None,
                    attrs: [None, None, None],
                    tekked: true,
                }
            ),
        }).await.unwrap());

    let mut inventory = Vec::new();
    for _ in 0..30usize {
        inventory.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await;
    assert!(packets.is_err());

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 30);
}

#[async_std::test]
async fn test_withdraw_stacked_item_in_full_inventory() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut monomates = Vec::new();
    for _ in 0..2usize {
        monomates.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }

    let mut inventory = Vec::new();
    for _ in 0..30usize {
        inventory.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap());
    }

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packets = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await;

    assert!(packets.is_err());


    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_stacked(|items| {
        assert_eq!(items.iter().map(|i| i.id).collect::<Vec<_>>(),
                   vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 30);
}

#[async_std::test]
async fn test_withdraw_stacked_item_in_full_inventory_with_partial_stack() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let mut bank_item = Vec::new();
    for _ in 0..2usize {
        bank_item.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_item]), &item::BankIdentifier::Character).await.unwrap();

    let mut items = Vec::new();
    for _i in 0..29usize {
        items.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Weapon(
                    item::weapon::Weapon {
                        weapon: item::weapon::WeaponType::Vulcan,
                        grind: 0,
                        special: None,
                        attrs: [None, None, None],
                        tekked: true,
                    }
                ),
            }).await.unwrap().into());
    }

    let mut item29 = Vec::new();
    for _ in 0..2usize {
        item29.push(entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
            }).await.unwrap());
    }
    items.push(item::InventoryItemEntity::Stacked(item29));

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(items)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000,
        action: 1,
        item_amount: 2,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(bank_items.items.len() == 0);

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert!(inventory_items.items.len() == 30);
    match &inventory_items.items[29] {
        item::InventoryItemEntity::Stacked(items) => {
            assert_eq!(items.len(), 4);
        },
        _ => panic!(),
    }
}

#[async_std::test]
async fn test_withdraw_meseta() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await.unwrap();

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 23);
    assert!(c1_bank_meseta.0 == 277);
}

#[async_std::test]
async fn test_withdraw_too_much_meseta() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(999980)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packet = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await;

    assert!(packet.is_err());

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 999980);
    assert!(c1_bank_meseta.0 == 300);
}

#[async_std::test]
async fn test_withdraw_meseta_inventory_is_maxed() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    let packet = ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await;

    assert!(packet.is_err());

    let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert!(c1_meseta.0 == 999999);
    assert!(c1_bank_meseta.0 == 300);
}



#[async_std::test]
async fn test_withdraw_meseta_and_buy_a_few_monomates_with_it() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(100)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 60,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::ShopRequest(ShopRequest {
        client: 255,
        target: 255,
        shop_type: 0,
    })))).await.unwrap();
    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BuyItem(BuyItem {
        client: 255,
        target: 255,
        item_id: 0x10000,
        shop_type: 0,
        shop_index: 0,
        amount: 3,
        unknown1: 0,
    })))).await.unwrap();

    //let c1_meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    //let c1_bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    //assert!(c1_meseta.0 == 23);
    //assert!(c1_bank_meseta.0 == 277);
}

#[async_std::test]
async fn test_deposit_items_into_shared_banks() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let item0 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Saber).as_new()).await.unwrap();
    let item1 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Buster).as_new()).await.unwrap();
    let item2 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Rifle).as_new()).await.unwrap();
    let item3 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Handgun).as_new()).await.unwrap();
    let item4 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Autogun).as_new()).await.unwrap();
    let item5 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Calibur).as_new()).await.unwrap();

    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![item0, item1, item2, item3, item4, item5])).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10000,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank asdf".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10001,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10002,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank qwer".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10003,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/bank".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x10004,
        action: 0,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
    assert_eq!(bank_items.items.len(), 2);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(2));
    }).unwrap();

    bank_items.items[1].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(3));
    }).unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(4));
    }).unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 2);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(1));
    }).unwrap();

    bank_items.items[1].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(5));
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 1);
    inventory_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(6));
    }).unwrap();
}


#[async_std::test]
async fn test_deposit_meseta_into_shared_banks() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank asdf".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 55,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank qwer".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 0,
        item_amount: 0,
        meseta_amount: 32,
        unknown: 0,
    })))).await.unwrap();

    let meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    assert_eq!(meseta.0, 300-23-55-32);

    let bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_meseta.0, 23);
    let bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
    assert_eq!(bank_meseta.0, 55);
    let bank_meseta = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();
    assert_eq!(bank_meseta.0, 32);
}

#[async_std::test]
async fn test_withdraw_items_from_shared_banks() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;

    let item0 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Saber).as_new()).await.unwrap();
    let item1 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Buster).as_new()).await.unwrap();
    let item2 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Rifle).as_new()).await.unwrap();
    let item3 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Handgun).as_new()).await.unwrap();
    let item4 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Autogun).as_new()).await.unwrap();
    let item5 = entity_gateway.create_item(ItemBuilder::weapon(item::weapon::WeaponType::Calibur).as_new()).await.unwrap();

    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item0, item1]), &item::BankIdentifier::Character).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item2, item3]), &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
    entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item4, item5]), &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x20000, // saber (1)
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank asdf".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x810003, // handgun (4)
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x810004, // rifle (3)
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank qwer".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0x810006, // autogun (5)
        action: 1,
        item_amount: 0,
        meseta_amount: 0,
        unknown: 0,
    })))).await.unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
    assert_eq!(bank_items.items.len(), 0);

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(6));
    }).unwrap();

    let bank_items = entity_gateway.get_character_bank(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    assert_eq!(bank_items.items.len(), 1);
    bank_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(2));
    }).unwrap();

    let inventory_items = entity_gateway.get_character_inventory(&char1.id).await.unwrap();
    assert_eq!(inventory_items.items.len(), 4);
    inventory_items.items[0].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(1));
    }).unwrap();
    inventory_items.items[1].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(4));
    }).unwrap();
    inventory_items.items[2].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(3));
    }).unwrap();
    inventory_items.items[3].with_individual(|item| {
        assert_eq!(item.id, item::ItemEntityId(5));
    }).unwrap();
}


#[async_std::test]
async fn test_withdraw_meseta_from_shared_banks() {
    let mut entity_gateway = InMemoryGateway::default();

    let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into())), item::Meseta(300)).await.unwrap();
    entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into())), item::Meseta(300)).await.unwrap();

    let mut ship = standard_ship(entity_gateway.clone());
    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
    join_lobby(&mut ship, ClientId(1)).await;
    create_room(&mut ship, ClientId(1), "room", "").await;

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 23,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank asdf".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 55,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/sbank qwer".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 32,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::PlayerChat(PlayerChat::new(0, "\tE/bank".into()))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
        client: 0,
        target: 0,
        unknown: 0,
    })))).await.unwrap();

    ship.handle(ClientId(1), RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankInteraction(BankInteraction {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        action: 1,
        item_amount: 0,
        meseta_amount: 5,
        unknown: 0,
    })))).await.unwrap();

    let meseta = entity_gateway.get_character_meseta(&char1.id).await.unwrap();
    let bank_meseta1 = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Character).await.unwrap();
    let bank_meseta2 = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
    let bank_meseta3 = entity_gateway.get_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();
    assert_eq!(meseta.0, 23+55+32+5);
    assert_eq!(bank_meseta1.0, 300-23-5);
    assert_eq!(bank_meseta2.0, 300-55);
    assert_eq!(bank_meseta3.0, 300-32);
}