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::{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::{UserAccount, UserSettings, 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, AreaType, 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),
}

#[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),
}

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)?)),
            _ => 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),
}

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(),
        }
    }
}

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

impl ClientState {
    fn new(user: UserAccount, settings: UserSettings, 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 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 send_player_to_lobby(&mut self, id: ClientId, _pkt: &CharData) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
        self.client_location.add_to_lobby(id, LobbyId(0)).unwrap();

        let lobby = self.client_location.get_area_by_user(id);
        let clients = lobby.clients();
        println!("clients in lobby: {:?}", clients);
        let playerinfo = clients.iter()
            .map(|room_client| {
                let client = self.clients.get(&room_client.client_id).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,
                        _unknown1: [0; 5],
                        client_id: room_client.index 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 client_id = clients.iter()
            .fold(0, |acc, k| {
                if k.client_id == id {
                    k.index
                }
                else {
                    acc
                }
            });

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

        let client = self.clients.get_mut(&id).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();
        let addto = AddToLobby {
            flag: 1,
            client: client_id as u8,
            leader: lobby.leader().index as u8,
            one: 1,
            lobby: lobby.id() as u8,
            block: 1,
            event: 0,
            padding: 0,
            playerinfo: PlayerInfo {
                header: PlayerHeader {
                    tag: 0x100,
                    guildcard: client.user.id,
                    _unknown1: [0; 5],
                    client_id: 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 mut v = Vec::new();
        v.push((id, SendShipPacket::JoinLobby(join_lobby)));
        for client in clients {
            if client.client_id != id {
                v.push((client.client_id, SendShipPacket::AddToLobby(addto.clone()))
            )}
        }

        Ok(v)
    }

    fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let cmsg = msg.clone();
        Box::new(self.client_location.get_area_by_user(id).clients().iter()
                 .filter(|client| client.client_id != id)
                 .map(move |client| {
                     (client.client_id, SendShipPacket::Message(cmsg.clone()))
                 }).collect::<Vec<_>>().into_iter())
    }

    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,
                        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(),
                    }),
                };
                Box::new(self.client_location.get_area_by_user(id).clients().iter()
                    .filter(|client| client.index == cmsg.flag as usize)
                    .map(|client| {
                        (client.client_id, SendShipPacket::DirectMessage(out_msg.clone()))
                    }).collect::<Vec<_>>().into_iter())
            },
            _ => {
                Box::new(self.client_location.get_area_by_user(id).clients().iter()
                    .filter(|client| client.index == cmsg.flag as usize)
                    .map(|client| {
                        (client.client_id, SendShipPacket::DirectMessage(cmsg.clone()))
                    }).collect::<Vec<_>>().into_iter())
            },
        }

    }

    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, msg.message.clone());

        Ok(Box::new(self.client_location.get_area_by_user(id).clients().iter()
                .map(move |client| {
                    (client.client_id, SendShipPacket::PlayerChat(cmsg.clone()))
                }).collect::<Vec<_>>().into_iter()))
    }

    fn create_room(&mut self, id: ClientId, create_room: &CreateRoom) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let area = self.client_location.get_area_by_user(id);
        let area_client = area.clients().into_iter().filter(|client| {
            client.client_id == id
        }).next().unwrap();
        let other_clients = area.clients().into_iter()
            .filter(move |c| {
                c.client_id != id
            });
        let room_id = match self.client_location.new_room(id) {
            Ok(room_id) => room_id,
            Err(err) => return Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new(format!("could not create room: {:?}", err))))].into_iter())
        };

        let room = room::RoomState::from_create_room(create_room).unwrap();

        let client = self.clients.get_mut(&id).unwrap();//.ok_or(ShipError::ClientNotFound(id)).unwrap();
        let players = [PlayerHeader {
            tag: 0x00010000,
            guildcard: client.user.id,
            _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_id: 0,
            leader_id: 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 = area.leader();
        Box::new(vec![(id, SendShipPacket::JoinRoom(join_room))].into_iter().chain(other_clients.map(move |c| {
            (c.client_id, SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.index as u8, leader.index as u8)))
        })))
    }

    fn room_name_request(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let area = self.client_location.get_area_by_user(id);
        let room_state = self.rooms[area.id()].as_ref().unwrap();
        Box::new(vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {name: room_state.name.clone()}))].into_iter())
    }

    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.set_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 lobby = self.client_location.get_area_by_user(id);
        let clients = lobby.clients();
        let r = clients
            .iter()
            .filter(|c| c.client_id != id)
            .filter_map(|c| {
                self.clients.get(&c.client_id)
            })
            .map(|c| {
                InfoboardResponse {
                    name: libpso::utf8_to_utf16_array!(c.character.name, 16),
                    message: c.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.set_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_client_count_in_room(RoomId(i)), // TODO
                        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())
    }
}

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))),
                    _ => 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)
            },
        })
    }

    fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendShipPacket)> {
        let mut area = self.client_location.get_area_by_user(id);
        let client = area.clients().into_iter().filter(|client| {
            client.client_id == id
        //}).collect::<Vec<_>>()[0];
        }).next().unwrap();
        let other_clients = area.clients().into_iter().filter(|client| {
            client.client_id != id
        });
        //self.client_location.remove_from_location(id);
        area.remove(id);
        let leader = area.leader();

        let pkt = match area.area_type {
            AreaType::Lobby => SendShipPacket::LeaveLobby(LeaveLobby::new(client.index as u8, leader.index as u8)),
            AreaType::Room => SendShipPacket::LeaveRoom(LeaveRoom::new(client.index as u8, leader.index as u8)),
        };

        other_clients.map(|client| {
            (client.client_id, pkt.clone())
        }).collect()
    }
}