elseware/src/ship/ship.rs

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

use rand::Rng;
use thiserror::Error;

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::ship::location::{ClientLocation, LobbyId, RoomId, RoomLobby, MAX_ROOMS, ClientLocationError};
use crate::ship::character::{CharacterBytesBuilder, FullCharacterBytesBuilder};
use crate::ship::items;
use crate::ship::room;
use crate::ship::map::MapsError;
use crate::ship::packet::handler;

pub const SHIP_PORT: u16 = 23423;
pub type Rooms = [Option<room::RoomState>; MAX_ROOMS];
pub type Clients = HashMap<ClientId, ClientState>;

#[derive(Error, Debug)]
#[error("")]
pub enum ShipError {
    ClientNotFound(ClientId),
    NoCharacterInSlot(ClientId, u32),
    InvalidSlot(ClientId, u32),
    TooManyClients,
    ClientLocationError(#[from] ClientLocationError),
    MapsError(#[from] MapsError),
    InvalidRoom(u32),
    MonsterAlreadyDroppedItem(ClientId, u16),
    SliceError(#[from] std::array::TryFromSliceError),
    ItemError, // TODO: refine this
}

#[derive(Debug)]
pub enum RecvShipPacket {
    Login(Login),
    MenuSelect(MenuSelect),
    RoomPasswordReq(RoomPasswordReq),
    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),
    LobbySelect(LobbySelect),
}

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 => match data[0] {
                16 => Ok(RecvShipPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
                48 => Ok(RecvShipPacket::RoomPasswordReq(RoomPasswordReq::from_bytes(data)?)),
                _ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec())),
            },
            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)?)),
            0x84 => Ok(RecvShipPacket::LobbySelect(LobbySelect::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),
    LobbyList(LobbyList),
}

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(),
            SendShipPacket::LobbyList(pkt) => pkt.as_bytes(),
        }
    }
}

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

impl ClientState {
    pub 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,
            floor_items: Vec::new(),
            block: 1,
        }
    }
}


pub struct ShipServerState<EG: EntityGateway> {
    entity_gateway: EG,
    clients: Clients,
    client_location: ClientLocation,
    level_table: CharacterLevelTable,
    name: String,
    rooms: 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 message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        match &msg.msg {
            GameMessage::RequestExp(request_exp) => {
                handler::message::request_exp(id, request_exp, &self.client_location, &self.rooms)
            },
            _ => {
                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 direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let target = msg.flag;
        match &msg.msg {
            GameMessage::GuildcardSend(guildcard_send) => {
                handler::direct_message::guildcard_send(id, guildcard_send, target, &self.client_location, &self.clients)
            },
            GameMessage::RequestItem(request_item) => {
                handler::direct_message::request_item(id, request_item, &mut self.entity_gateway, &mut self.client_location, &mut self.clients, &mut self.rooms, &mut self.item_database).unwrap()
            },
            _ => {
                let cmsg = msg.clone();
                Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                    .filter(move |client| client.local_client.id() == target as u8)
                    .map(move |client| {
                        (client.client, SendShipPacket::DirectMessage(cmsg.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(handler::auth::validate_login(id, login, &mut self.entity_gateway, &mut self.clients, &mut self.item_database, &self.name)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvShipPacket::MenuSelect(menuselect) => {
                match menuselect.menu {
                    BLOCK_MENU_ID => Box::new(handler::lobby::block_selected(id, menuselect, &mut self.clients, &self.level_table)?.into_iter().map(move |pkt| (id, pkt))),
                    ROOM_MENU_ID => handler::room::join_room(id, menuselect, &mut self.client_location, &mut self.clients, &self.level_table, &mut self.rooms)?,
                    _ => unreachable!(),
                }
            },
            RecvShipPacket::RoomPasswordReq(room_password_req) => {
                if room_password_req.password == self.rooms[room_password_req.item as usize].as_ref()
                    .ok_or(ShipError::InvalidRoom(room_password_req.item))?
                    .password {
                    let menuselect = MenuSelect {
                        menu: room_password_req.menu,
                        item: room_password_req.item,
                    };
                    handler::room::join_room(id, &menuselect, &mut self.client_location, &mut self.clients, &self.level_table, &mut self.rooms)?
                }
                else {
                    Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("Incorrect password".into())))].into_iter())
                }
            },
            RecvShipPacket::CharData(chardata) => {
                Box::new(handler::lobby::send_player_to_lobby(id, chardata, &mut self.client_location, &self.clients, &self.level_table)?.into_iter())
            },
            RecvShipPacket::Message(msg) => {
                self.message(id, msg)
            },
            RecvShipPacket::DirectMessage(msg) => {
                self.direct_message(id, msg)
            },
            RecvShipPacket::PlayerChat(msg) => {
                Box::new(handler::communication::player_chat(id, msg, &self.client_location, &self.clients)?.into_iter())
            },
            RecvShipPacket::CreateRoom(create_room) => {
                handler::room::create_room(id, create_room, &mut self.client_location, &mut self.clients, &mut self.rooms)?
            },
            RecvShipPacket::RoomNameRequest(_req) => {
                handler::room::room_name_request(id, &self.client_location, &self.rooms)
            },
            RecvShipPacket::UpdateConfig(pkt) => {
                handler::settings::update_config(id, pkt, &mut self.clients, &mut self.entity_gateway)
            },
            RecvShipPacket::ViewInfoboardRequest(pkt) => {
                handler::communication::request_infoboard(id, pkt, &self.client_location, &self.clients)
            },
            RecvShipPacket::WriteInfoboard(pkt) => {
                handler::communication::write_infoboard(id, pkt, &mut self.clients, &mut self.entity_gateway)
            },
            RecvShipPacket::RoomListRequest(_req) => {
                handler::room::request_room_list(id, &self.client_location, &self.rooms)
            },
            RecvShipPacket::Like62ButCooler(cool62) => {
                handler::room::cool_62(id, cool62, &self.client_location)
            },
            RecvShipPacket::ClientCharacterData(_) => {
                // TOOD: validate this in some way?
                Box::new(None.into_iter())
            },
            RecvShipPacket::DoneBursting(_) => {
                handler::room::done_bursting(id, &self.client_location, &mut self.rooms)
            },
            RecvShipPacket::LobbySelect(pkt) => {
                Box::new(handler::lobby::change_lobby(id, pkt.lobby, &mut self.client_location, &self.clients, &self.level_table)?.into_iter())
            }
        })
    }

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