elseware/src/login/character.rs

use std::net;

use rand::{Rng, RngCore};
use bcrypt::{DEFAULT_COST, hash, verify};

use libpso::packet::login::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::{CipherError, PSOCipher, NullCipher};
use libpso::crypto::bb::PSOBBCipher;

use elseware::pktvec;
use elseware::common::pktvec::PktVec;
use elseware::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
use elseware::common::network::{PacketNetworkError};
use elseware::common::client::Client;
use elseware::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
use elseware::common::util::array_to_utf8;

use crate::dataaccess::DataAccess;
use crate::login::{SharedLoginState, get_login_status};
//use crate::models::UserAccount;
use crate::entities::{UserAccount, Character};

pub const CHARACTER_PORT: u16 = 12001;

#[derive(Debug)]
pub enum CharacterError {
}

#[derive(Debug)]
pub enum RecvCharacterPacket {
    Login(Login),
    RequestSettings(RequestSettings),
    CharSelect(CharSelect),
    Checksum(Checksum),
}

impl RecvServerPacket for RecvCharacterPacket {
    fn from_bytes(data: &[u8]) -> Result<RecvCharacterPacket, PacketParseError> {
        match u16::from_le_bytes([data[2], data[3]]) {
            0x93 => Ok(RecvCharacterPacket::Login(Login::from_bytes(data)?)),
            0xE0 => Ok(RecvCharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)),
            0xE3 => Ok(RecvCharacterPacket::CharSelect(CharSelect::from_bytes(data)?)),
            0x1E8 => Ok(RecvCharacterPacket::Checksum(Checksum::from_bytes(data)?)),
            _ => Err(PacketParseError::WrongPacketForServerType)
        }
    }
}


#[derive(Debug)]
pub enum SendCharacterPacket {
    LoginResponse(LoginResponse),
    LoginWelcome(LoginWelcome),
    SendKeyAndTeamSettings(SendKeyAndTeamSettings),
    CharAck(CharAck),
    ChecksumAck(ChecksumAck),
}

impl SendServerPacket for SendCharacterPacket {
    fn as_bytes(&self) -> Vec<u8> {
        match self {
            SendCharacterPacket::LoginResponse(pkt) => pkt.as_bytes(),
            SendCharacterPacket::LoginWelcome(pkt) => pkt.as_bytes(),
            SendCharacterPacket::SendKeyAndTeamSettings(pkt) => pkt.as_bytes(),
            SendCharacterPacket::CharAck(pkt) => pkt.as_bytes(),
            SendCharacterPacket::ChecksumAck(pkt) => pkt.as_bytes(),
            //SendLoginPacket::RedirectClient(pkt) => pkt.as_bytes(),
        }
    }
}

pub struct CharacterServerState<DA: DataAccess> {
    //shared_state: SharedLoginState<DA>,
    data_access: DA,
    user: Option<UserAccount>,
    characters: Option<[Option<Character>; 4]>
}

impl<DA: DataAccess> CharacterServerState<DA> {
    fn new(data_access: DA) -> CharacterServerState<DA> {
        CharacterServerState {
            //shared_state: shared_state,
            data_access: data_access,
            user: None,
            characters: None,
        }
    }

    fn validate_login(&mut self, pkt: &Login) -> Vec<SendCharacterPacket> {
        match get_login_status(&self.data_access, pkt) {
            Ok(user) => {
                let mut response = LoginResponse::by_status(AccountStatus::Ok, pkt.security_data);
                response.guildcard = user.guildcard.map_or(0, |gc| gc) as u32;
                response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
                self.user = Some(user);
                vec![SendCharacterPacket::LoginResponse(response)]
            },
            Err(err) => {
                vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, pkt.security_data))]
            }
        }
    }

    fn get_settings(&mut self) -> Vec<SendCharacterPacket> {
        let user = self.user.as_ref().unwrap();
        let settings = match self.data_access.get_user_settings_by_user(&user) {
            Some(settings) => settings,
            None => self.data_access.create_user_settings_by_user(&user),
        };

        let pkt = SendKeyAndTeamSettings::new(settings.settings.key_config,
                                              settings.settings.joystick_config, 0, 0);
        let pkt = SendCharacterPacket::SendKeyAndTeamSettings(pkt);

        vec![pkt]
    }

    fn char_select(&mut self, select: &CharSelect) -> Vec<SendCharacterPacket> {
        /*if self.characters.is_none() {
            self.characters = Some(self.data_access.get_characters_by_user(self.user.as_ref().unwrap()));
        }

        let chars = self.characters.as_ref().unwrap();
        if let Some(ref char) = chars[select.slot as usize] {
            Vec::new()
        }
        else {
            vec![SendCharacterPacket::CharAck(CharAck {
                flag: 0,
                slot: select.slot,
                code: 2,
            })]
    }*/
        Vec::new()
    }

    fn validate_checksum(&mut self) -> Vec<SendCharacterPacket> {
        vec![SendCharacterPacket::ChecksumAck(ChecksumAck {
            flag: 0,
            ack: 1,
        })]
    }
}

impl<DA: DataAccess> ServerState for CharacterServerState<DA> {
    type SendPacket = SendCharacterPacket;
    type RecvPacket = RecvCharacterPacket;
    type PacketError = CharacterError;

    fn on_connect(&mut self) -> 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(SendCharacterPacket::LoginWelcome(LoginWelcome::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: &RecvCharacterPacket) -> Box<dyn Iterator<Item = (ClientId, SendCharacterPacket)>> {
        match pkt {
            RecvCharacterPacket::Login(login) => {
                Box::new(self.validate_login(login).into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::RequestSettings(_req) => {
                Box::new(self.get_settings().into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::CharSelect(sel) => {
                Box::new(self.char_select(sel).into_iter().map(move |pkt| (id, pkt)))
            }
            RecvCharacterPacket::Checksum(checksum) => {
                Box::new(self.validate_checksum().into_iter())
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::entities::UserSettings;
    use libpso::character::settings;
    use std::time::SystemTime;

    #[test]
    fn test_option_send() {
        struct TestData {
        }

        impl DataAccess for TestData {
            fn get_user_settings_by_user(&self, _user: &UserAccount) -> Option<UserSettings> {
                Some(UserSettings {
                    id: 0,
                    user_id: 0,
                    settings: settings::UserSettings::default()
                })
            }
        }

        let mut server = CharacterServerState::new(TestData {});
        server.user = Some(UserAccount {
            id: 1,
            username: "testuser".to_owned(),
            password: bcrypt::hash("mypassword", 5).unwrap(),
            guildcard: None,
            team_id: None,
            banned: false,
            muted_until: SystemTime::now(),
            created_at: SystemTime::now(),
        });

        let send = server.handle(5, &RecvCharacterPacket::RequestSettings(RequestSettings {flag: 0})).collect::<Vec<_>>();
        assert!(send.len() == 1);

        assert!(send[0].0 == 5);
        let bytes = send[0].1.as_bytes();
        assert!(bytes[2] == 0xE2);
        assert!(bytes.len() == 0xAFC);
    }

    #[test]
    fn test_user_checksum() {
        struct TestData {}
        impl DataAccess for TestData{}
        let shared = SharedLoginState::new(TestData {});
        let mut server = CharacterServerState::new(shared);
        let send = server.handle(&RecvCharacterPacket::Checksum(Checksum {flag: 0})).collect::<Vec<_>>();
        assert!(send.len() == 1);

        let bytes = send[0].as_bytes();
        assert!(bytes == [0xC, 0, 0xE8, 0x02, 0,0,0,0, 1,0,0,0]);
    }
}