use std::time::SystemTime;

use elseware::common::serverstate::{ClientId, ServerState};
use elseware::entity::gateway::{EntityGateway, InMemoryGateway};
use elseware::entity::account::{UserAccountEntity, NewUserAccountEntity, NewUserSettingsEntity};
use elseware::entity::character::{CharacterEntity, NewCharacterEntity};
//use elseware::entity::item::{NewItemEntity, ItemDetail, ItemLocation};
use elseware::entity::item;
use elseware::ship::ship::{ShipServerState, RecvShipPacket};
use elseware::ship::items::{ClientItemId, ActiveItemEntityId, HeldItemType, FloorItemType};

use libpso::packet::ship::*;
use libpso::packet::messages::*;
use libpso::packet::login::{Login, Session};
use libpso::{utf8_to_array, utf8_to_utf16_array};


pub async fn new_user_character<EG: EntityGateway>(entity_gateway: &mut EG, username: &str, password: &str) -> (UserAccountEntity, CharacterEntity) {
    let new_user = NewUserAccountEntity {
        username: username.into(),
        password: bcrypt::hash(password, 5).unwrap(),
        guildcard: 1,
        team_id: None,
        banned: false,
        muted_until: SystemTime::now(),
        created_at: SystemTime::now(),
        flags: 0,
    };

    let user = entity_gateway.create_user(new_user).await.unwrap();
    let new_settings = NewUserSettingsEntity::new(user.id);
    let _settings = entity_gateway.create_user_settings(new_settings).await.unwrap();
    let new_character = NewCharacterEntity::new(user.id);
    let character = entity_gateway.create_character(new_character).await.unwrap();

    (user, character)
}

pub async fn log_in_char<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, username: &str, password: &str) {
    let username = username.to_string();
    let password = password.to_string();
    ship.handle(id, &RecvShipPacket::Login(Login {
        tag: 0,
        guildcard: 0,
        version: 0,
        unknown1: [0; 6],
        team: 0,
        username: utf8_to_array!(username, 16),
        unknown2: [0; 32],
        password: utf8_to_array!(password, 16),
        unknown3: [0; 40],
        hwinfo: [0; 8],
        session: Session::new(),
    })).await.unwrap().for_each(drop);
}

pub async fn join_lobby<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId) {
    ship.handle(id, &RecvShipPacket::CharData(CharData {
        _unknown: [0; 0x828]
    })).await.unwrap().for_each(drop);
}

pub async fn create_room<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, name: &str, password: &str) {
    ship.handle(id, &RecvShipPacket::CreateRoom(CreateRoom {
        unknown: [0; 2],
        name: utf8_to_utf16_array!(name, 16),
        password: utf8_to_utf16_array!(password, 16),
        difficulty: 0,
        battle: 0,
        challenge: 0,
        episode: 1,
        single_player: 0,
        padding: [0; 3],
    })).await.unwrap().for_each(drop);
    ship.handle(id, &RecvShipPacket::DoneBursting(DoneBursting {})).await.unwrap().for_each(drop);
}

pub async fn join_room<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, room_id: u32) {
    ship.handle(id, &RecvShipPacket::MenuSelect(MenuSelect {
        menu: ROOM_MENU_ID,
        item: room_id,
    })).await.unwrap().for_each(drop);
}


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

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

    entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Tool(
                item::tool::Tool {
                    tool: item::tool::ToolType::Monomate
                }
            ),
            location: item::ItemLocation::Inventory {
                character_id: char1.id,
                slot: 0,
                equipped: false,
            }
        }).await;

    for (slot, tool) in vec![item::tool::ToolType::Monomate, item::tool::ToolType::Monofluid].into_iter().enumerate() {
        for _ in 0..5 {
            entity_gateway.create_item(
                item::NewItemEntity {
                    item: item::ItemDetail::Tool(
                        item::tool::Tool {
                            tool: tool
                        }
                    ),
                    location: item::ItemLocation::Inventory {
                        character_id: char2.id,
                        slot: slot,
                        equipped: false,
                    }
                }).await;
        }
    }

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
        client: 0,
        target: 0,
        unknown1: 0,
        area: 0,
        item_id: 0x210000,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0x210000,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 1);
    let inventory_item = p1_inventory.slot(0).unwrap();
    assert!(inventory_item.entity_id == ActiveItemEntityId::Stacked(vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3), item::ItemEntityId(4), item::ItemEntityId(5), item::ItemEntityId(6)]));
    assert!(inventory_item.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 6));
}

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

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

    entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Tool(
                item::tool::Tool {
                    tool: item::tool::ToolType::Monomate
                }
            ),
            location: item::ItemLocation::Inventory {
                character_id: char2.id,
                slot: 0,
                equipped: false,
            }
        }).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
        client: 0,
        target: 0,
        unknown1: 0,
        area: 0,
        item_id: 0x210000,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0x210000,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 1);
    let inventory_item = p1_inventory.slot(0).unwrap();
    assert!(inventory_item.entity_id == ActiveItemEntityId::Stacked(vec![item::ItemEntityId(1)]));
    assert!(inventory_item.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 1));
}

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

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

    for slot in 0..30 {
        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,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char1.id,
                    slot: slot,
                    equipped: false,
                }
            }).await;
    }

    char2.meseta = 300;
    entity_gateway.save_character(&char2).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        map_area: 0,
        x: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSplitItemStack(PlayerSplitItemStack {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        amount: 23,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0xF0000001,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 30);

    let c1 = ship.clients.get(&ClientId(1)).unwrap();
    let c2 = ship.clients.get(&ClientId(2)).unwrap();
    assert!(c1.character.meseta == 23);
    assert!(c2.character.meseta == 277);
}

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

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

    for slot in 0..29 {
        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,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char1.id,
                    slot: slot,
                    equipped: false,
                }
            }).await;
    }

    entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Tool(
                item::tool::Tool {
                    tool: item::tool::ToolType::Monomate,
                }
            ),
            location: item::ItemLocation::Inventory {
                character_id: char1.id,
                slot: 29,
                equipped: false,
            }
        }).await;
    entity_gateway.create_item(
        item::NewItemEntity {
            item: item::ItemDetail::Tool(
                item::tool::Tool {
                    tool: item::tool::ToolType::Monomate,
                }
            ),
            location: item::ItemLocation::Inventory {
                character_id: char2.id,
                slot: 0,
                equipped: false,
            }
        }).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
        client: 0,
        target: 0,
        unknown1: 0,
        area: 0,
        item_id: 0x210000,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0x210000,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 30);

    let monomates = p1_inventory.slot(29).unwrap();
    assert!(monomates.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 2));
}

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

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

    for slot in 0..30 {
        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,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char1.id,
                    slot: slot,
                    equipped: false,
                }
            }).await;
    }

    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,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char2.id,
                    slot: 0,
                    equipped: false,
                }
            }).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
        client: 0,
        target: 0,
        unknown1: 0,
        area: 0,
        item_id: 0x210000,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0x210000,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 30);
    let floor_item = ship.item_manager.get_floor_item_by_id(&char1, ClientItemId(0x210000)).unwrap();
    assert!(floor_item.item_id == ClientItemId(0x210000));
}

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

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

    char1.meseta = 300;
    entity_gateway.save_character(&char1).await;

    let mut ship = ShipServerState::new(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::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        map_area: 0,
        x: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    let split_attempt = ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSplitItemStack(PlayerSplitItemStack {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        amount: 301,
    })))).await;
    assert!(split_attempt.is_err());

    let c1 = ship.clients.get(&ClientId(1)).unwrap();
    assert!(c1.character.meseta == 300);
    assert!(ship.item_manager.get_floor_item_by_id(&char1, ClientItemId(0xF0000001)).is_err())
}

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

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

    for _ in 0..6 {
        entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char1.id,
                    slot: 0,
                    equipped: false,
                }
            }).await;
    }
    for _ in 0..6 {
        entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char2.id,
                    slot: 0,
                    equipped: false,
                }
            }).await;
    }

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
        client: 0,
        target: 0,
        unknown1: 0,
        area: 0,
        item_id: 0x210000,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0x210000,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    let monomates = p1_inventory.slot(0).unwrap();
    assert!(monomates.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 6));
    let floor_monomates = ship.item_manager.get_floor_item_by_id(&char1, ClientItemId(0x210000)).unwrap();
    assert!(floor_monomates.item == FloorItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 6));
}

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

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

    char1.meseta = 999999;
    entity_gateway.save_character(&char1).await;
    char2.meseta = 300;
    entity_gateway.save_character(&char2).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        map_area: 0,
        x: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSplitItemStack(PlayerSplitItemStack {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        amount: 23,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0xF0000001,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let c1 = ship.clients.get(&ClientId(1)).unwrap();
    let c2 = ship.clients.get(&ClientId(2)).unwrap();
    assert!(c1.character.meseta == 999999);
    assert!(c2.character.meseta == 277);

    let floor_meseta = ship.item_manager.get_floor_item_by_id(&char1, ClientItemId(0xF0000001)).unwrap();
    assert!(floor_meseta.item == FloorItemType::Meseta(item::Meseta(23)));
}

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

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

    char1.meseta = 999998;
    entity_gateway.save_character(&char1).await;
    char2.meseta = 300;
    entity_gateway.save_character(&char2).await;

    let mut ship = ShipServerState::new(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(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        map_area: 0,
        x: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSplitItemStack(PlayerSplitItemStack {
        client: 0,
        target: 0,
        item_id: 0xFFFFFFFF,
        amount: 23,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0xF0000001,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let c1 = ship.clients.get(&ClientId(1)).unwrap();
    let c2 = ship.clients.get(&ClientId(2)).unwrap();
    assert!(c1.character.meseta == 999999);
    assert!(c2.character.meseta == 277);

    let floor_meseta = ship.item_manager.get_floor_item_by_id(&char1, ClientItemId(0xF0000001));
    assert!(floor_meseta.is_err());
}

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

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

    for _ in 0..5 {
        entity_gateway.create_item(
            item::NewItemEntity {
                item: item::ItemDetail::Tool(
                    item::tool::Tool {
                        tool: item::tool::ToolType::Monomate,
                    }
                ),
                location: item::ItemLocation::Inventory {
                    character_id: char1.id,
                    slot: 0,
                    equipped: false,
                }
            }).await;
    }

    let mut ship = ShipServerState::new(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::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
        client: 0,
        target: 0,
        item_id: 0x10000,
        map_area: 0,
        x: 0.0,
        z: 0.0,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSplitItemStack(PlayerSplitItemStack {
        client: 0,
        target: 0,
        item_id: 0x10000,
        amount: 2,
    })))).await.unwrap().for_each(drop);

    ship.handle(ClientId(2), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
        client: 0,
        target: 0,
        item_id: 0xF0000001,
        area: 0,
        unknown: [0; 3]
    })))).await.unwrap().for_each(drop);

    let p1_inventory = ship.item_manager.get_character_inventory(&char1).unwrap();
    assert!(p1_inventory.count() == 1);
    let inventory_item = p1_inventory.slot(0).unwrap();
    assert!(inventory_item.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 3));

    let p2_inventory = ship.item_manager.get_character_inventory(&char2).unwrap();
    assert!(p2_inventory.count() == 1);
    let inventory_item = p2_inventory.slot(0).unwrap();
    assert!(inventory_item.item == HeldItemType::Stacked(item::tool::Tool {tool: item::tool::ToolType::Monomate}, 2));
}