elseware/src/ship/ship.rs

use std::collections::HashMap;
use log::warn;

use rand::Rng;

use libpso::packet::ship::*;
use libpso::packet::login::{Login, LoginResponse, AccountStatus, Session};
use libpso::packet::messages::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::bb::PSOBBCipher;
use libpso::character::character;
use libpso::packet::ship::{BLOCK_MENU_ID, ROOM_MENU_ID};
use libpso::{utf8_to_array, utf8_to_utf16_array};

use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
use crate::common::leveltable::CharacterLevelTable;

use crate::entity::gateway::EntityGateway;
use crate::entity::account::{UserAccountEntity, UserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
use crate::entity::character::CharacterEntity;
use crate::entity::item::{ItemLocation, ItemEntity};
use crate::login::login::get_login_status;
use crate::ship::location::{ClientLocation, LobbyId, RoomId, RoomLobby, MAX_ROOMS};
use crate::ship::character::{CharacterBytesBuilder, FullCharacterBytesBuilder};
use crate::ship::items;
use crate::ship::room;

pub const SHIP_PORT: u16 = 23423;

#[derive(Debug)]
pub enum ShipError {
    ClientNotFound(ClientId),
    NoCharacterInSlot(ClientId, u32),
    InvalidSlot(ClientId, u32),
    TooManyClients,
    ClientError(String),
    InvalidRoom(u32),
}

#[derive(Debug)]
pub enum RecvShipPacket {
    Login(Login),
    MenuSelect(MenuSelect),
    CharData(CharData),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
    CreateRoom(CreateRoom),
    RoomNameRequest(RoomNameRequest),
    UpdateConfig(UpdateConfig),
    ViewInfoboardRequest(ViewInfoboardRequest),
    WriteInfoboard(WriteInfoboard),
    RoomListRequest(RoomListRequest),
    Like62ButCooler(Like62ButCooler),
    ClientCharacterData(ClientCharacterData),
    DoneBursting(DoneBursting),
}

impl RecvServerPacket for RecvShipPacket {
    fn from_bytes(data: &[u8]) -> Result<RecvShipPacket, PacketParseError> {
        match u16::from_le_bytes([data[2], data[3]]) {
            0x93 => Ok(RecvShipPacket::Login(Login::from_bytes(data)?)),
            0x10 => Ok(RecvShipPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
            0x61 => Ok(RecvShipPacket::CharData(CharData::from_bytes(data)?)),
            0x60 => Ok(RecvShipPacket::Message(Message::from_bytes(data)?)),
            0x62 => Ok(RecvShipPacket::DirectMessage(DirectMessage::from_bytes(data)?)),
            0x06 => Ok(RecvShipPacket::PlayerChat(PlayerChat::from_bytes(data)?)),
            0xC1 => Ok(RecvShipPacket::CreateRoom(CreateRoom::from_bytes(data)?)),
            0x8A => Ok(RecvShipPacket::RoomNameRequest(RoomNameRequest::from_bytes(data)?)),
            0x7ED => Ok(RecvShipPacket::UpdateConfig(UpdateConfig::from_bytes(data)?)),
            0xD8 => Ok(RecvShipPacket::ViewInfoboardRequest(ViewInfoboardRequest::from_bytes(data)?)),
            0xD9 => Ok(RecvShipPacket::WriteInfoboard(WriteInfoboard::from_bytes(data)?)),
            0x08 => Ok(RecvShipPacket::RoomListRequest(RoomListRequest::from_bytes(data)?)),
            0x6D => Ok(RecvShipPacket::Like62ButCooler(Like62ButCooler::from_bytes(data)?)),
            0x98 => Ok(RecvShipPacket::ClientCharacterData(ClientCharacterData::from_bytes(data)?)),
            0x6F => Ok(RecvShipPacket::DoneBursting(DoneBursting::from_bytes(data)?)),
            _ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
        }
    }
}

#[derive(Debug, Clone)]
pub enum SendShipPacket {
    ShipWelcome(ShipWelcome),
    LoginResponse(LoginResponse),
    ShipBlockList(ShipBlockList),
    FullCharacter(FullCharacter),
    CharDataRequest(CharDataRequest),
    JoinLobby(JoinLobby),
    AddToLobby(AddToLobby),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
    SmallDialog(SmallDialog),
    JoinRoom(JoinRoom),
    AddToRoom(AddToRoom),
    LeaveLobby(LeaveLobby),
    LeaveRoom(LeaveRoom),
    RoomNameResponse(RoomNameResponse),
    ViewInfoboardResponse(ViewInfoboardResponse),
    RoomListResponse(RoomListResponse),
    Like62ButCooler(Like62ButCooler),
    BurstDone72(BurstDone72),
    DoneBursting(DoneBursting),
}

impl SendServerPacket for SendShipPacket {
    fn as_bytes(&self) -> Vec<u8> {
        match self {
            SendShipPacket::ShipWelcome(pkt) => pkt.as_bytes(),
            SendShipPacket::LoginResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::ShipBlockList(pkt) => pkt.as_bytes(),
            SendShipPacket::FullCharacter(pkt) => pkt.as_bytes(),
            SendShipPacket::CharDataRequest(pkt) => pkt.as_bytes(),
            SendShipPacket::JoinLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::AddToLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::Message(pkt) => pkt.as_bytes(),
            SendShipPacket::DirectMessage(pkt) => pkt.as_bytes(),
            SendShipPacket::PlayerChat(pkt) => pkt.as_bytes(),
            SendShipPacket::SmallDialog(pkt) => pkt.as_bytes(),
            SendShipPacket::JoinRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::AddToRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::LeaveLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::LeaveRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::RoomNameResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::ViewInfoboardResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::RoomListResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::Like62ButCooler(pkt) => pkt.as_bytes(),
            SendShipPacket::BurstDone72(pkt) => pkt.as_bytes(),
            SendShipPacket::DoneBursting(pkt) => pkt.as_bytes(),
        }
    }
}

struct ClientState {
    user: UserAccountEntity,
    settings: UserSettingsEntity,
    character: CharacterEntity,
    session: Session,
    //guildcard: GuildCard,
    inventory: items::ActiveInventory,
    //bank: Bank,
    block: u32,
}

impl ClientState {
    fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, inventory: items::ActiveInventory, /*bank: Bank,*/ session: Session) -> ClientState {
        ClientState {
            user: user,
            settings: settings,
            character: character,
            session: session,
            inventory: inventory,
            //bank: bank,
            block: 1,
        }
    }
}


pub struct ShipServerState<EG: EntityGateway> {
    entity_gateway: EG,
    clients: HashMap<ClientId, ClientState>,
    client_location: ClientLocation,
    level_table: CharacterLevelTable,
    name: String,
    rooms: [Option<room::RoomState>; MAX_ROOMS],
    item_database: items::ActiveItemDatabase,
}

impl<EG: EntityGateway> ShipServerState<EG> {
    pub fn new(entity_gateway: EG) -> ShipServerState<EG> {
        ShipServerState {
            entity_gateway: entity_gateway,
            clients: HashMap::new(),
            client_location: ClientLocation::new(),
            level_table: CharacterLevelTable::new(),
            name: "Sona-Nyl".into(),
            rooms: [None; MAX_ROOMS],
            item_database: items::ActiveItemDatabase::new(),
        }
    }

    fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendShipPacket>, ShipError> {
        Ok(match get_login_status(&self.entity_gateway, pkt) {
            Ok(user) => {
                let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
                response.guildcard = user.id.0 as u32;
                response.team_id = user.team_id.map_or(31, |ti| ti) as u32;
                let characters = self.entity_gateway.get_characters_by_user(&user);
                let character = characters
                    .get(pkt.session.character_slot as usize)
                    .ok_or(ShipError::InvalidSlot(id, pkt.session.character_slot as u32))?.as_ref()
                    .ok_or(ShipError::NoCharacterInSlot(id, pkt.session.character_slot as u32))?
                    .clone();
                let settings = self.entity_gateway.get_user_settings_by_user(&user)
                    .ok_or(ShipError::ClientNotFound(id))?;
                let inventory = self.item_database.get_character_inventory(&mut self.entity_gateway, &character);

                self.clients.insert(id, ClientState::new(user, settings, character, inventory, pkt.session));
                vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(&self.name, 3))]
            },
            Err(err) => {
                vec![SendShipPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]
            }
        })
    }

    fn block_selected(&mut self, id: ClientId, pkt: &MenuSelect) -> Result<Vec<SendShipPacket>, ShipError> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
        client.block = pkt.item as u32;

        let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);

        let fc = FullCharacterBytesBuilder::new()
            .character(&client.character)
            .stats(&stats)
            .level(level)
            .inventory(&client.inventory)
            .key_config(&client.settings.settings.key_config)
            .joystick_config(&client.settings.settings.joystick_config)
            .build();

        Ok(vec![
            SendShipPacket::FullCharacter(FullCharacter {
                character: fc,
            }),
            SendShipPacket::CharDataRequest(CharDataRequest {}),
        ])
    }

    fn join_room(&mut self, id: ClientId, pkt: &MenuSelect) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
        let original_area = self.client_location.get_area(id).unwrap();
        let original_neighbors = self.client_location.get_client_neighbors(id).unwrap();
        let room = self.rooms.get(pkt.item as usize)
            .ok_or_else(|| ShipError::InvalidRoom(pkt.item))?.as_ref()
            .ok_or_else(|| ShipError::InvalidRoom(pkt.item))?;
        if room.bursting {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))])
        }
        let room_id = RoomId(pkt.item as usize);
        let original_room_clients = self.client_location.get_clients_in_room(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
        self.client_location.add_client_to_room(id, room_id).unwrap(); // TODO: show room full error or whatever

        let all_clients = self.client_location.get_clients_in_room(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
        let player_headers = all_clients.iter()
            .enumerate()
            .fold([PlayerHeader::default(); 4], |mut acc, (i, c)| {
                let header_client = self.clients.get(&c.client).ok_or(ShipError::ClientNotFound(id)).unwrap();
                acc[i] = PlayerHeader {
                    tag: 0x100,
                    guildcard: header_client.user.id.0,
                    _unknown1: [0,0,0, c.local_client.id() as u32, 0],
                    client_id: 0,
                    name: libpso::utf8_to_utf16_array!(header_client.character.name, 16),
                    _unknown2: 2,
                };
                acc
            });

        let area_client = self.client_location.get_local_client(id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
        let leader = self.client_location.get_room_leader(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;

        let join_room = JoinRoom {
            flag: all_clients.len() as u32,
            maps: room.map_headers(),
            players: player_headers,
            client: area_client.local_client.id(),
            leader: leader.local_client.id(),
            one: 1,
            difficulty: room.mode.difficulty().into(),
            battle: matches!(room.mode, room::RoomMode::Battle {..}) as u8,
            event: 0,
            section: room.section_id.into(),
            challenge: matches!(room.mode, room::RoomMode::Challenge {..}) as u8,
            random_seed: room.random_seed,
            episode: room.mode.episode().into(),
            one2: 1,
            single_player: 0, // TODO
            unknown: 0,
        };

        let client = self.clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
        let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
        let c = CharacterBytesBuilder::new()
            .character(&client.character)
            .stats(&stats)
            .level(level - 1)
            .build();
        let add_to = AddToRoom {
            flag: 0x10000,
            client: area_client.local_client.id(),
            leader: leader.local_client.id(),
            one: 0, // TODO: ??????????
            lobby: 0xff,
            block: 0,
            event: 0,
            padding: 1,
            playerinfo: PlayerInfo {
                header: PlayerHeader {
                    tag: 0x10000,
                    guildcard: client.user.id.0,
                    _unknown1: [0; 5],
                    client_id: area_client.local_client.id() as u32,
                    name: libpso::utf8_to_utf16_array!(client.character.name, 16),
                    _unknown2: 2,
                },
                inventory: character::Inventory {
                    item_count: 0,
                    hp_mats_used: 0,
                    tp_mats_used: 0,
                    language: 0,
                    items: [character::InventoryItem::default(); 30], // TOOD: this should be something
                },
                character: c,
            },
        };

        let result = vec![(id, SendShipPacket::JoinRoom(join_room))]
           .into_iter()
           .chain(original_room_clients.clone().into_iter()
                  .map(|c| (c.client, SendShipPacket::AddToRoom(add_to.clone())))
           );

        let room = self.rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
        room.bursting = true;
        if let Ok(leader) = self.client_location.get_area_leader(original_area) {
            let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
            Ok(result.chain(original_neighbors.into_iter()
                         .map(|c| (c.client, leave_lobby.clone()))).collect())
        }
        else {
            Ok(result.collect())
        }
    }

    fn send_player_to_lobby(&mut self, id: ClientId, _pkt: &CharData) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
        let lobby = self.client_location.add_client_to_next_available_lobby(id, LobbyId(0)).map_err(|_| ShipError::TooManyClients)?;
        let clients = self.client_location.get_clients_in_lobby(lobby).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
        let playerinfo = clients.iter()
            .map(|room_client| {
                let client = self.clients.get(&room_client.client).ok_or(ShipError::ClientNotFound(id)).unwrap();
                let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
                let c = CharacterBytesBuilder::new()
                    .character(&client.character)
                    .stats(&stats)
                    .level(level - 1)
                    .build();
                PlayerInfo {
                    header: PlayerHeader {
                        tag: 0x100,
                        guildcard: client.user.id.0,
                        _unknown1: [0; 5],
                        client_id: room_client.local_client.id() as u32,
                        name: c.name,
                        _unknown2: 2,
                    },
                    inventory: character::Inventory {
                        item_count: 0,
                        hp_mats_used: 0,
                        tp_mats_used: 0,
                        language: 0,
                        items: [character::InventoryItem::default(); 30],
                    },
                    character: c,
                }
            });
        let area_client = self.client_location.get_local_client(id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
        let leader = self.client_location.get_lobby_leader(lobby).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;

        let join_lobby = JoinLobby {
            client: area_client.local_client.id(),
            leader: leader.local_client.id(),
            one: 1,
            lobby: lobby.id(),
            block: 1,
            event: 0,
            padding: 0,
            playerinfo: playerinfo.collect(),
        };

        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
        let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
        let c = CharacterBytesBuilder::new()
            .character(&client.character)
            .stats(&stats)
            .level(level - 1)
            .build();
        let addto = AddToLobby {
            flag: 1,
            client: area_client.local_client.id(),
            leader: leader.local_client.id(),
            one: 1,
            lobby: lobby.id(),
            block: 1,
            event: 0,
            padding: 0,
            playerinfo: PlayerInfo {
                header: PlayerHeader {
                    tag: 0x100,
                    guildcard: client.user.id.0,
                    _unknown1: [0; 5],
                    client_id: area_client.local_client.id() as u32,
                    name: c.name,
                    _unknown2: 2,
                },
                inventory: character::Inventory {
                    item_count: 0,
                    hp_mats_used: 0,
                    tp_mats_used: 0,
                    language: 0,
                    items: [character::InventoryItem::default(); 30],
                },
                character: c,
            },
        };

        let neighbors = self.client_location.get_client_neighbors(id).unwrap();
        Ok(vec![(id, SendShipPacket::JoinLobby(join_lobby))]
            .into_iter()
            .chain(neighbors.into_iter()
                   .map(|c| (c.client, SendShipPacket::AddToLobby(addto.clone())))).collect())
    }

    fn done_bursting(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let area = self.client_location.get_area(id).unwrap();
        if let RoomLobby::Room(room_id) = area {
            let room = self.rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
            room.bursting = false;
        }
        Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
                 .map(move |client| {
                     vec![
                         (client.client, SendShipPacket::BurstDone72(BurstDone72::new())),
                     ]
                 }).flatten())
    }

    fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        match &msg.msg {
            GameMessage::RequestExp(killmonster) => {
                match self.client_location.get_area(id).unwrap() {
                    RoomLobby::Room(room) => {
                        let r  = self.rooms[room.0].as_ref().unwrap();
                        warn!("killed a {:?}", r.maps.enemy_by_id(killmonster.enemy_id as usize).monster);
                    },
                    _ => {}
                }
            },
            _ => {},
        }

        let cmsg = msg.clone();
        Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
                 .map(move |client| {
                     (client.client, SendShipPacket::Message(cmsg.clone()))
                 }))
    }

    /*fn generate_item_drop(&mut self, id: ClientId, monster: MonsterType) -> Option<ActiveItem> {
        let room = self.rooms[self.client_location.get_area_by_user(id).index];
        let item_drop = room.drop_table.get_drop()
    }*/

    fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let cmsg = msg.clone();
        let client = self.clients.get_mut(&id).unwrap();
        match &cmsg.msg {
            GameMessage::GuildcardSend(guildcard_send) => {
                let out_msg = DirectMessage{
                    flag: cmsg.flag,
                    msg: GameMessage::GuildcardRecv(GuildcardRecv {
                        client: guildcard_send.client,
                        target: guildcard_send.target,
                        guildcard: client.user.id.0,
                        name: utf8_to_utf16_array!(client.character.name, 0x18),
                        team: [0; 0x10], // TODO: teams not yet implemented
                        desc: utf8_to_utf16_array!(client.character.guildcard.description, 0x58),
                        one: 1,
                        language: 0, // TODO: add language flag to character
                        section_id: client.character.section_id.into(),
                        class: client.character.char_class.into(),
                    }),
                };
                let msg_flag = cmsg.flag as u8;
                Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                    .filter(move |client| client.local_client.id() == msg_flag)
                    .map(move |client| {
                        (client.client, SendShipPacket::DirectMessage(out_msg.clone()))
                    }))
            },
            /*GameMessage::RequestItem(req_item) => {
                let item = self.generate_item_drop(id);
                Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(ItemDrop {
                    client: req_item.client,
                    target: req_item.target,
                    area: req_item.area,
                    variety: 0,
                    unknown: 0,
                    x: req_item.x,
                    z: req_item.z,
                    unknown2: 0,
                    item_bytes: item[0..12].try_into().unwrap(),
                    item_id: 0,
                    item_bytes2: item[12..16].try_into().unwrap(),
                    unknown3: 0,
                }))))].into_iter())
            },*/
            _ => {
                let msg_flag = cmsg.flag as u8;
                Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                    .filter(move |client| client.local_client.id() == msg_flag)
                    .map(move |client| {
                        (client.client, SendShipPacket::DirectMessage(cmsg.clone()))
                    }))
            },
        }
    }

    fn player_chat(&mut self, id: ClientId, msg: &PlayerChat) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
        let cmsg = PlayerChat::new(client.user.id.0, msg.message.clone());

        Ok(Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                .map(move |client| {
                    (client.client, SendShipPacket::PlayerChat(cmsg.clone()))
                })))
    }

    fn create_room(&mut self, id: ClientId, create_room: &CreateRoom) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let area = self.client_location.get_area(id).unwrap();
        let area_client = self.client_location.get_local_client(id).unwrap();
        let lobby_neighbors = self.client_location.get_client_neighbors(id).unwrap();
        let room_id = self.client_location.create_new_room(id).unwrap();

        let client = self.clients.get_mut(&id).unwrap();//.ok_or(ShipError::ClientNotFound(id)).unwrap();
        let mut room = room::RoomState::from_create_room(create_room, client.character.section_id).unwrap();
        room.bursting = true;

        let players = [PlayerHeader {
            tag: 0x10000,
            guildcard: client.user.id.0,
            _unknown1: [0; 5],
            client_id: 0,
            name: libpso::utf8_to_utf16_array!(client.character.name, 16),
            _unknown2: 2,
        }, PlayerHeader::default(), PlayerHeader::default(), PlayerHeader::default()];

        let join_room = JoinRoom {
            flag: 1,
            maps: room.maps.map_headers(),
            players: players,
            client: 0,
            leader: 0,
            one: 1,
            difficulty: create_room.difficulty,
            battle: create_room.battle,
            event: 0,
            section: 0, // TODO
            challenge: create_room.challenge,
            random_seed: 23, // TODO
            episode: create_room.episode,
            one2: 1,
            single_player: create_room.single_player,
            unknown: 0,
        };
        self.rooms[room_id.0] = Some(room);

        let leader = self.client_location.get_area_leader(area);
        let result = vec![(id, SendShipPacket::JoinRoom(join_room))].into_iter();
        match leader {
            Ok(leader) => Box::new(result.chain(lobby_neighbors
                                                .into_iter()
                                                .map(move |c| {
                                                    (c.client, SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id())))
                                                }))),
            Err(_) => Box::new(result)
        }
    }

    fn room_name_request(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let area = self.client_location.get_area(id).unwrap();
        match area {
            RoomLobby::Room(room) => Box::new(vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {name: self.rooms[room.0].as_ref().unwrap().name.clone()}))].into_iter()),
            RoomLobby::Lobby(_) => panic!()
        }
    }

    fn update_config(&mut self, id: ClientId, update_config: &UpdateConfig) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        client.character.config.update(update_config);
        self.entity_gateway.save_character(&client.character);
        Box::new(None.into_iter())
    }

    fn request_infoboard(&mut self, id: ClientId, request_infoboard: &ViewInfoboardRequest) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let clients = self.client_location.get_client_neighbors(id).unwrap();
        let r = clients.iter()
            .filter_map(|c| {
                self.clients.get(&c.client)
            })
            .map(|client| {
                InfoboardResponse {
                    name: libpso::utf8_to_utf16_array!(client.character.name, 16),
                    message: client.character.info_board.as_bytes(),
                }
            }).collect();
        Box::new(vec![(id, SendShipPacket::ViewInfoboardResponse(ViewInfoboardResponse {response: r}))].into_iter())
    }

    fn write_infoboard(&mut self, id: ClientId, new_infoboard: &WriteInfoboard) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        client.character.info_board.update_infoboard(new_infoboard);
        self.entity_gateway.save_character(&client.character);
        Box::new(None.into_iter())
    }

    fn request_room_list(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let active_room_list = self.rooms.iter()
            .enumerate()
            .filter_map(|(i, r)| {
                r.as_ref().map(|room| {
                    RoomList {
                        menu_id: ROOM_MENU_ID,
                        item_id: i as u32,
                        difficulty: room.get_difficulty_for_room_list(),
                        players: self.client_location.get_clients_in_room(RoomId(i)).unwrap().len() as u8,
                        name: libpso::utf8_to_utf16_array!(room.name, 16),
                        episode: room.get_episode_for_room_list(),
                        flags: room.get_flags_for_room_list(),
                    }
                })
            });
        let baseroom: RoomList = RoomList {
            menu_id: ROOM_MENU_ID,
            item_id: ROOM_MENU_ID,
            difficulty: 0x00,
            players: 0x00,
            name: libpso::utf8_to_utf16_array!("Room list menu", 16),
            episode: 0,
            flags: 0,
        };

        Box::new(vec![(id, SendShipPacket::RoomListResponse(RoomListResponse {
            baseroom,
            rooms: active_room_list.collect()
        }))].into_iter())
    }

    fn cool_62(&mut self, id: ClientId, cool_62: &Like62ButCooler) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let target = cool_62.flag as u8;
        let cool_62 = cool_62.clone();
        Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
                 .filter(move |client| client.local_client.id() == target)
                 .map(move |client| {
                     (client.client, SendShipPacket::Like62ButCooler(cool_62.clone()))
                 }))
    }
}

impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
    type SendPacket = SendShipPacket;
    type RecvPacket = RecvShipPacket;
    type PacketError = ShipError;

    fn on_connect(&mut self, id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
        let mut rng = rand::thread_rng();

        let mut server_key = [0u8; 48];
        let mut client_key = [0u8; 48];
        rng.fill(&mut server_key[..]);
        rng.fill(&mut client_key[..]);

        vec![OnConnect::Packet(SendShipPacket::ShipWelcome(ShipWelcome::new(server_key, client_key))),
             OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
                                Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
        ]
    }

    fn handle(&mut self, id: ClientId, pkt: &RecvShipPacket)
              -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
        Ok(match pkt {
            RecvShipPacket::Login(login) => {
                Box::new(self.validate_login(id, login)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvShipPacket::MenuSelect(menuselect) => {
                match menuselect.menu {
                    BLOCK_MENU_ID => Box::new(self.block_selected(id, menuselect)?.into_iter().map(move |pkt| (id, pkt))),
                    ROOM_MENU_ID => Box::new(self.join_room(id, menuselect)?.into_iter()),
                    _ => unreachable!(),
                }
            },
            RecvShipPacket::CharData(chardata) => {
                Box::new(self.send_player_to_lobby(id, chardata)?.into_iter())
            },
            RecvShipPacket::Message(msg) => {
                self.message(id, msg)
            },
            RecvShipPacket::DirectMessage(msg) => {
                self.direct_message(id, msg)
            },

            RecvShipPacket::PlayerChat(msg) => {
                Box::new(self.player_chat(id, msg)?.into_iter())
            },
            RecvShipPacket::CreateRoom(create_room) => {
                self.create_room(id, create_room)
            },
            RecvShipPacket::RoomNameRequest(_req) => {
                self.room_name_request(id)
            },
            RecvShipPacket::UpdateConfig(pkt) => {
                self.update_config(id, pkt)
            },

            RecvShipPacket::ViewInfoboardRequest(pkt) => {
                self.request_infoboard(id, pkt)
            },

            RecvShipPacket::WriteInfoboard(pkt) => {
                self.write_infoboard(id, pkt)
            },

            RecvShipPacket::RoomListRequest(_req) => {
                self.request_room_list(id)
            },
            RecvShipPacket::Like62ButCooler(cool62) => {
                self.cool_62(id, cool62)
            },
            RecvShipPacket::ClientCharacterData(_) => {
                // TOOD: validate this in some way?
                Box::new(None.into_iter())
            },
            RecvShipPacket::DoneBursting(_) => {
                self.done_bursting(id)
            }
        })
    }

    fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendShipPacket)> {
        let client = self.client_location.get_local_client(id).unwrap();
        let neighbors = self.client_location.get_client_neighbors(id).unwrap();

        let pkt = match self.client_location.get_area(id).unwrap() {
            RoomLobby::Room(room) => {
                let leader = self.client_location.get_room_leader(room).unwrap();
                SendShipPacket::LeaveRoom(LeaveRoom::new(client.local_client.id(), leader.local_client.id()))
            },
            RoomLobby::Lobby(lobby) => {
                let leader = self.client_location.get_lobby_leader(lobby).unwrap();
                SendShipPacket::LeaveLobby(LeaveLobby::new(client.local_client.id(), leader.local_client.id()))
            }
        };

        self.client_location.remove_client_from_area(id);

        neighbors.into_iter().map(|n| {
            (n.client, pkt.clone())
        }).collect()
    }
}