use std::collections::HashSet;
use std::sync::Arc;
use std::time::{Duration, Instant};

use elefren::{FediClient, StatusBuilder};
use elefren::debug::EventDisplay;
use elefren::debug::NotificationDisplay;
use elefren::debug::StatusDisplay;
use elefren::entities::event::Event;
use elefren::entities::notification::{Notification, NotificationType};
use elefren::entities::status::Status;
use elefren::status_builder::Visibility;
use futures::StreamExt;

use crate::command::StatusCommand;
use crate::error::GroupError;
use crate::store::ConfigStore;
use crate::store::data::GroupConfig;
use crate::utils::{LogError, normalize_acct};

/// This is one group's config store capable of persistence
#[derive(Debug)]
pub struct GroupHandle {
    pub(crate) client: FediClient,
    pub(crate) config: GroupConfig,
    pub(crate) store: Arc<ConfigStore>,
}

const DELAY_BEFORE_ACTION: Duration = Duration::from_millis(250);
const DELAY_REOPEN_STREAM: Duration = Duration::from_millis(500);
const MAX_CATCHUP_NOTIFS: usize = 25;
// also statuses
const MAX_CATCHUP_STATUSES: usize = 50;
// higher because we can expect a lot of non-hashtag statuses here
const PERIODIC_SAVE: Duration = Duration::from_secs(60);
const PING_INTERVAL: Duration = Duration::from_secs(15); // must be < periodic save!

impl GroupHandle {
    pub async fn save(&mut self) -> Result<(), GroupError> {
        debug!("Saving group config & status");
        self.store.set_group_config(self.config.clone()).await?;
        debug!("Saved");
        self.config.clear_dirty_status();
        Ok(())
    }

    pub async fn save_if_needed(&mut self) -> Result<(), GroupError> {
        if self.config.is_dirty() {
            self.save().await?;
        }
        Ok(())
    }

    /*
    pub async fn reload(&mut self) -> Result<(), GroupError> {
        if let Some(g) = self.store.get_group_config(self.config.get_acct()).await {
            self.config = g;
            Ok(())
        } else {
            Err(GroupError::GroupNotExist)
        }
    }
    */
}

trait NotifTimestamp {
    fn timestamp_millis(&self) -> u64;
}

impl NotifTimestamp for Notification {
    fn timestamp_millis(&self) -> u64 {
        self.created_at.timestamp_millis().max(0) as u64
    }
}

impl NotifTimestamp for Status {
    fn timestamp_millis(&self) -> u64 {
        // this may not work well for unseen status tracking,
        // if ancient statuses were to appear in the timeline :(
        self.created_at.timestamp_millis().max(0) as u64
    }
}

impl GroupHandle {
    pub async fn run(&mut self) -> Result<(), GroupError> {
        assert!(PERIODIC_SAVE >= PING_INTERVAL);

        loop {
            debug!("Opening streaming API socket");
            let mut next_save = Instant::now() + PERIODIC_SAVE; // so we save at start
            let mut events = self.client.streaming_user().await?;
            let socket_open_time = Instant::now();
            let mut last_rx = Instant::now();
            let mut last_ping = Instant::now();

            match self.catch_up_with_missed_notifications().await {
                Ok(true) => {
                    debug!("Some missed notifs handled");
                }
                Ok(false) => {
                    debug!("No notifs missed");
                }
                Err(e) => {
                    error!("Failed to handle missed notifs: {}", e);
                }
            }

            match self.catch_up_with_missed_statuses().await {
                Ok(true) => {
                    debug!("Some missed statuses handled");
                }
                Ok(false) => {
                    debug!("No statuses missed");
                }
                Err(e) => {
                    error!("Failed to handle missed statuses: {}", e);
                }
            }

            if self.config.is_dirty() {
                // save asap
                next_save = Instant::now() - PERIODIC_SAVE
            }

            'rx: loop {
                if next_save < Instant::now() {
                    debug!("Save time elapsed, saving if needed");
                    self.save_if_needed().await.log_error("Failed to save group");
                    next_save = Instant::now() + PERIODIC_SAVE;
                }

                if last_rx.elapsed() > PING_INTERVAL * 2 {
                    warn!("Socket idle too long, close");
                    break 'rx;
                }

                if socket_open_time.elapsed() > Duration::from_secs(120) {
                    debug!("Socket open too long, closing");
                    break 'rx;
                }

                debug!("Await msg");
                let timeout = next_save
                    .saturating_duration_since(Instant::now())
                    .min(PING_INTERVAL)
                    .max(Duration::from_secs(1));

                match tokio::time::timeout(timeout, events.next()).await {
                    Ok(Some(event)) => {
                        last_rx = Instant::now();
                        debug!("(@{}) Event: {}", self.config.get_acct(), EventDisplay(&event));
                        match event {
                            Event::Update(status) => {
                                self.handle_status(status).await.log_error("Error handling a status");
                            }
                            Event::Notification(n) => {
                                self.handle_notification(n).await.log_error("Error handling a notification");
                            }
                            Event::Delete(_id) => {}
                            Event::FiltersChanged => {}
                            Event::Heartbeat => {}
                        }
                    }
                    Ok(None) => {
                        warn!("Group @{} socket closed, restarting...", self.config.get_acct());
                        break 'rx;
                    }
                    Err(_) => {
                        // Timeout so we can save if needed
                    }
                }

                if last_ping.elapsed() > PING_INTERVAL {
                    last_ping = Instant::now();
                    debug!("Pinging");
                    if events.send_ping()
                        .await.is_err() {
                        break 'rx;
                    }
                }
            }

            warn!("Notif stream closed, will reopen");
            tokio::time::sleep(DELAY_REOPEN_STREAM).await;
        }
    }

    async fn handle_notification(&mut self, n: Notification) -> Result<(), GroupError> {
        debug!("Handling notif #{}", n.id);
        let ts = n.timestamp_millis();
        self.config.set_last_notif(ts);

        let group_acct = self.config.get_acct().to_string();
        let notif_user_id = &n.account.id;
        let notif_acct = normalize_acct(&n.account.acct, &group_acct)?;

        if notif_acct == group_acct {
            debug!("This is our post, ignore that");
            return Ok(());
        }

        if self.config.is_banned(&notif_acct) {
            warn!("Notification actor {} is banned!", notif_acct);
            return Ok(());
        }

        match n.notification_type {
            NotificationType::Mention => {
                if let Some(status) = n.status {
                    self.handle_mention_status(status).await?;
                }
            }
            NotificationType::Follow => {
                info!("New follower!");

                if self.config.is_member_or_admin(&notif_acct) {
                    // Already joined, just doing something silly, ignore this
                    debug!("User already a member, ignoring");
                } else {
                    let text = if self.config.is_member_only() {
                        // Admins are listed without @, so they won't become handles here.
                        // Tagging all admins would be annoying.
                        let mut admins = self.config.get_admins().cloned().collect::<Vec<_>>();
                        admins.sort();
                        format!(
                            "@{user} Hi, this is a member-only group, you won't be \
                            able to post. You can still receive group posts though. If you'd like to join, \
                            please ask one of the group admins to add you:\n\n\
                         {admins}",
                            user = notif_acct,
                            admins = admins.join(", ")
                        )
                    } else {
                        self.follow_user(notif_user_id).await
                            .log_error("Failed to follow");
                        make_welcome_text(&notif_acct)
                    };

                    let post = StatusBuilder::new()
                        .status(text)
                        .content_type("text/markdown")
                        .visibility(Visibility::Direct)
                        .build()
                        .expect("error build status");

                    // tokio::time::sleep(Duration::from_millis(500)).await;
                    let _ = self.client.new_status(post).await.log_error("Failed to post");
                }
            }
            NotificationType::Favourite => {}
            NotificationType::Reblog => {}
        }

        Ok(())
    }

    /// Handle a non-mention status
    async fn handle_status(&mut self, s: Status) -> Result<(), GroupError> {
        debug!("Handling status #{}", s.id);
        let ts = s.timestamp_millis();
        self.config.set_last_status(ts);

        let group_user = self.config.get_acct();
        let status_user = normalize_acct(&s.account.acct, group_user)?;

        if status_user == group_user {
            debug!("This is our post, ignore that");
            return Ok(());
        }

        // for m in &s.mentions {
        //     let ma = normalize_acct(&m.acct, gu)?;
        //     if ma == gu {
        //         debug!("Mention detected, handle status as mention notification!");
        //         return self.handle_mention_status(s).await;
        //     }
        // }

        if !s.content.contains('#') {
            debug!("No tags in status");
            return Ok(());
        }

        if s.visibility.is_private() {
            debug!("Status is direct/private, not boosting");
            return Ok(());
        }

        if s.content.contains("/add ") || s.content.contains("/remove ") {
            debug!("Discard, looks like a hashtag manipulation command");
            return Ok(());
        }


        if self.config.is_banned(&status_user) {
            debug!("Status author @{} is banned.", status_user);
            return Ok(());
        }

        if !self.config.is_member_or_admin(&status_user) {
            debug!("Status author @{} is not a member.", status_user);
            return Ok(());
        }

        let tags = crate::command::parse_status_tags(&s.content);
        debug!("Tags in status: {:?}", tags);

        for t in tags {
            if self.config.is_tag_followed(&t) {
                self.client.reblog(&s.id).await
                    .log_error("Failed to reblog");
                break;
            }
        }

        Ok(())
    }

    async fn follow_user(&mut self, id: &str) -> Result<(), GroupError> {
        self.client.follow(id).await?;
        Ok(())
    }

    async fn unfollow_user(&mut self, id: &str) -> Result<(), GroupError> {
        self.client.unfollow(id).await?;
        Ok(())
    }

    /// Catch up with missed notifications, returns true if any were handled
    async fn catch_up_with_missed_notifications(&mut self) -> Result<bool, GroupError> {
        let last_notif = self.config.get_last_notif();

        let notifications = self.client.notifications().await?;
        let mut iter = notifications.items_iter();

        let mut notifs_to_handle = vec![];

        // They are retrieved newest first, but we want oldest first for chronological handling

        let mut num = 0;
        while let Some(n) = iter.next_item().await {
            let ts = n.timestamp_millis();
            if ts <= last_notif {
                break; // reached our last seen notif
            }

            debug!("Inspecting notif {}", NotificationDisplay(&n));
            notifs_to_handle.push(n);
            num += 1;
            if num > MAX_CATCHUP_NOTIFS {
                warn!("Too many notifs missed to catch up!");
                break;
            }

            // sleep so we dont make the api angry
            tokio::time::sleep(Duration::from_millis(250)).await;
        }

        if notifs_to_handle.is_empty() {
            return Ok(false);
        }

        notifs_to_handle.reverse();

        debug!("{} notifications to catch up!", notifs_to_handle.len());

        for n in notifs_to_handle {
            debug!("Handling missed notification: {}", NotificationDisplay(&n));
            self.handle_notification(n).await.log_error("Error handling a notification");
        }

        Ok(true)
    }

    /// Catch up with missed statuses, returns true if any were handled
    async fn catch_up_with_missed_statuses(&mut self) -> Result<bool, GroupError> {
        let last_status = self.config.get_last_status();

        let statuses = self.client.get_home_timeline().await?;
        let mut iter = statuses.items_iter();

        let mut statuses_to_handle = vec![];

        // They are retrieved newest first, but we want oldest first for chronological handling

        let mut newest_status = None;

        let mut num = 0;
        while let Some(s) = iter.next_item().await {
            let ts = s.timestamp_millis();
            if ts <= last_status {
                break; // reached our last seen status (hopefully there arent any retro-bumped)
            }

            debug!("Inspecting status {}", StatusDisplay(&s));

            if newest_status.is_none() {
                newest_status = Some(ts);
            }

            if s.content.contains('#') && !s.visibility.is_private() {
                statuses_to_handle.push(s);
            }
            num += 1;
            if num > MAX_CATCHUP_STATUSES {
                warn!("Too many statuses missed to catch up!");
                break;
            }

            // sleep so we dont make the api angry
            tokio::time::sleep(Duration::from_millis(250)).await;
        }

        if let Some(ts) = newest_status {
            self.config.set_last_status(ts);
        }

        if statuses_to_handle.is_empty() {
            return Ok(false);
        }

        statuses_to_handle.reverse();

        debug!("{} statuses to catch up!", statuses_to_handle.len());

        for s in statuses_to_handle {
            debug!("Handling missed status: {}", StatusDisplay(&s));
            self.handle_status(s).await
                .log_error("Error handling a status");
        }

        Ok(true)
    }

    fn list_admins(&self, replies: &mut Vec<String>) {
        let mut admins = self.config.get_admins().collect::<Vec<_>>();
        admins.sort();
        for a in admins {
            replies.push(a.to_string());
        }
    }

    fn list_members(&self, replies: &mut Vec<String>) {
        let admins = self.config.get_admins().collect::<HashSet<_>>();
        let mut members = self.config.get_members().collect::<Vec<_>>();
        members.extend(admins.iter());
        members.sort();
        members.dedup();
        for m in members {
            if admins.contains(&m) {
                replies.push(format!("{} [admin]", m));
            } else {
                replies.push(m.to_string());
            }
        }
    }
    async fn handle_mention_status(&mut self, status: Status) -> Result<(), GroupError> {
        let group_acct = self.config.get_acct().to_string();
        let status_acct = normalize_acct(&status.account.acct, &group_acct)?;
        let status_user_id = &status.account.id;

        let can_write = self.config.can_write(&status_acct);
        let is_admin = self.config.is_admin(&status_acct);

        if self.config.is_banned(&status_acct) {
            warn!("Status author {} is banned!", status_acct);
            return Ok(());
        }

        let commands = crate::command::parse_slash_commands(&status.content);

        let mut replies = vec![];
        let mut announcements = vec![];
        let mut do_boost_prev_post = false;
        let mut any_admin_cmd = false;
        let mut want_markdown = false;

        if commands.is_empty() {
            debug!("No commands in post");
            if status.in_reply_to_id.is_none() {
                if can_write {
                    // Someone tagged the group in OP, boost it.
                    info!("Boosting OP mention");
                    // tokio::time::sleep(DELAY_BEFORE_ACTION).await;
                    self.client.reblog(&status.id).await.log_error("Failed to boost");
                } else {
                    replies.push("You are not allowed to post to this group".to_string());
                }
            } else {
                debug!("Not OP, ignore mention");
            }
        } else {
            for cmd in commands {
                match cmd {
                    // ignore is first on purpose
                    StatusCommand::Ignore => {
                        debug!("Notif ignored because of ignore command");
                        return Ok(());
                    }
                    StatusCommand::Announce(a) => {
                        info!("Sending PSA");
                        announcements.push(a);
                    }
                    StatusCommand::Boost => {
                        if can_write {
                            do_boost_prev_post = status.in_reply_to_id.is_some();
                        } else {
                            replies.push("You are not allowed to share to this group".to_string());
                        }
                    }
                    StatusCommand::BanUser(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if !self.config.is_banned(&u) {
                                match self.config.ban_user(&u, true) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        replies.push(format!("User {} banned from group!", u));

                                        // FIXME we need user ID, not handle - get it via API?
                                        // self.unfollow_user(&u).await
                                        //     .log_error("Failed to unfollow");

                                        // no announcement here
                                    }
                                    Err(e) => {
                                        replies.push(format!("Failed to ban user {}: {}", u, e));
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage user bans".to_string());
                        }
                    }
                    StatusCommand::UnbanUser(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if self.config.is_banned(&u) {
                                match self.config.ban_user(&u, false) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        replies.push(format!("User {} un-banned!", u));

                                        // no announcement here
                                    }
                                    Err(_) => {
                                        unreachable!()
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage user bans".to_string());
                        }
                    }
                    StatusCommand::BanServer(s) => {
                        if is_admin {
                            if !self.config.is_server_banned(&s) {
                                match self.config.ban_server(&s, true) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        announcements.push(format!("Server \"{}\" has been banned.", s));
                                        replies.push(format!("Server {} banned from group!", s));
                                    }
                                    Err(e) => {
                                        replies.push(format!("Failed to ban server {}: {}", s, e));
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage server bans".to_string());
                        }
                    }
                    StatusCommand::UnbanServer(s) => {
                        if is_admin {
                            if self.config.is_server_banned(&s) {
                                match self.config.ban_server(&s, false) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        announcements.push(format!("Server \"{}\" has been un-banned.", s));
                                        replies.push(format!("Server {} un-banned!", s));
                                    }
                                    Err(_) => {
                                        unreachable!()
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage server bans".to_string());
                        }
                    }
                    StatusCommand::AddMember(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if !self.config.is_member(&u) {
                                match self.config.set_member(&u, true) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        replies.push(format!("User {} added to the group!", u));
                                        self.follow_user(status_user_id).await.log_error("Failed to follow");
                                    }
                                    Err(e) => {
                                        replies.push(format!("Failed to add user {} to group: {}", u, e));
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage members".to_string());
                        }
                    }
                    StatusCommand::RemoveMember(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if self.config.is_member(&u) {
                                match self.config.set_member(&u, false) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        replies.push(format!("User {} removed from the group.", u));

                                        // FIXME we need user ID, not handle - get it via API?
                                        // self.unfollow_user(&u).await
                                        //     .log_error("Failed to unfollow");
                                    }
                                    Err(_) => {
                                        unreachable!()
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage members".to_string());
                        }
                    }
                    StatusCommand::AddTag(tag) => {
                        if is_admin {
                            any_admin_cmd = true;
                            self.config.add_tag(&tag);
                            replies.push(format!("Tag #{} added to the group!", tag));
                        } else {
                            replies.push("Only admins can manage group tags".to_string());
                        }
                    }
                    StatusCommand::RemoveTag(tag) => {
                        if is_admin {
                            any_admin_cmd = true;
                            self.config.remove_tag(&tag);
                            replies.push(format!("Tag #{} removed from the group!", tag));
                        } else {
                            replies.push("Only admins can manage group tags".to_string());
                        }
                    }
                    StatusCommand::GrantAdmin(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if !self.config.is_admin(&u) {
                                match self.config.set_admin(&u, true) {
                                    Ok(_) => {
                                        // try to make the config a little more sane, admins should be members
                                        let _ = self.config.set_member(&u, true);

                                        any_admin_cmd = true;
                                        replies.push(format!("User {} is now a group admin!", u));
                                        announcements
                                            .push(format!("User @{} can now manage this group!", u));
                                    }
                                    Err(e) => {
                                        replies.push(format!(
                                            "Failed to make user {} a group admin: {}",
                                            u, e
                                        ));
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage admins".to_string());
                        }
                    }
                    StatusCommand::RemoveAdmin(u) => {
                        let u = normalize_acct(&u, &group_acct)?;
                        if is_admin {
                            if self.config.is_admin(&u) {
                                match self.config.set_admin(&u, false) {
                                    Ok(_) => {
                                        any_admin_cmd = true;
                                        replies.push(format!("User {} is no longer a group admin!", u));
                                        announcements
                                            .push(format!("User @{} no longer manages this group.", u));
                                    }
                                    Err(e) => {
                                        replies
                                            .push(format!("Failed to revoke {}'s group admin: {}", u, e));
                                    }
                                }
                            }
                        } else {
                            replies.push("Only admins can manage admins".to_string());
                        }
                    }
                    StatusCommand::OpenGroup => {
                        if is_admin {
                            if self.config.is_member_only() {
                                any_admin_cmd = true;
                                self.config.set_member_only(false);
                                replies.push("Group changed to open-access".to_string());
                                announcements.push("This group is now open-access!".to_string());
                            }
                        } else {
                            replies.push("Only admins can set group options".to_string());
                        }
                    }
                    StatusCommand::CloseGroup => {
                        if is_admin {
                            if !self.config.is_member_only() {
                                any_admin_cmd = true;
                                self.config.set_member_only(true);
                                replies.push("Group changed to member-only".to_string());
                                announcements.push("This group is now member-only!".to_string());
                            }
                        } else {
                            replies.push("Only admins can set group options".to_string());
                        }
                    }
                    StatusCommand::Help => {
                        want_markdown = true;

                        if self.config.is_member_only() {
                            replies.push("This is a member-only group. ".to_string());
                        } else {
                            replies.push("This is a public-access group. ".to_string());
                        }

                        if self.config.can_write(&status_acct) {
                            if is_admin {
                                replies.push("*You are an admin.*".to_string());
                            } else {
                                replies.push("*You are a member.*".to_string());
                            }
                        } else {
                            if self.config.is_member_only() {
                                replies.push("*You are not a member, ask one of the admins to add you.*".to_string());
                            } else {
                                replies.push("*You are not a member, follow or use /join to join the group.*".to_string());
                            }
                        }

                        replies.push(
                            "\nTo share an original post, mention the group user.\n\
                                        Replies and mentions with commands won't be shared.\n\
                                        \n\
                                        **Supported commands:**\n\
                                        `/boost, /b` - boost the replied-to post into the group\n\
                                        `/ignore, /i` - make the group completely ignore the post\n\
                                        `/ping` - check that the service is alive\n\
                                        `/join` - join the group\n\
                                        `/leave` - leave the group".to_string(),
                        );

                        if self.config.is_member_only() {
                            replies.push("`/members, /who` - show group members / admins".to_string());
                        } else {
                            replies.push("`/members, /who` - show group admins".to_string());
                        }

                        if is_admin {
                            replies.push(
                                "\n\
                                            **Admin commands:**\n\
                                            `/add user` - add a member (use e-mail style address)\n\
                                            `/kick, /remove user` - kick a member\n\
                                            `/ban x` - ban a user or a server\n\
                                            `/unban x` - lift a ban\n\
                                            `/op, /admin user` - grant admin rights\n\
                                            `/deop, /deadmin user` - revoke admin rights\n\
                                            `/opengroup` - make member-only\n\
                                            `/closegroup` - make public-access\n\
                                            `/announce x` - make a public announcement from the rest of the status"
                                    .to_string(),
                            );
                        }
                    }
                    StatusCommand::ListMembers => {
                        let mut show_admins = false;
                        if is_admin {
                            replies.push("Group members:".to_string());
                            self.list_members(&mut replies);
                        } else {
                            replies.push("Group admins:".to_string());
                            self.list_admins(&mut replies);
                        }
                    }
                    StatusCommand::ListTags => {
                        replies.push("Group tags:".to_string());
                        let mut tags = self.config.get_tags().collect::<Vec<_>>();
                        tags.sort();
                        for t in tags {
                            replies.push(format!("#{}", t));
                        }
                    }
                    StatusCommand::Leave => {
                        if self.config.is_member_or_admin(&status_acct) {
                            // admin can leave but that's a bad idea

                            any_admin_cmd = true;
                            let _ = self.config.set_member(&status_acct, false);
                            replies.push("You're no longer a group member. Unfollow the group user to stop receiving group messages.".to_string());

                            self.unfollow_user(&status_user_id).await
                                .log_error("Failed to unfollow");
                        }
                    }
                    StatusCommand::Join => {
                        if self.config.is_member_or_admin(&status_acct) {
                            // Already a member, so let's try to follow the user
                            // again, maybe first time it failed
                            self.follow_user(status_user_id).await
                                .log_error("Failed to follow");
                        } else {
                            // Not a member yet
                            if self.config.is_member_only() {
                                // No you can't
                                replies.push(format!(
                                    "Hi, this group is closed to new sign-ups.\n\
                                    Please ask one of the group admins to add you:"));
                                self.list_admins(&mut replies);
                            } else {
                                // Open access
                                self.follow_user(status_user_id).await
                                    .log_error("Failed to follow");

                                // This only fails if the user is banned, but that is filtered above
                                let _ = self.config.set_member(&status_acct, true);
                                replies.push(format!("\
                                    Thanks for joining, you are now a member and the group user will \
                                    follow you so you can use group hashtags. Make sure you follow the \
                                    group user to receive group messages."));
                            }
                        }
                    }
                    StatusCommand::Ping => {
                        replies.push("Pong".to_string());
                    }
                }
            }

            // tokio::time::sleep(DELAY_BEFORE_ACTION).await;
        }

        if do_boost_prev_post {
            self.client
                .reblog(&status.in_reply_to_id.as_ref().unwrap())
                .await
                .log_error("Failed to boost");
        }

        if !replies.is_empty() {
            debug!("replies={:?}", replies);
            let r = replies.join("\n");
            debug!("r={}", r);

            let post = StatusBuilder::new()
                .status(format!("@{user}\n{msg}", user = status_acct, msg = r))
                .content_type(if want_markdown {
                    "text/markdown"
                } else {
                    "text/plain"
                })
                .visibility(Visibility::Direct)
                .build()
                .expect("error build status");

            let _ = self.client.new_status(post).await.log_error("Failed to post");
        }

        if !announcements.is_empty() {
            let msg = announcements.join("\n");
            let post = StatusBuilder::new()
                .status(format!("**📢 Group announcement**\n{msg}", msg = msg))
                .content_type("text/markdown")
                .visibility(Visibility::Public)
                .build()
                .expect("error build status");

            let _ = self.client.new_status(post).await.log_error("Failed to post");
        }

        if any_admin_cmd {
            debug!("Saving after admin cmd");
            self.save_if_needed().await.log_error("Failed to save");
        }

        Ok(())
    }
}

fn make_welcome_text(user: &str) -> String {
    format!(
        "@{user} Welcome to the group! To share a post, tag the group user \
        or use one of the group hashtags. Use /help for more info.",
        user = user
    )
}


trait VisExt: Copy {
    /// Check if is private or direct
    fn is_private(self) -> bool;
}

impl VisExt for Visibility {
    fn is_private(self) -> bool {
        self == Visibility::Direct || self == Visibility::Private
    }
}