//! Channels: the `Channel` record, membership, channel modes, bans, invites and
//! JOIN/NAMES — the same job InspIRCd splits across channels/channelmanager, but
//! written from scratch in Rust (InspIRCd is a behaviour reference, not a source).

use std::collections::{HashMap, HashSet};

use crate::module::Hook;
use crate::modules::chathistory::{HistMsg, History};
use crate::numeric::*;
use crate::server::{iso_time, now, Server};
use crate::Uid;

/// Per-member prefix modes (+q/+a/+o/+h/+v). Flag modes live in [`ChanModes`].
#[derive(Default)]
pub struct Member {
    pub owner: bool,  // +q (~)
    pub admin: bool,  // +a (&)
    pub op: bool,     // +o (@)
    pub halfop: bool, // +h (%)
    pub voice: bool,  // +v (+)
}

/// Prefix ranks, high→low — gate who may grant a prefix / kick whom.
pub const RANK_OWNER: u8 = 5;
pub const RANK_ADMIN: u8 = 4;
pub const RANK_OP: u8 = 3;
pub const RANK_HALFOP: u8 = 2;
pub const RANK_VOICE: u8 = 1;

impl Member {
    /// This member's numeric rank (0 = plain member).
    pub fn rank(&self) -> u8 {
        if self.owner {
            RANK_OWNER
        } else if self.admin {
            RANK_ADMIN
        } else if self.op {
            RANK_OP
        } else if self.halfop {
            RANK_HALFOP
        } else if self.voice {
            RANK_VOICE
        } else {
            0
        }
    }

    /// Highest prefix char for NAMES (`""` for a plain member).
    pub fn prefix_char(&self) -> &'static str {
        if self.owner {
            "~"
        } else if self.admin {
            "&"
        } else if self.op {
            "@"
        } else if self.halfop {
            "%"
        } else if self.voice {
            "+"
        } else {
            ""
        }
    }

    /// Set/clear a prefix mode by its letter (used by the S2S mode applier).
    pub fn set_prefix(&mut self, letter: char, on: bool) {
        match letter {
            'q' => self.owner = on,
            'a' => self.admin = on,
            'o' => self.op = on,
            'h' => self.halfop = on,
            'v' => self.voice = on,
            _ => {}
        }
    }

    /// Every prefix char this member holds, high→low (for the `multi-prefix` cap).
    pub fn all_prefixes(&self) -> String {
        let mut s = String::new();
        for (on, c) in [
            (self.owner, '~'),
            (self.admin, '&'),
            (self.op, '@'),
            (self.halfop, '%'),
            (self.voice, '+'),
        ] {
            if on {
                s.push(c);
            }
        }
        s
    }
}

pub struct Topic {
    pub text: String,
    pub setter: String,
    pub ts: u64,
}

/// A +b ban: a `nick!user@host` glob, who set it and when.
pub struct Ban {
    pub mask: String,
    pub setter: String,
    pub ts: u64,
}

/// +f message flood: `[*]lines:secs` — kick past `lines` msgs in `secs` (and set
/// a +b ban too when `ban`, from the leading `*`).
#[derive(Clone)]
pub struct MsgFlood {
    pub lines: u32,
    pub secs: u64,
    pub ban: bool,
}

/// A `count:secs` rate, shared by +j (join flood) and +F (nick-change flood).
#[derive(Clone)]
pub struct Rate {
    pub count: u32,
    pub secs: u64,
}

/// Channel modes other than the per-member prefixes.
#[derive(Default)]
pub struct ChanModes {
    pub moderated: bool,             // +m — only +o/+v may speak
    pub topic_ops: bool,             // +t — only ops may set the topic
    pub no_external: bool,           // +n — must be a member to message it
    pub invite_only: bool,           // +i
    pub secret: bool,                // +s
    pub key: Option<String>,         // +k <key>
    pub limit: Option<u32>,          // +l <n>
    pub secure_only: bool,           // +z — only TLS-connected users may join
    pub private: bool,               // +p — private (hidden from WHOIS channel list)
    pub oper_only: bool,             // +O — only IRC operators may join
    pub no_nick: bool,               // +N — members can't change nick while here
    pub no_ctcp: bool,               // +C — block CTCP to the channel
    pub no_notice: bool,             // +T — block NOTICEs to the channel
    pub no_color: bool,              // +c — reject messages with formatting/colour
    pub strip_color: bool,           // +S — strip formatting/colour from messages
    pub reg_only: bool,              // +R — only logged-in (account) users may join
    pub reg_moderated: bool,         // +M — only logged-in users may speak
    pub censor: bool,                // +G — replace configured bad words
    pub auditorium: bool,            // +u — hide non-ops from non-ops
    pub flood: Option<MsgFlood>,     // +f
    pub joinflood: Option<Rate>,     // +j
    pub nickflood: Option<Rate>,     // +F
    pub redirect: Option<String>,    // +L <#target> — when full, send there
    pub history: Option<(u32, u64)>, // +H <lines>:<secs> — replay recent messages to joiners
    pub anticaps: Option<u8>,        // +B <percent> — block messages that are mostly CAPS
}

impl ChanModes {
    /// Set/clear a no-parameter flag mode by its letter (the S2S mode applier).
    pub fn set_by_letter(&mut self, c: char, on: bool) {
        match c {
            'm' => self.moderated = on,
            'n' => self.no_external = on,
            't' => self.topic_ops = on,
            'i' => self.invite_only = on,
            's' => self.secret = on,
            'z' => self.secure_only = on,
            'p' => self.private = on,
            'O' => self.oper_only = on,
            'N' => self.no_nick = on,
            'C' => self.no_ctcp = on,
            'T' => self.no_notice = on,
            'c' => self.no_color = on,
            'S' => self.strip_color = on,
            'R' => self.reg_only = on,
            'M' => self.reg_moderated = on,
            'G' => self.censor = on,
            'u' => self.auditorium = on,
            _ => {}
        }
    }

    /// `+mnt`, or with `params` the +k/+l arguments too: `+ntkl secret 20`.
    pub fn render(&self, params: bool) -> String {
        let mut s = String::from("+");
        for (on, ch) in [
            (self.invite_only, 'i'),
            (self.moderated, 'm'),
            (self.no_external, 'n'),
            (self.secret, 's'),
            (self.topic_ops, 't'),
            (self.secure_only, 'z'),
            (self.private, 'p'),
            (self.oper_only, 'O'),
            (self.no_nick, 'N'),
            (self.no_ctcp, 'C'),
            (self.no_notice, 'T'),
            (self.no_color, 'c'),
            (self.strip_color, 'S'),
            (self.reg_only, 'R'),
            (self.reg_moderated, 'M'),
            (self.censor, 'G'),
            (self.auditorium, 'u'),
        ] {
            if on {
                s.push(ch);
            }
        }
        if self.key.is_some() {
            s.push('k');
        }
        if self.limit.is_some() {
            s.push('l');
        }
        if self.flood.is_some() {
            s.push('f');
        }
        if self.joinflood.is_some() {
            s.push('j');
        }
        if self.nickflood.is_some() {
            s.push('F');
        }
        if self.redirect.is_some() {
            s.push('L');
        }
        if self.history.is_some() {
            s.push('H');
        }
        if params {
            if let Some(k) = &self.key {
                s.push(' ');
                s.push_str(k);
            }
            if let Some(l) = self.limit {
                s.push(' ');
                s.push_str(&l.to_string());
            }
            if let Some(f) = &self.flood {
                let star = if f.ban { "*" } else { "" };
                s.push_str(&format!(" {star}{}:{}", f.lines, f.secs));
            }
            if let Some(j) = &self.joinflood {
                s.push_str(&format!(" {}:{}", j.count, j.secs));
            }
            if let Some(n) = &self.nickflood {
                s.push_str(&format!(" {}:{}", n.count, n.secs));
            }
            if let Some(t) = &self.redirect {
                s.push(' ');
                s.push_str(t);
            }
            if let Some((n, t)) = &self.history {
                s.push_str(&format!(" {n}:{t}"));
            }
        }
        s
    }
}

pub struct Channel {
    pub name: String, // display casing
    pub topic: Option<Topic>,
    pub members: HashMap<Uid, Member>,
    pub rmembers: HashMap<String, Member>, // remote members, by network uuid (S2S)
    pub modes: ChanModes,
    pub bans: Vec<Ban>,
    pub excepts: Vec<Ban>,     // +e ban exceptions
    pub invex: Vec<Ban>,       // +I invite exceptions
    pub filters: Vec<Ban>,     // +g word/glob message filters (mask = the glob)
    pub invites: HashSet<Uid>, // uids allowed past +i
    pub created: u64,
    // --- ephemeral flood counters (not modes; never rendered or synced) -------
    pub msgflood_hits: HashMap<Uid, Vec<u64>>, // +f per-user message times
    pub joinflood_hits: Vec<u64>,              // +j recent join times
    pub joinflood_until: u64,                  // +j locked out until this unix ts
    pub nickflood_hits: Vec<u64>,              // +F recent nick-change times
    pub nickflood_until: u64,                  // +F locked out until this unix ts
}

impl Channel {
    /// A fresh channel with the default `+nt` modes.
    pub fn new(name: &str) -> Channel {
        Channel {
            name: name.to_string(),
            topic: None,
            members: HashMap::new(),
            rmembers: HashMap::new(),
            modes: ChanModes {
                no_external: true,
                topic_ops: true,
                ..Default::default()
            },
            bans: Vec::new(),
            excepts: Vec::new(),
            invex: Vec::new(),
            filters: Vec::new(),
            invites: HashSet::new(),
            created: now(),
            msgflood_hits: HashMap::new(),
            joinflood_hits: Vec::new(),
            joinflood_until: 0,
            nickflood_hits: Vec::new(),
            nickflood_until: 0,
        }
    }

    /// True once no local *and* no remote members remain (safe to drop).
    pub fn is_empty(&self) -> bool {
        self.members.is_empty() && self.rmembers.is_empty()
    }
}

impl Server {
    /// A member's channel rank (0 if not a member).
    pub fn rank(&self, uid: Uid, key: &str) -> u8 {
        // SAMODE/SAKICK run as the server: every access check keys off rank(),
        // so a transient sudo makes them bypass the ladder cleanly.
        if self.mode_sudo {
            return RANK_OWNER;
        }
        self.channels
            .get(key)
            .and_then(|c| c.members.get(&uid))
            .map(|m| m.rank())
            .unwrap_or(0)
    }

    pub fn is_op(&self, uid: Uid, key: &str) -> bool {
        self.rank(uid, key) >= RANK_OP
    }

    pub fn is_member(&self, uid: Uid, key: &str) -> bool {
        self.channels
            .get(key)
            .map(|c| c.members.contains_key(&uid))
            .unwrap_or(false)
    }

    /// Force `uid` out of `chan` (SAPART / SVSPART enforcement): announce the PART
    /// to the channel and to links, drop the membership, reap the channel if empty.
    /// No-op if the user isn't a member.
    pub fn force_part(&mut self, uid: Uid, chan: &str, reason: &str) {
        let key = chan.to_ascii_lowercase();
        if !self.is_member(uid, &key) {
            return;
        }
        let prefix = self.users[&uid].prefix();
        self.to_channel(&key, &format!(":{prefix} PART {chan} :{reason}"), None);
        self.propagate_part(uid, chan, reason);
        if let Some(ch) = self.channels.get_mut(&key) {
            ch.members.remove(&uid);
        }
        if let Some(u) = self.users.get_mut(&uid) {
            u.channels.remove(&key);
        }
        self.channels.retain(|_, c| !c.is_empty());
    }

    /// Join a user to a channel (creating it if new, giving the creator +o),
    /// then broadcast JOIN and send TOPIC + NAMES. Queues the join hook.
    pub fn join(&mut self, uid: Uid, name: &str, key_arg: Option<&str>) {
        if !valid_chan(name) {
            self.numeric(uid, ERR_NOSUCHCHANNEL, &format!("{name} :No such channel"));
            return;
        }
        let key = name.to_ascii_lowercase();
        if self
            .users
            .get(&uid)
            .map(|u| u.channels.contains(&key))
            .unwrap_or(true)
        {
            return; // unknown user, or already joined
        }
        // an existing channel can refuse the join (+k / +b / +i / +l)
        if let Some(ch) = self.channels.get(&key) {
            if let Some(k) = &ch.modes.key {
                if key_arg != Some(k.as_str()) {
                    self.numeric(
                        uid,
                        ERR_BADCHANNELKEY,
                        &format!("{name} :Cannot join channel (+k)"),
                    );
                    return;
                }
            }
            // +b — bans block even an invited user, unless a +e exception matches
            let mask = self.users.get(&uid).map(|u| u.prefix()).unwrap_or_default();
            if ch.bans.iter().any(|b| glob_match(&b.mask, &mask))
                && !ch.excepts.iter().any(|e| glob_match(&e.mask, &mask))
            {
                self.numeric(
                    uid,
                    ERR_BANNEDFROMCHAN,
                    &format!("{name} :Cannot join channel (+b)"),
                );
                return;
            }
            // +i — unless invited or matched by a +I invite exception
            if ch.modes.invite_only
                && !ch.invites.contains(&uid)
                && !ch.invex.iter().any(|e| glob_match(&e.mask, &mask))
            {
                self.numeric(
                    uid,
                    ERR_INVITEONLYCHAN,
                    &format!("{name} :Cannot join channel (+i)"),
                );
                return;
            }
            // +z — TLS-connected users only
            if ch.modes.secure_only && !self.users.get(&uid).map(|u| u.secure).unwrap_or(false) {
                self.numeric(
                    uid,
                    ERR_SECUREONLYCHAN,
                    &format!("{name} :Cannot join channel; TLS users only (+z is set)"),
                );
                return;
            }
            // +O — IRC operators only
            if ch.modes.oper_only && !self.users.get(&uid).map(|u| u.flags.oper).unwrap_or(false) {
                self.numeric(
                    uid,
                    ERR_CANTJOINOPERSONLY,
                    &format!("{name} :Cannot join channel; IRC operators only (+O is set)"),
                );
                return;
            }
            // +R — must be logged into an account (services-registered)
            if ch.modes.reg_only
                && self
                    .users
                    .get(&uid)
                    .map(|u| u.account.is_none())
                    .unwrap_or(true)
            {
                self.numeric(
                    uid,
                    ERR_NEEDREGGEDNICK,
                    &format!("{name} :Cannot join channel; you must be logged in (+R is set)"),
                );
                return;
            }
        }
        // +l full — with +L redirect, bounce the user to the target instead
        if let Some(ch) = self.channels.get(&key) {
            let full = ch.modes.limit.is_some_and(|l| ch.members.len() as u32 >= l);
            let redirect = ch.modes.redirect.clone();
            if full {
                match redirect {
                    Some(t)
                        if !self.in_redirect
                            && t.to_ascii_lowercase() != key
                            && !self.is_member(uid, &t.to_ascii_lowercase()) =>
                    {
                        self.numeric(
                            uid,
                            ERR_LINKCHANNEL,
                            &format!("{name} {t} :Cannot join channel (+l), redirecting"),
                        );
                        self.in_redirect = true;
                        self.join(uid, &t, None);
                        self.in_redirect = false;
                        return;
                    }
                    _ => {
                        self.numeric(
                            uid,
                            ERR_CHANNELISFULL,
                            &format!("{name} :Cannot join channel (+l)"),
                        );
                        return;
                    }
                }
            }
        }
        // +j join flood — once tripped, the channel locks new joins out for 60s
        if self.channels.contains_key(&key) && self.joinflood_check(&key) {
            self.numeric(
                uid,
                ERR_UNAVAILRESOURCE,
                &format!("{name} :This channel is temporarily unavailable (+j join flood)"),
            );
            return;
        }
        let is_new = !self.channels.contains_key(&key);
        let ch = self
            .channels
            .entry(key.clone())
            .or_insert_with(|| Channel::new(name));
        ch.members.insert(
            uid,
            Member {
                op: is_new,
                ..Default::default()
            },
        );
        ch.invites.remove(&uid); // consume any pending invite
        if let Some(u) = self.users.get_mut(&uid) {
            u.channels.insert(key.clone());
        }

        // JOIN broadcast — extended-join clients also get the account + realname
        let (prefix, acct, realname) = {
            let u = &self.users[&uid];
            (
                u.prefix(),
                u.account.clone().unwrap_or_else(|| "*".to_string()),
                u.realname.clone(),
            )
        };
        let plain = format!(":{prefix} JOIN {name}");
        let extended = format!(":{prefix} JOIN {name} {acct} :{realname}");
        let aud = self.channels[&key].modes.auditorium;
        let members: Vec<Uid> = self.channels[&key].members.keys().copied().collect();
        for m in members {
            // +u auditorium: non-op members don't see other users join
            if aud && m != uid && self.rank(m, &key) < RANK_OP {
                continue;
            }
            let ext = self
                .users
                .get(&m)
                .map(|u| u.caps.extended_join)
                .unwrap_or(false);
            self.send(m, if ext { extended.clone() } else { plain.clone() });
        }
        if let Some(t) = self.channels[&key].topic.as_ref() {
            let text = t.text.clone();
            self.numeric(uid, RPL_TOPIC, &format!("{name} :{text}"));
        }
        self.send_names(uid, &key);
        self.replay_chanhistory(uid, &key); // +H: replay recent messages to the joiner
        self.propagate_join(uid, name); // tell linked servers this user joined
        self.events.push_back(Hook::Join(uid, key));
    }

    /// +H chanhistory: replay a channel's recent messages to a user who just
    /// joined — the last `<lines>` (within `<secs>`, 0 = no limit) from the store,
    /// wrapped in a `chathistory` batch for batch-capable clients.
    fn replay_chanhistory(&mut self, uid: Uid, key: &str) {
        let Some((lines, secs)) = self.channels.get(key).and_then(|c| c.modes.history) else {
            return;
        };
        let Some(name) = self.channels.get(key).map(|c| c.name.clone()) else {
            return;
        };
        let batch = self.users.get(&uid).map(|u| u.caps.batch).unwrap_or(false);
        let cutoff = if secs > 0 {
            now().saturating_sub(secs)
        } else {
            0
        };
        let bref = if batch {
            Some(self.next_msgid().replace('-', ""))
        } else {
            None
        };
        let out: Vec<String> = match self.ext.get::<History>().and_then(|h| h.0.get(key)) {
            Some(buf) => {
                let mut recent: Vec<&HistMsg> = buf.iter().filter(|m| m.ts >= cutoff).collect();
                let start = recent.len().saturating_sub(lines as usize);
                recent.drain(..start);
                recent
                    .iter()
                    .map(|m| {
                        let mut tags = format!("time={};msgid={}", iso_time(m.ts), m.msgid);
                        if let Some(b) = &bref {
                            tags.push_str(&format!(";batch={b}"));
                        }
                        format!("@{tags} :{} {} {name} :{}", m.prefix, m.verb, m.text)
                    })
                    .collect()
            }
            None => return,
        };
        if out.is_empty() {
            return;
        }
        if let Some(b) = &bref {
            self.send(uid, format!(":{} BATCH +{b} chathistory {name}", self.name));
        }
        for l in out {
            self.send(uid, l);
        }
        if let Some(b) = &bref {
            self.send(uid, format!(":{} BATCH -{b}", self.name));
        }
    }

    pub fn send_names(&self, uid: Uid, key: &str) {
        let Some(ch) = self.channels.get(key) else {
            self.numeric(uid, RPL_ENDOFNAMES, &format!("{key} :End of /NAMES list"));
            return;
        };
        // +s (secret) / +p (private): members are hidden from non-members. Reply as
        // if the channel were empty (opers still see it).
        if (ch.modes.secret || ch.modes.private)
            && !ch.members.contains_key(&uid)
            && !self.is_oper(uid)
        {
            self.numeric(
                uid,
                RPL_ENDOFNAMES,
                &format!("{} :End of /NAMES list", ch.name),
            );
            return;
        }
        // multi-prefix → all prefixes; userhost-in-names → full nick!user@host
        let (multi, uhost) = self
            .users
            .get(&uid)
            .map(|u| (u.caps.multi_prefix, u.caps.userhost_in_names))
            .unwrap_or((false, false));
        // +u auditorium: a non-op viewer only sees ops (plus themselves)
        let hide =
            ch.modes.auditorium && ch.members.get(&uid).map(|m| m.rank()).unwrap_or(0) < RANK_OP;
        let mut names = String::new();
        for (m, flags) in &ch.members {
            if hide && *m != uid && flags.rank() < RANK_OP {
                continue;
            }
            let p = if multi {
                flags.all_prefixes()
            } else {
                flags.prefix_char().to_string()
            };
            if let Some(u) = self.users.get(m) {
                names.push_str(&p);
                let shown = if uhost { u.prefix() } else { u.nick.clone() };
                names.push_str(&shown);
                names.push(' ');
            }
        }
        // remote members (users on linked servers)
        for (ruuid, mem) in &ch.rmembers {
            if hide && mem.rank() < RANK_OP {
                continue;
            }
            if let Some(ru) = self.remote_users.get(ruuid) {
                let p = if multi {
                    mem.all_prefixes()
                } else {
                    mem.prefix_char().to_string()
                };
                names.push_str(&p);
                let shown = if uhost { ru.prefix() } else { ru.nick.clone() };
                names.push_str(&shown);
                names.push(' ');
            }
        }
        self.numeric(
            uid,
            RPL_NAMREPLY,
            &format!("= {} :{}", ch.name, names.trim_end()),
        );
        self.numeric(
            uid,
            RPL_ENDOFNAMES,
            &format!("{} :End of /NAMES list", ch.name),
        );
    }

    /// True if `uid` is caught by an acting extban of type `kind` (`m`/`c`/`n`) on
    /// `key` with no matching `kind:` exception in +e. The stored mask is
    /// `kind:<hostmask>`; we glob the hostmask part against the user's prefix.
    pub fn extban_active(&self, uid: Uid, key: &str, kind: char) -> bool {
        let Some(ch) = self.channels.get(key) else {
            return false;
        };
        let Some(who) = self.users.get(&uid).map(|u| u.prefix()) else {
            return false;
        };
        let pfx = format!("{kind}:");
        let hit = |list: &Vec<Ban>| {
            list.iter()
                .filter(|b| b.mask.starts_with(&pfx))
                .any(|b| glob_match(&b.mask[2..], &who))
        };
        hit(&ch.bans) && !hit(&ch.excepts)
    }

    /// Broadcast a membership line, honouring +u auditorium: when set, non-op
    /// members other than `actor` don't see it. `actor` always receives it.
    pub fn to_channel_vis(&self, key: &str, line: &str, actor: Uid) {
        if let Some(ch) = self.channels.get(key) {
            let aud = ch.modes.auditorium;
            for (&uid, m) in &ch.members {
                if aud && uid != actor && m.rank() < RANK_OP {
                    continue;
                }
                self.send(uid, line.to_string());
            }
        }
    }

    /// +f: record a channel message from `uid`; `Some(ban)` when they just went
    /// over the limit (ban ⇒ also set a +b). Members at half-op+ and opers are
    /// exempt (checked by the caller).
    pub fn messageflood_hit(&mut self, uid: Uid, key: &str) -> Option<bool> {
        let n = now();
        let ch = self.channels.get_mut(key)?;
        let f = ch.modes.flood.clone()?;
        let v = ch.msgflood_hits.entry(uid).or_default();
        v.retain(|&t| n.saturating_sub(t) < f.secs);
        v.push(n);
        if v.len() as u32 > f.lines {
            ch.msgflood_hits.remove(&uid);
            Some(f.ban)
        } else {
            None
        }
    }

    /// Kick `uid` from `key` for flooding (optionally banning `*!*@host` first),
    /// broadcasting the KICK and queuing the part hook.
    pub fn flood_kick(&mut self, uid: Uid, key: &str, ban: bool) {
        let (nick, host) = match self.users.get(&uid) {
            Some(u) => (u.nick.clone(), u.host_display().to_string()),
            None => return,
        };
        let cname = self
            .channels
            .get(key)
            .map(|c| c.name.clone())
            .unwrap_or_else(|| key.to_string());
        if ban {
            let mask = format!("*!*@{host}");
            if let Some(c) = self.channels.get_mut(key) {
                if !c.bans.iter().any(|b| b.mask == mask) {
                    c.bans.push(Ban {
                        mask,
                        setter: self.name.clone(),
                        ts: now(),
                    });
                }
            }
        }
        self.to_channel(
            key,
            &format!(":{} KICK {cname} {nick} :Flood", self.name),
            None,
        );
        self.propagate_from_user(uid, &format!("KICK {cname} {nick} :Flood"));
        if let Some(c) = self.channels.get_mut(key) {
            c.members.remove(&uid);
        }
        if let Some(u) = self.users.get_mut(&uid) {
            u.channels.remove(key);
        }
        self.channels.retain(|_, c| !c.is_empty());
        self.events
            .push_back(Hook::Part(uid, key.to_string(), "flood".to_string()));
    }

    /// +j: record a join attempt on `key`; true if joins are (now) locked out.
    pub fn joinflood_check(&mut self, key: &str) -> bool {
        let n = now();
        let Some(ch) = self.channels.get_mut(key) else {
            return false;
        };
        let Some(f) = ch.modes.joinflood.clone() else {
            return false;
        };
        if n < ch.joinflood_until {
            return true; // still locked out
        }
        ch.joinflood_hits.retain(|&t| n.saturating_sub(t) < f.secs);
        ch.joinflood_hits.push(n);
        if ch.joinflood_hits.len() as u32 > f.count {
            ch.joinflood_until = n + 60; // lock the channel for 60s
            ch.joinflood_hits.clear();
            return true;
        }
        false
    }

    /// +F: record a nick change and return the display name of any channel that
    /// is (now) locked out — the caller denies the change if so. Opers exempt.
    pub fn nickflood_blocked(&mut self, uid: Uid) -> Option<String> {
        let n = now();
        let keys: Vec<String> = self
            .users
            .get(&uid)
            .map(|u| u.channels.iter().cloned().collect())
            .unwrap_or_default();
        let mut blocked = None;
        for key in keys {
            let Some(ch) = self.channels.get_mut(&key) else {
                continue;
            };
            let Some(f) = ch.modes.nickflood.clone() else {
                continue;
            };
            if n < ch.nickflood_until {
                blocked.get_or_insert_with(|| ch.name.clone());
                continue;
            }
            ch.nickflood_hits.retain(|&t| n.saturating_sub(t) < f.secs);
            ch.nickflood_hits.push(n);
            if ch.nickflood_hits.len() as u32 > f.count {
                ch.nickflood_until = n + 60;
                ch.nickflood_hits.clear();
                blocked.get_or_insert_with(|| ch.name.clone());
            }
        }
        blocked
    }
}

/// A channel name starts with `#`, is ≤ 50 chars, and has no space/comma/control.
pub fn valid_chan(name: &str) -> bool {
    name.starts_with('#')
        && name.len() > 1
        && name.len() <= 50
        && !name
            .chars()
            .any(|c| c == ' ' || c == ',' || (c as u32) < 0x20)
}

/// Case-insensitive glob (`*` = any run, `?` = one char) — for +b mask matching.
pub fn glob_match(pat: &str, s: &str) -> bool {
    let p: Vec<char> = pat.to_lowercase().chars().collect();
    let t: Vec<char> = s.to_lowercase().chars().collect();
    let (mut pi, mut ti) = (0usize, 0usize);
    let mut star: Option<usize> = None;
    let mut mark = 0usize;
    while ti < t.len() {
        if pi < p.len() && (p[pi] == '?' || p[pi] == t[ti]) {
            pi += 1;
            ti += 1;
        } else if pi < p.len() && p[pi] == '*' {
            star = Some(pi);
            mark = ti;
            pi += 1;
        } else if let Some(sp) = star {
            pi = sp + 1;
            mark += 1;
            ti = mark;
        } else {
            return false;
        }
    }
    while pi < p.len() && p[pi] == '*' {
        pi += 1;
    }
    pi == p.len()
}

/// Fill out a ban mask to `nick!user@host` form (`bob` → `bob!*@*`).
pub fn normalize_mask(m: &str) -> String {
    match (m.contains('!'), m.contains('@')) {
        (true, true) => m.to_string(),
        (false, true) => format!("*!{m}"),
        (true, false) => format!("{m}@*"),
        (false, false) => format!("{m}!*@*"),
    }
}

/// Like [`normalize_mask`] but aware of extbans: `m:bob` normalises only the
/// value after the `X:` prefix, so acting bans (`m:` mute, `c:` nocolor,
/// `n:` nonick) keep their type while their hostmask is filled out.
pub fn normalize_ban_mask(m: &str) -> String {
    let b = m.as_bytes();
    if b.len() >= 2 && b[1] == b':' && (b[0] as char).is_ascii_alphabetic() {
        return format!("{}:{}", &m[..1], normalize_mask(&m[2..]));
    }
    normalize_mask(m)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn member_rank_and_prefix_char_take_the_highest() {
        let mut m = Member::default();
        assert_eq!(m.rank(), 0);
        assert_eq!(m.prefix_char(), "");
        m.voice = true;
        assert_eq!((m.rank(), m.prefix_char()), (RANK_VOICE, "+"));
        m.halfop = true;
        assert_eq!((m.rank(), m.prefix_char()), (RANK_HALFOP, "%"));
        m.op = true;
        assert_eq!((m.rank(), m.prefix_char()), (RANK_OP, "@"));
        m.admin = true;
        assert_eq!((m.rank(), m.prefix_char()), (RANK_ADMIN, "&"));
        m.owner = true;
        assert_eq!((m.rank(), m.prefix_char()), (RANK_OWNER, "~"));
    }
}