elseware/src/entity/gateway/inmemory.rs

use std::collections::HashMap;
use std::default::Default;

use crate::entity::account::*;
use crate::entity::character::*;
use crate::entity::gateway::EntityGateway;
use crate::entity::item::*;

use libpso::character::settings;
use libpso::item;

use std::sync::{Arc, Mutex};

#[derive(Clone)]
pub struct InMemoryGateway {
    users: Arc<Mutex<HashMap<UserAccountId, UserAccountEntity>>>,
    user_settings: Arc<Mutex<HashMap<UserSettingsId, UserSettingsEntity>>>,
    characters: Arc<Mutex<HashMap<CharacterEntityId, CharacterEntity>>>,
    items: Arc<Mutex<HashMap<ItemEntityId, ItemEntity>>>,
}

impl InMemoryGateway {
    pub fn new() -> InMemoryGateway {
        InMemoryGateway {
            users: Arc::new(Mutex::new(HashMap::new())),
            user_settings: Arc::new(Mutex::new(HashMap::new())),
            characters: Arc::new(Mutex::new(HashMap::new())),
            items: Arc::new(Mutex::new(HashMap::new())),
        }
    }
}

impl EntityGateway for InMemoryGateway {
    fn get_user_by_id(&self, id: UserAccountId) -> Option<UserAccountEntity> {
        let users = self.users.lock().unwrap();
        users.get(&id).map(|k| k.clone())
    }

    fn get_user_by_name(&self, username: String) -> Option<UserAccountEntity> {
        let users = self.users.lock().unwrap();
        users
            .iter()
            .find(|(_, k)| k.username == username)
            .map(|(_, k)| k.clone())
    }

    fn set_user(&mut self, user: &mut UserAccountEntity) {
        let mut users = self.users.lock().unwrap();
        if let None = user.id {
            let id = users
                .iter()
                .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
                + 1;
            user.id = Some(UserAccountId(id));
        }
        users.insert(user.id.unwrap(), user.clone());
    }

    fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Option<UserSettingsEntity> {
        let user_settings = self.user_settings.lock().unwrap();
        user_settings
            .iter()
            .find(|(_, k)| k.user_id == user.id.unwrap())
            .map(|(_, k)| k.clone())
    }


    fn set_user_settings(&mut self, user_setting: &mut UserSettingsEntity) {
        let mut user_settings = self.user_settings.lock().unwrap();
        if let None = user_setting.id {
            let id = user_settings
                .iter()
                .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
                + 1;
            user_setting.id = Some(UserSettingsId(id));
        }
        user_settings.insert(user_setting.id.unwrap(), user_setting.clone());
    }

    fn get_characters_by_user(&self, user: &UserAccountEntity) -> [Option<CharacterEntity>; 4] {
        let characters = self.characters.lock().unwrap();
        let mut chars = [None; 4];
        characters
            .iter()
            .filter(|(_, c)| c.user_id == user.id.unwrap())
            .for_each(|(_, c)| chars[c.slot as usize] = Some(c.clone()));
        chars
    }

    fn set_character(&mut self, char: &mut CharacterEntity) {
        let mut characters = self.characters.lock().unwrap();
        if let None = char.id {
            let id = characters
                .iter()
                .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
                + 1;
            char.id = Some(CharacterEntityId(id));
        }
        characters.insert(char.id.unwrap(), char.clone());
    }

    fn get_guild_card_data_by_user(&self, user: &UserAccountEntity) -> GuildCardDataEntity {
        GuildCardDataEntity::new(user.id.unwrap())
    }

    fn set_item(&mut self, item: &mut ItemEntity) {
        let mut items = self.items.lock().unwrap();
        if let None = item.id {
            let id = items
                .iter()
                .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
                + 1;
            item.id = Some(ItemEntityId(id));
        }
        items.insert(item.id.unwrap(), item.clone());
    }

    fn get_items_by_character(&self, character: &CharacterEntity) -> Vec<ItemEntity> {
        let items = self.items.lock().unwrap();
        items
            .iter()
            .filter(|(_, k)| {
                match k.location {
                    ItemLocation::Inventory{character_id, ..} => character_id == character.id.unwrap(),
                    ItemLocation::Bank{character_id, ..} => character_id == character.id.unwrap(),
                    _ => false
                }
            })
            .map(|(_, k)| {
                k.clone()
            })
            .collect()
    }
}