why2-chat 2.3.1

/*
This is part of WHY2
Copyright (C) 2022-2026 Václav Šmejkal

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

use ratatui::text::{ Line, Span };

use crate::
{
    t,
    tn,
    options,
    network::
    {
        codes::OnlineUser,
        client::{ ClientEvent, image as client_image },
    },
};

use super::
{
    theme,
    state::{ self, App },
    tofu::Prompt,
    login::Stage,
};

//IMPLEMENTATIONS
impl App
{
    //TRANSLATE ONE EVENT INTO STATE, NEVER DRAWING
    pub fn apply(&mut self, event: ClientEvent)
    {
        match event
        {
            //THE PROMPTS LIVE IN THE CONNECT BOX
            ClientEvent::Register =>
            {
                if let Some(login) = self.login.as_mut() { login.ask(Stage::Password { register: true }, None); }

                self.answer_step(Stage::Password { register: true });
                self.dirty = true;
            },

            ClientEvent::Login =>
            {
                if let Some(login) = self.login.as_mut() { login.ask(Stage::Password { register: false }, None); }

                self.answer_step(Stage::Password { register: false });
                self.dirty = true;
            },

            ClientEvent::FirstUser =>
            {
                self.push_styled(t!("event.first_user"), theme::notice());
            },

            ClientEvent::Authenticated(role) =>
            {
                self.login = None; //THE BOX HAS ASKED FOR EVERYTHING IT WAS GOING TO ASK FOR
                self.role = role;
                self.push_styled(t!("event.login_ok"), theme::ok());

                //THESE ANSWERS ARE WORTH REPLAYING NOW
                self.reconnect.accepted();

                //AND THE SERVER'S PICTURE IS WORTH ASKING FOR
                self.icon_request = true;
            },

            ClientEvent::Connected(server_name) =>
            {
                self.push_styled(t!("event.connected", server_name), theme::ok());
                self.server_name = server_name;
            },

            //STORED UNRENDERED - App::theme MAKES THE LINE
            ClientEvent::Message(message, username, id, message_id, colors, channel, timestamp, reply) =>
            {
                //None = EVERY PANE, Some(None) = THE LOBBY
                match channel.map(Option::unwrap_or_default)
                {
                    Some(channel) if channel != self.channel =>
                        self.park_entry(channel, state::Entry::Message { username, id, message_id, timestamp, text: message, colors, reply, hearts: Vec::new(), edited: false }),

                    _ =>
                    {
                        //A MESSAGE IS THE PROOF THEY STOPPED
                        self.stopped_typing(&username);
                        self.push_message(username, id, message_id, timestamp, message, colors, reply);
                    },
                }
            },

            ClientEvent::Typing(username) => self.set_typing(username),

            //A PICTURE IS AN ENTRY OF ITS OWN
            ClientEvent::ImageDisplay(username, filename, message_id, timestamp, image, color) =>
                self.push_image(username, filename, message_id, timestamp, image, color),

            //A PICTURE WE DO NOT HOLD: CAPTION IT NOW
            ClientEvent::ImagePending(username, filename, message_id, timestamp, hash, color) =>
            {
                self.push_caption(username, filename, message_id, timestamp, hash, state::Picture::Waiting, color);
                self.image_requests.push(hash);
            },

            //THE SAME LINE WITH THE BUTTON ON IT
            ClientEvent::ImageOffer(username, filename, message_id, timestamp, hash, color) =>
                self.push_caption(username, filename, message_id, timestamp, hash, state::Picture::Absent, color),

            //LOADED ONCE ITS PANE IS LOOKED AT
            ClientEvent::ImageParked(channel, username, filename, message_id, timestamp, hash, username_color) =>
            {
                let picture = match client_image::auto_show_images()
                {
                    true => state::Picture::Deferred,
                    false => state::Picture::Absent,
                };

                //WE MAY HAVE SWITCHED THERE SINCE
                match channel == self.channel
                {
                    true => self.push_caption(username, filename, message_id, timestamp, hash, picture, username_color),
                    false => self.park_entry(channel, state::Entry::Image { username, filename, message_id, timestamp, username_color, hash: Some(hash), picture, hearts: Vec::new() }),
                }
            },

            //A CLICK THE CACHE COULD NOT ANSWER
            ClientEvent::ImageRequest(hash) => self.image_requests.push(hash),

            ClientEvent::ImageFailed(username, filename, ..) => self.push_styled(
                t!("event.image_failed", username, filename), theme::error()),

            ClientEvent::PrivateMessageSent(to, id, msg, colors) => self.push_private(true, to, id, msg, colors),

            ClientEvent::PrivateMessageRecv(from, id, msg, colors) => self.push_private(false, from, id, msg, colors),

            ClientEvent::TofuPrompt(request) =>
            {
                self.tofu = Some(Prompt::new(request));
                self.dirty = true;
            },

            //A REFUSED CHECK ENDS THE SESSION
            ClientEvent::TofuError => self.quit(1, None),

            //BACK TO THE ADDRESS, THE KEY IS PINNED NOW
            ClientEvent::ReconnectFailed => self.disconnected(t!("event.reconnect_failed")),

            //THERE WAS NO PROMPT, SO THE REASON GOES BACK
            ClientEvent::HandshakeFailed(reason) => self.disconnected(reason),

            ClientEvent::TofuSkip(hash) =>
            {
                self.push_styled(t!("event.tofu_skip.title"), theme::error());
                self.push_styled(t!("event.tofu_skip.body"), theme::notice());
                self.push_styled(hash, theme::notice());
            },

            ClientEvent::VoiceActivity(users) =>
            {
                self.voice_activity = users;
                self.rebuild_voice();
            },

            //THE WHOLE ROSTER - IT REPLACES WHAT WE HELD
            ClientEvent::VoiceRoster(clients) =>
            {
                self.voice_roster = clients.into_iter().collect();
                self.rebuild_voice();
            },

            ClientEvent::VoiceJoin(id, username) =>
            {
                self.voice_roster.insert(id, username);
                self.rebuild_voice();
            },

            ClientEvent::VoiceLeave(id) =>
            {
                self.voice_roster.remove(&id);
                self.rebuild_voice();
            },

            ClientEvent::Join(uname, username_color, id, device, role) =>
            {
                if let Some(device) = device.clone() { self.devices.insert(uname.clone(), device); }

                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::styled(t!("event.joined", username = &uname), theme::ok()),
                ]));

                self.offline.remove(&uname); //THEY ARE HERE NOW

                //Join NAMES THE USER, SO ADD THEM HERE - THE ROSTER MAY HOLD THEM ALREADY
                if !self.online.iter().any(|user| user.id == id)
                {
                    self.online.push(OnlineUser
                    {
                        username: uname,
                        username_color,
                        id,
                        channel: None, //EVERYBODY STARTS IN THE LOBBY
                        device,
                        role,
                    });

                    self.sort_online();
                }
            },

            ClientEvent::Leave(uname, id, registered) =>
            {
                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::styled(t!("event.left", username = &uname), theme::dim()),
                ]));

                //Leave NAMES THE USER, SO DROP THEM HERE
                let color = self.online.iter().find(|user| user.id == id).and_then(|user| user.username_color);

                self.online.retain(|user| user.id != id);
                self.devices.remove(&uname);
                self.stopped_typing(&uname);

                //A DELETED ACCOUNT IS NOT OFFLINE
                if self.offline_listed && registered { self.offline.insert(uname, color); }

                //A DISCONNECT CARRIES NO VoiceLeave
                if self.voice_roster.remove(&id).is_some() { self.rebuild_voice(); }

                //A CHANNEL EXISTS WHILE SOMEBODY IS IN IT
                self.channels = self.online.iter().filter_map(|user| user.channel.clone()).collect();
                self.prune_panes();
            },

            ClientEvent::Muted =>
            {
                self.push_styled(t!("event.muted"), theme::notice());
            },

            ClientEvent::Deleted(message_id) => self.delete_message(message_id),

            ClientEvent::Hearts(message_id, hearts) => self.set_hearts(message_id, hearts),

            ClientEvent::Edited(message_id, text) => self.edit_message(message_id, text),

            ClientEvent::InvalidUsage =>
            {
                //A REFUSED SAVE LEAVES THE BOX EDITABLE
                self.settings.saving = false;

                self.push_styled(t!("invalid.usage"), theme::error());
            },

            ClientEvent::UnsafeVersion(newer_versions, current_version, newest_version) =>
            {
                self.push_styled(tn!("event.unsafe_version", newer_versions, current_version, newest_version), theme::notice());
            },

            ClientEvent::Username(disabled_registration, min_uname, max_uname) =>
            {
                let hint = if disabled_registration
                {
                    t!("login.registration_disabled").to_owned()
                } else
                {
                    t!("login.username_rules", min = min_uname, max = max_uname)
                };

                if let Some(login) = self.login.as_mut() { login.ask(Stage::Username, Some(hint)); }

                self.answer_step(Stage::Username);
                self.dirty = true;
            },

            ClientEvent::VoiceEnabled =>
            {
                self.voice_enabled = true;
                self.rebuild_voice();
                self.push_styled(t!("event.voice_enabled"), theme::ok());
            },

            ClientEvent::VoiceDeviceFailed =>
            {
                self.push_styled(t!("event.device_failed"), theme::error());

                //THE CONFIG POINTS AT THE DEVICE THAT PLAYS
                #[cfg(feature = "client_voice")]
                self.settings.refresh_devices();
            },

            ClientEvent::VoiceHandshakeFailed =>
            {
                self.push_styled(t!("event.voice_handshake_failed"), theme::error());
            },

            ClientEvent::VoiceDisabled =>
            {
                //ONLY OUR OWN HALF OF THE PANEL GOES
                self.voice_enabled = false;
                self.voice_activity.clear();
                self.rebuild_voice();
                self.push_styled(t!("event.voice_disabled"), theme::dim());
            },

            //SERVER MESSAGE
            ClientEvent::ServerSay(message) =>
            {
                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::styled(message, theme::notice()),
                ]));
            },

            //A ROLE WAS SET, ON US OR ON SOMEBODY ELSE
            ClientEvent::Role(role, username) =>
            {
                //MOVE THEM TO THEIR NEW SECTION
                self.online.iter_mut().filter(|user| user.username == username).for_each(|user| user.role = role);
                self.sort_online();
                self.dirty = true;

                //AN OPEN PROFILE OF THEIRS
                if self.settings.open && self.settings.profile() && self.settings.subject == username { self.settings.role = role; }

                if username == self.username
                {
                    self.role = role;
                    self.push_styled(t!("event.role", role), theme::notice());
                }
            },

            //THE LOBBY'S STORED MESSAGES
            ClientEvent::History(messages, start, more, kept, older) =>
            {
                //A PICTURE IS LOADED WHEN IT IS LOOKED AT
                let auto_show = client_image::auto_show_images();

                let entries = messages.into_iter().map(|message| match message.image
                {
                    Some(hash) => state::Entry::Image
                    {
                        username: message.username,
                        filename: message.text,
                        message_id: message.message_id,
                        timestamp: message.timestamp,
                        username_color: message.colors.username_color,
                        hash: Some(hash),
                        picture: match auto_show
                        {
                            true => state::Picture::Deferred,
                            false => state::Picture::Absent,
                        },
                        hearts: message.hearts,
                    },

                    None => state::Entry::History
                    {
                        username: message.username,
                        message_id: message.message_id,
                        timestamp: message.timestamp,
                        text: message.text,
                        colors: message.colors,
                        reply: message.reply,
                        hearts: message.hearts,
                        edited: message.edited,
                    },
                }).collect();

                match older
                {
                    true => self.prepend_history(entries, start, more),

                    false =>
                    {
                        self.push_styled(t!("event.history", count = kept), theme::title());
                        self.start_history(entries, start, more);
                    },
                }
            },

            //THE ANSWER TO A CLICKED CAPTION, THE PROFILE BOX OR THE SIDEBAR
            ClientEvent::ImageData(hash, image) =>
            {
                self.fetched(&hash);

                if self.wants_icon(&hash) { self.deliver_icon(hash, image.clone()); }

                match self.wants_avatar(&hash)
                {
                    true => self.deliver_avatar(hash, image),
                    false => self.deliver_image(hash, image),
                }
            },

            //server.toml CAME BACK
            ClientEvent::ServerSettings(settings, saved) =>
            {
                match saved
                {
                    //A REFUSED ROW SNAPS BACK
                    true =>
                    {
                        if self.settings.open && self.settings.server() { self.settings.stored(settings); }

                        self.push_styled(t!("event.server_settings_saved"), theme::ok());
                    },

                    false => self.settings.open_server(settings),
                }

                self.dirty = true;
            },

            //A PASSWORD CHANGE CAME BACK
            ClientEvent::Passwd(changed) =>
            {
                match changed
                {
                    true =>
                    {
                        //A RECONNECT REPLAYS THE NEW ONE
                        if let Some(form) = self.account.take() { self.reconnect.passwd(form.new_password()); }

                        self.push_styled(t!("event.password_changed"), theme::ok());
                    },

                    false =>
                    {
                        let message = t!("event.password_refused").to_owned();

                        match self.account.as_mut()
                        {
                            Some(form) => form.rejected(message),
                            None => self.push_styled(message, theme::error()),
                        }
                    },
                }

                self.dirty = true;
            },

            //AN ACCOUNT DELETION CAME BACK
            ClientEvent::AccountDeleted(deleted) =>
            {
                match deleted
                {
                    //THE SERVER HANGS UP NEXT
                    true =>
                    {
                        self.account = None;
                        self.disconnect_reason = Some(t!("event.account_deleted").to_owned());
                    },

                    false =>
                    {
                        let message = t!("event.wrong_password").to_owned();

                        match self.account.as_mut()
                        {
                            Some(form) => form.rejected(message),
                            None => self.push_styled(message, theme::error()),
                        }
                    },
                }

                self.dirty = true;
            },

            //A PROFILE CAME BACK
            ClientEvent::Profile(username, profile, own, saved) =>
            {
                match saved
                {
                    //A REFUSED DESCRIPTION SNAPS BACK
                    true =>
                    {
                        if self.settings.open && self.settings.profile()
                        {
                            self.settings.stored_profile(username, profile);
                        }

                        self.push_styled(t!("event.profile_saved"), theme::ok());
                    },

                    false => self.settings.open_profile(username, profile, own),
                }

                //THE PICTURE IT NAMES IS FETCHED LIKE A CAPTION'S
                if self.settings.open && self.settings.picture.is_none()
                    && let Some(hash) = self.settings.avatar
                {
                    self.image_loads.push(hash);
                }

                self.dirty = true;
            },

            //OUR AVATAR COULD NOT BE CUT, SO NOTHING WENT OUT
            ClientEvent::AvatarFailed(error) =>
            {
                self.settings.saving = false;
                self.push_styled(error, theme::error());
            },

            //OUR COLORS AT LOGIN
            ClientEvent::Colors(Some(colors)) =>
            {
                self.color = colors.username_color;
                self.dirty = true;
            },

            //THE SERVER'S PICTURE - ONLY OUR OWN SAVE SAYS ANYTHING
            ClientEvent::ServerIcon(hash, save) =>
            {
                if save
                {
                    self.push_styled(match hash
                    {
                        Some(_) => t!("event.server_icon_set"),
                        None => t!("event.server_icon_removed"),
                    }, theme::ok());
                }

                self.set_server_icon(hash);
            },

            //THE ANSWER TO A /color
            ClientEvent::Colors(None) => self.push_styled(t!("event.color_set"), theme::ok()),

            //THE BAN LIST
            ClientEvent::ServerBans(users, ips) =>
            {
                if users.is_empty() && ips.is_empty()
                {
                    self.push_styled(t!("event.bans.none"), theme::dim());
                } else
                {
                    self.push_styled(t!("event.bans.title", count = users.len() + ips.len()), theme::title());

                    //TWO SECTIONS, EACH NUMBERED FROM ZERO
                    let sections = [(t!("event.bans.users"), users), (t!("event.bans.addresses"), ips)];
                    let last_section = sections.iter().filter(|(_, bans)| !bans.is_empty()).count().saturating_sub(1);

                    let mut section_index = 0;
                    for (name, bans) in sections
                    {
                        if bans.is_empty() { continue; }

                        let last = section_index == last_section;
                        section_index += 1;

                        self.push(Line::from(vec!
                        [
                            Span::styled(super::branch(last), theme::border()),
                            Span::raw(name),
                        ]));

                        //THE TRUNK RUNS PAST A NON-LAST SECTION
                        let trunk = format!("{}  ", if last { " " } else { "│" });
                        let width = id_width(bans.iter().map(|ban| ban.id));
                        let last_ban = bans.len() - 1;

                        for (index, ban) in bans.into_iter().enumerate()
                        {
                            let mut spans = vec![Span::styled(format!("{trunk}{}", super::branch(index == last_ban)), theme::border())];

                            spans.extend(id_column(ban.id, width));
                            spans.push(Span::raw(ban.subject));

                            self.push(Line::from(spans));
                        }
                    }
                }
            },

            ClientEvent::List(users, registered) =>
            {
                //ALWAYS REFRESH THE SIDEBAR; ECHO ONLY IF ASKED
                self.online = users;
                self.offline_listed = registered.is_some();
                self.offline = registered.unwrap_or_default().into_iter()
                    .map(|user| (user.username, user.username_color)).collect();
                self.sort_online();
                self.dirty = true;

                //THE ROSTER NAMES EVERYBODY, SO IT OWNS THE DEVICES
                self.devices = self.online.iter()
                    .filter_map(|user| Some((user.username.clone(), user.device.clone()?)))
                    .collect();

                //A CHANNEL EXISTS WHILE SOMEBODY IS IN IT
                self.channels = self.online.iter().filter_map(|user| user.channel.clone()).collect();
                self.prune_panes();

                if self.list_requested
                {
                    self.list_requested = false;

                    let here = options::get_channel();
                    let width = id_width(self.online.iter().map(|user| user.id));
                    let last = self.online.len().saturating_sub(1);

                    self.push_styled(t!("event.list.title", count = self.online.len()), theme::title());

                    let rows = self.online.iter().enumerate().map(|(index, user)|
                    {
                        let mut spans = vec![Span::styled(super::branch(index == last), theme::border())];

                        spans.extend(id_column(user.id, width));
                        spans.push(self.theme.colorize(user.username.clone(), user.username_color));

                        //WHAT THEY ARE ON, IF THEY SHARE IT
                        if let Some(device) = self.devices.get(&user.username)
                        {
                            spans.push(Span::styled(format!("  {}", super::device_label(device)), theme::dim()));
                        }

                        //ACCENT OUR OWN CHANNEL
                        if let Some(channel) = user.channel.clone()
                        {
                            let style = if channel == here { theme::accent() } else { theme::dim() };
                            spans.push(Span::styled(format!("  #{channel}"), style));
                        }

                        Line::from(spans)
                    }).collect::<Vec<Line<'static>>>();

                    for row in rows { self.push(row); }
                }

                self.dirty = true;
            },

            ClientEvent::Upload(uid, filename, size) =>
            {
                self.push_transfer(uid, filename, size, true, false);
            },

            ClientEvent::Image(uid, filename, size) =>
            {
                self.push_transfer(uid, filename, size, true, true);
            },

            ClientEvent::UploadDone(uid, _) =>
            {
                self.finish_transfer(uid, true);
            },

            ClientEvent::TransferProgress(uid, done) =>
            {
                self.update_transfer(uid, done);
            },

            ClientEvent::Uploaded(username, filename) =>
            {
                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::raw(t!("event.uploaded", username, filename)),
                ]));
            },

            ClientEvent::Download(uid, filename, size) =>
            {
                self.push_transfer(uid, filename, size, false, false);
            },

            ClientEvent::Downloaded(uid, _) =>
            {
                self.finish_transfer(uid, true);
            },

            ClientEvent::DownloadFailed(uid, _) =>
            {
                self.finish_transfer(uid, false);
            },

            ClientEvent::Files(users) =>
            {
                if users.is_empty()
                {
                    self.push_styled(t!("event.files.none"), theme::dim());
                } else
                {
                    self.push_styled(t!("event.files.title", count = users.len()), theme::title());

                    //THE OWNER IS THE BRANCH, THEIR FILES HANG OFF IT
                    let width = id_width(users.iter().map(|user| user.id));
                    let last = users.len() - 1;

                    for (index, user) in users.into_iter().enumerate()
                    {
                        let mut spans = vec![Span::styled(super::branch(index == last), theme::border())];

                        spans.extend(id_column(user.id, width));
                        spans.push(Span::raw(user.username.clone()));

                        self.push(Line::from(spans));

                        //THE TRUNK RUNS PAST A NON-LAST OWNER
                        let trunk = format!("{}  ", if index == last { " " } else { "│" });
                        let file_width = id_width(user.upload.iter().map(|(_, id)| *id));
                        let last_file = user.upload.len().saturating_sub(1);

                        for (file, (filename, file_id)) in user.upload.into_iter().enumerate()
                        {
                            let mut spans = vec![Span::styled(format!("{trunk}{}", super::branch(file == last_file)), theme::border())];

                            spans.extend(id_column(file_id, file_width));
                            spans.push(Span::raw(filename));

                            self.push(Line::from(spans));
                        }
                    }
                }
            },

            ClientEvent::Screens(users) =>
            {
                #[cfg(feature = "client_screen")]
                { self.screens_requested = false; }

                if users.is_empty()
                {
                    self.push_styled(t!("event.screens.none"), theme::dim());
                } else
                {
                    self.push_styled(t!("event.screens.title", count = users.len()), theme::title());

                    let width = id_width(users.iter().map(|user| user.id));
                    let last = users.len() - 1;

                    for (index, user) in users.into_iter().enumerate()
                    {
                        let mut spans = vec![Span::styled(super::branch(index == last), theme::border())];

                        spans.extend(id_column(user.id, width));
                        spans.push(Span::raw(user.username));

                        self.push(Line::from(spans));
                    }
                }
            },

            ClientEvent::UploadLimit =>
            {
                self.push_styled(t!("event.upload_limit"), theme::error());
            },

            ClientEvent::Screen(enabled) =>
            {
                self.push_styled(if enabled { t!("event.screen.started") } else { t!("event.screen.stopped") }, theme::ok());
            },

            ClientEvent::ScreenFailed(reason) =>
            {
                self.push_styled(t!("event.screen.failed", reason), theme::error());
            },

            ClientEvent::Attach(username) =>
            {
                self.push_text(t!("event.screen.attach", username));
            },

            ClientEvent::Deattach(username) =>
            {
                self.push_text(t!("event.screen.deattach", username));
            },

            //BROADCAST TO EVERYBODY, US INCLUDED
            ClientEvent::Screenshare(username) if username != self.username =>
            {
                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::styled(t!("event.screen.peer_started", username), theme::notice()),
                ]));
            },

            ClientEvent::ScreenshareEnd(username) if username != self.username =>
            {
                self.push(Line::from(vec!
                [
                    Span::styled(format!("[{}] ", options::get_server_username()), theme::dim()),
                    Span::styled(t!("event.screen.peer_stopped", username), theme::dim()),
                ]));
            },

            ClientEvent::Screenshare(_) | ClientEvent::ScreenshareEnd(_) => {},

            ClientEvent::Attached(username) =>
            {
                self.push_text(t!("event.screen.attached", username));
            },

            ClientEvent::Deattached(username) =>
            {
                self.push_text(t!("event.screen.deattached", username));
            },

            ClientEvent::IncompatibleVersion(version, server_version) =>
            {
                //THE BOX IS STILL UP, SO THE HISTORY IS NOT WHERE THIS IS READ
                self.disconnect_reason = Some(t!("event.incompatible_version", version, server_version));
            },

            ClientEvent::VersionMismatch(client_version, server_version) =>
            {
                self.push_styled(t!("event.version_mismatch", client_version, server_version), theme::notice());
            },

            //Login::ask KEEPS THE ERROR ON SCREEN
            ClientEvent::UsernameRejected =>
            {
                match self.login.as_mut()
                {
                    Some(login) => login.error = Some(t!("login.username_rejected").to_owned()),
                    None => self.push_styled(t!("login.username_rejected"), theme::error()),
                }

                //A REPLAYED ANSWER THE SERVER REFUSES IS NOT ONE TO REPLAY AGAIN
                self.reconnect.forget();
                self.dirty = true;
            },

            ClientEvent::PasswordRejected(min_pass) =>
            {
                let message = t!("login.password_rejected", min = min_pass);

                match self.login.as_mut()
                {
                    Some(login) => login.error = Some(message),
                    None => self.push_styled(message, theme::error()),
                }

                self.dirty = true;
            },

            ClientEvent::SpamWarning =>
            {
                self.push_styled(t!("event.spam_warning"), theme::notice());
            },

            ClientEvent::Socks5Voice =>
            {
                self.push_styled(t!("event.socks5_voice"), theme::error());
            },

            ClientEvent::DisabledFeature =>
            {
                self.push_styled(t!("event.disabled_feature"), theme::error());
            },

            ClientEvent::VersionFailed =>
            {
                self.push_styled(t!("event.version_failed"), theme::notice());
            },

            //BACK TO THE CONNECT BOX UNLESS WE ASKED TO LEAVE
            ClientEvent::Quit(said) =>
            {
                if self.leaving
                {
                    self.quit(0, Some(t!("event.quit").to_owned()));
                } else if self.logging_out
                {
                    self.disconnected(t!("event.logged_out"));
                } else
                {
                    //A SERVER THAT SAID SO IS NOT ONE TO DIAL BACK
                    if said { self.reconnect.forget(); }

                    let reason = self.disconnect_reason.take();
                    self.disconnected(reason.unwrap_or_else(|| t!("event.server_quit").to_owned()));
                }
            },

            //SIDEBAR-ONLY, NOTHING IS ASKED OF THE SERVER
            ClientEvent::ChannelChanged(channel) =>
            {
                self.switch_channel(channel.clone().unwrap_or_default());

                if let Some(name) = channel.clone() { self.channels.insert(name); }

                //KEEP OUR OWN ROW HONEST UNTIL THE NEXT LIST
                let me = self.username.clone();

                if let Some(user) = self.online.iter_mut().find(|user| user.username == me)
                {
                    user.channel = channel;
                }

                //THE NEW CHANNEL'S ROSTER ARRIVES BEHIND THIS
                self.voice_roster.clear();
                self.voice_activity.clear();
                self.rebuild_voice();
            },

            ClientEvent::ChannelCreated(name) =>
            {
                self.channels.insert(name);
                self.dirty = true;
            },

            ClientEvent::ChannelDestroyed(name) =>
            {
                self.channels.remove(&name);
                self.panes.remove(&name);
                self.dirty = true;
            },
        }
    }

    pub fn quit(&mut self, code: i32, message: Option<String>)
    {
        self.should_quit = true;
        self.exit_code = code;
        self.quit_message = message;
        self.dirty = true;
    }
}

//PRIVATE
//EVERY LIST BLOCK IS A TREE: BRANCH, ID, NAME
fn id_width(ids: impl Iterator<Item = usize>) -> usize
{
    ids.map(|id| id.to_string().len()).max().unwrap_or(1)
}

fn id_column(id: usize, width: usize) -> Vec<Span<'static>>
{
    vec![Span::styled(format!("{id:>width$}  "), theme::dim())]
}