use super::*;
use crate::net::{NetHandle, SyncRecv};
use iris::core::util::HashMap;
use openworm::net::{RequestUserInfo, UserId, UserInfo};

pub struct UserCache {
    pub con: NetHandle,
    pub requests: HashMap<UserId, SyncRecv<RequestUserInfo>>,
    pub users: HashMap<UserId, UserInfo>,
    pub widgets: HashMap<UserId, Vec<WeakWidget<Text>>>,
}

impl UserCache {
    pub fn new(con: NetHandle) -> Self {
        Self {
            con,
            requests: Default::default(),
            users: Default::default(),
            widgets: Default::default(),
        }
    }

    pub fn username(&mut self, id: UserId, rsc: &mut Rsc) -> WeakWidget {
        let text = if let Some(user) = self.users.get(&id) {
            &user.username
        } else {
            if !self.requests.contains_key(&id) {
                let recv = self.con.request_sync(RequestUserInfo { id });
                self.requests.insert(id, recv);
            }
            "loading..."
        };
        let wid = wtext(text).add(rsc);
        self.widgets.entry(id).or_default().push(wid);
        wid
    }

    pub fn update(&mut self, rsc: &mut Rsc) {
        self.requests.retain(|id, req| {
            if let Some(resp) = req.try_recv() {
                if let Ok(info) = resp {
                    for &widget in self.widgets.get(id).into_iter().flatten() {
                        *rsc[widget].content = info.username.clone();
                    }
                    self.users.insert(*id, info);
                }
                false
            } else {
                true
            }
        });
    }
}