forcebot_rs/src/core/identity.rs

use std::borrow::Borrow;
use std::collections::HashMap;
use std::error::Error;

use crate::core::botmodules::bot_actions::actions_util;
use crate::core::botmodules::{BotActionTrait, BotCommand, BotModule, Listener, ModulesManager};

use crate::core::botinstance::{self, botlog, BotInstance, ChType};
use futures::lock::Mutex;
use twitch_irc::message::{Badge, PrivmsgMessage};

// use crate::core::botmodules::ChType;

use crate::core::botinstance::ArcBox;

use std::cell::RefCell;
use std::rc::Rc;

use std::sync::Arc;
use tokio::sync::RwLock;

use casual_logger::{Level, Log};

use super::botmodules::bot_actions::actions_util::BotAR;

fn adminvector() -> Vec<String> {
    vec![String::from("ModulatingForce")]
    //vec![]
}

// pub fn init(mgr:&mut ModulesManager)
pub async fn init(mgr: Arc<ModulesManager>) {
    // println!("Went into Identiy Module init");
    botinstance::botlog::trace(
        "Went into Identiy Module init",
        Some("identity.rs > init()".to_string()),
        None,
    );

    // let a = actions_util::asyncbox(cmd_promote) ;

    let tempb = BotCommand {
        module: BotModule(String::from("identity")),
        command: String::from("promote"), // command call name
        alias: vec![],                    // String of alternative names
        exec_body: actions_util::asyncbox(cmd_promote),
        help: String::from("promote"),
        required_roles: vec![
            UserRole::Mod(ChType::Channel(String::new())),
            UserRole::SupMod(ChType::Channel(String::new())),
            UserRole::Broadcaster,
            UserRole::BotAdmin,
        ],
    };

    tempb.add_to_modmgr(Arc::clone(&mgr)).await;

    async fn cmd_promote(bot: BotAR, msg: PrivmsgMessage) -> () {
        //println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
        // println!("Called cmd promote");
        botinstance::botlog::trace(
            "Called cmd promote",
            Some("identity.rs > cmd_prommote()".to_string()),
            Some(&msg),
        );

        // -- If the BotCommand.command was called (e.g., promote) & required roles were validated OUTSIDE of this call
        // , this is the current function body to execute

        /*
        - `promote` / `demote`
            - [ ] `SupMod` & `Broadcaster` & `BotAdmin` can run
            - [ ] `UserRole`s that can run, can
                - [ ] run `promote` on a regular `Chatter` to make them a `Mod`
                - [ ] run `demote` on a `Mod` to make them a `Chatter`
            - [ ] Only `BotAdmin` can :
                - [ ] target themselves to `promote` / `demote` , in the case that they want to make themselves either a `Mod` or `SupMod` for the channel temporarily
                - [ ] `promote admin <Chatter>` to assign them `BotAdmin` role
            - `[ ] Broadcaster` & `BotAdmin` can `demote` a `SupMod` to make them a `Mod` or `promote` the other way
         */

        /*
        Usage :

            promote <user>

            demote <user>

            promote -admin <user>

         */

        //  println!("{}",msg.message_text);
        botinstance::botlog::trace(
            &format!("Twich Message > {}", msg.message_text),
            Some("identity.rs > cmd_promote()".to_string()),
            None,
        );

        let sendername = msg.clone().sender.name;

        let mut argv = msg.message_text.split(" ");

        argv.next(); // Skip the command name

        let arg1 = argv.next();

        let arg2 = argv.next();

        let mut sender_badge: Option<ChatBadge> = None;

        for b in &msg.badges {
            if b.name == "moderator" {
                sender_badge = Some(ChatBadge::Mod);
            } else if b.name == "broadcaster" {
                sender_badge = Some(ChatBadge::Broadcaster);
            }
        }

        let targetchnl = msg.channel_login.to_lowercase();

        /*

          [x] 1. Get trgusr (regardless of -admin flag)
          [x] 2. promote trguser
          [x] 3. Output resulting change

        */

        // [x] 1. Get trgusr (regardless of -admin flag)

        let targetusr = if arg1 == Some("-admin") { arg2 } else { arg1 };

        // [x] 2. promote trguser

        // [x] Get a required lock first

        let botlock = bot.read().await;
        let id = botlock.get_identity();
        let idlock = id.read().await;

        let rslt = match targetusr {
            Some(targetusr) => {
                botinstance::botlog::debug(
                    &format!("running promote()"),
                    Some("identity.rs > cmd_promote()".to_string()),
                    None,
                );
                Log::flush();

                let target_bot_admin_role = if arg1 == Some("-admin") {
                    Some(UserRole::BotAdmin)
                } else {
                    None
                };

                idlock
                    .promote(
                        sendername.clone(),
                        &sender_badge,
                        targetusr.to_string(),
                        Some(ChType::Channel(targetchnl.clone())),
                        target_bot_admin_role,
                    )
                    .await
            }

            None => {
                botinstance::botlog::debug(
                    &format!("No Targer User argument"),
                    Some("identity.rs > cmd_demote()".to_string()),
                    None,
                );
                Log::flush();

                ChangeResult::NoChange("No Targer User".to_string())
            }
        };

        // [x] 3. Output resulting change

        match rslt {
            ChangeResult::Success(a) => {
                // println!("Succesfully promoted : {a} ;");
                let outmsg = &format!("o7 Successfully promoted : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_prommote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "o7 Successfully promoted : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
            ChangeResult::Failed(a) => {
                // println!("Failed to promote : {a} ; ");
                let outmsg = &format!("PoroSad failed to promote : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_prommote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "PoroSad failed to promote : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
            ChangeResult::NoChange(a) => {
                // println!("No Changes Made : {a} ; ");
                let outmsg = &format!("uuh No Promotion Change : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_prommote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "uuh No Promotion Change : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
        }

        /*
        match arg1 {
            Some(a1) if a1 == String::from("-admin") => {
               // - [x] BotAdmins can promote admin to give BotAdmin UserRole

               let botlock = bot.read().await;
               let idlock = botlock.get_identity();
               let id = idlock.read().await;
               // let ta = ta.getspecialuserroles(String::from("Hello"), Some(ChType::Channel(msg.channel_login.to_lowercase())));
               // let ta = ta.getspecialuserroles(arg2.unwrap().to_string(), Some(ChType::Channel(msg.channel_login.to_lowercase())));
               let rolesfut = id.getspecialuserroles(
                   msg.sender.name.to_lowercase(),
                   Some(ChType::Channel(msg.channel_login.to_lowercase())));
               let usrroles = rolesfut.await;
               // let ta = ta.unwrap();
               // let a = ta.read().await;
               // let ta = *ta;
               // let ta = *ta;
               // if let Some(a) = *ta {

                   if usrroles.contains(&UserRole::BotAdmin) {
                       // println!("BotAdmin allowed to promote admin");
                       botinstance::botlog::debug("BotAdmin allowed to promote admin",
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));

                       {

                           let idlock = Arc::clone(&bot.read().await.get_identity());
                           // let idlock = idlock.write().await;
                           let idlock = idlock.read().await;
                           // let mut idlock = *idlock;
                           // let ta = idlock.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)).await;
                           let ta = idlock.promote(arg2.unwrap().to_string().to_lowercase(), None, Some(UserRole::BotAdmin)).await;

                           match ta {
                               ChangeResult::Success(a) => {
                                   // println!("Succesfully promoted : {a} ;");
                                   let outmsg = &format!("o7 Successfully promoted : {a}");
                                   botinstance::botlog::debug(outmsg,
                               Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                                   // let outmsg = "o7 Successfully promoted : ".to_string();
                                   botlock.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                               },
                               ChangeResult::Failed(a) => {
                                   // println!("Failed to promote : {a} ; ");
                                   let outmsg = &format!("PoroSad failed to promote : {a}");
                                   botinstance::botlog::debug(outmsg,
                           Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                                   // let outmsg = "PoroSad failed to promote : ".to_string();
                                   botlock.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                               },
                               ChangeResult::NoChange(a) => {
                                   // println!("No Changes Made : {a} ; ");
                                   let outmsg = &format!("uuh No Promotion Change : {a}");
                                   botinstance::botlog::debug(outmsg,
                           Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                                   // let outmsg = "uuh No Promotion Change : ".to_string();
                                   botlock.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                               },

                           }
                       }
                   } // if usrroles.contains(&UserRole::BotAdmin)
               }

           //  },
           Some(arg1) => {
               // In the case of promoting another chatter
               // Check caller's roles
               // Check targer chatter's roles
                   // - Also check if target chatter alread has target roles
               // if caller's role is Broadcaster, SupMod, BotAdmin , they can Promote target Chatters to become Mod (i.e., the target user is not a Mod,SupMod,BotAdmin)
               // if caller is BotAdmin, they can promote BotAdmins to Mod
               // if caller's role is Broadcaster, BotAdmin, they can Promote target Mod to SupMod
               botinstance::botlog::debug(&format!("Evaluating arg1: {arg1}"),
               Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
               Log::flush();

               let idlock = Arc::clone(&bot.read().await.get_identity());
               let idlock = idlock.read().await;
               // let ta = idlock.promote(msg.sender.name.to_lowercase(), None, Some(UserRole::BotAdmin)).await;

               let senderroles = idlock.getspecialuserroles(
                   msg.sender.name.to_lowercase(),
                   Some(ChType::Channel(msg.channel_login.to_lowercase()))).await;

               let trgusrroles = idlock.getspecialuserroles(
                       arg1.to_lowercase(),
                       Some(ChType::Channel(msg.channel_login.to_lowercase()))).await;

                   botinstance::botlog::debug(&format!("Ready to evaluate sender and targer user roles"),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                   Log::flush();

                   botinstance::botlog::trace(&format!("Related Vars : sender roles : {:?} ; targer usr roles : {:?}" ,
                                               senderroles,trgusrroles),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                   Log::flush();

               if ( senderroles.contains(&UserRole::Broadcaster) ||
                   senderroles.contains(&UserRole::SupMod(ChType::Channel(msg.channel_login.to_lowercase()))) ||
                   senderroles.contains(&UserRole::BotAdmin) ) &&
                   ( !trgusrroles.contains(&UserRole::Broadcaster) &&
                       // !trgusrroles.contains(&UserRole::BotAdmin) && // target users that are BotAdmins can promote themselves to Mod or SupMod
                       !trgusrroles.contains(&UserRole::SupMod(ChType::Channel(msg.channel_login.to_lowercase()))) &&
                       !trgusrroles.contains(&UserRole::Mod(ChType::Channel(msg.channel_login.to_lowercase())))
                   )
               {
                   // if caller's role is Broadcaster, SupMod, BotAdmin , they can Promote target Chatters to become Mod (i.e., the target user is not a Mod,SupMod,BotAdmin)
                   botinstance::botlog::trace(&format!("Attempting promote..."),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                   Log::flush();
                   let ta = idlock.promote(arg1.to_string().to_lowercase(),
                    Some(ChType::Channel(msg.channel_login.to_lowercase())),
                     Some(UserRole::Mod(ChType::Channel(msg.channel_login.to_lowercase())))).await;

                   match ta {
                       ChangeResult::Success(a) => {
                           // println!("Succesfully promoted : {a} ;");
                           let outmsg = &format!("Successful Promotion : {a}");
                           botinstance::botlog::debug(&format!("Successful Promotion : {a}"),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                       Log::flush();
                           // let outmsg = "o7 Successfully promoted : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::Failed(a) => {
                           // println!("Failed to promote : {a} ; ");
                           let outmsg = &format!("PoroSad failed to promote : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           // Log::flush();
                           // let outmsg = "PoroSad failed to promote : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::NoChange(a) => {
                           // println!("No Changes Made : {a} ; ");
                           let outmsg = &format!("uuh Not making any changes : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           Log::flush();
                           // let outmsg = "uuh No Promotion Change : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },

                   }

               } else if trgusrroles.contains(&UserRole::Mod(ChType::Channel(msg.channel_login.to_lowercase()))) &&
               ( senderroles.contains(&UserRole::Broadcaster) ||
                   senderroles.contains(&UserRole::BotAdmin) )
               {
                   botinstance::botlog::trace(&format!("Attempting promote..."),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                   Log::flush();

                   // broadcaster & botadmins can make mods into SupMod
                   let ta = idlock.promote(arg1.to_string().to_lowercase(),
                    Some(ChType::Channel(msg.channel_login.to_lowercase())),
                    Some(UserRole::SupMod(ChType::Channel(msg.channel_login.to_lowercase())))).await;

                   match ta {
                       ChangeResult::Success(a) => {
                           // println!("Succesfully promoted : {a} ;");
                           let outmsg = &format!("Successful Promotion : {a}");
                           botinstance::botlog::debug(&format!("Successful Promotion : {a}"),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                       Log::flush();
                           // let outmsg = "o7 Successfully promoted : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::Failed(a) => {
                           // println!("Failed to promote : {a} ; ");
                           let outmsg = &format!("PoroSad failed to promote : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           // Log::flush();
                           // let outmsg = "PoroSad failed to promote : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::NoChange(a) => {
                           // println!("No Changes Made : {a} ; ");
                           let outmsg = &format!("uuh No Change in Promotion : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           Log::flush();
                           // let outmsg = "uuh No Promotion Change : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },

                   }

               } else if trgusrroles.contains(&UserRole::Broadcaster) // This should always be NoChange
               {
                   botinstance::botlog::trace(&format!("Attempting promote..."),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                   Log::flush();

                   // broadcaster & botadmins can make mods into superadmins
                   let ta = idlock.promote(arg1.to_string().to_lowercase(),
                    Some(ChType::Channel(msg.channel_login.to_lowercase())),
                    Some(UserRole::Mod(ChType::Channel(msg.channel_login.to_lowercase())))).await;

                   match ta {
                       ChangeResult::Success(a) => {
                           // println!("Succesfully promoted : {a} ;");
                           let outmsg = &format!("Successful Promotion : {a}");
                           botinstance::botlog::debug(&format!("Successful Promotion : {a}"),
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                       Log::flush();
                           // let outmsg = "o7 Successfully promoted : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::Failed(a) => {
                           // println!("Failed to promote : {a} ; ");
                           let outmsg = &format!("PoroSad failed to promote : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           // Log::flush();
                           // let outmsg = "PoroSad failed to promote : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },
                       ChangeResult::NoChange(a) => {
                           // println!("No Changes Made : {a} ; ");
                           let outmsg = &format!("uuh No Change in Promotion : {a}");
                           botinstance::botlog::debug(outmsg,
                   Some("identity.rs > cmd_prommote()".to_string()), Some(&msg));
                           Log::flush();
                           // let outmsg = "uuh No Promotion Change : ".to_string();
                           bot.read().await.botmgrs.chat.say_in_reply_to(&msg, outmsg.to_string()).await;
                       },

                   }
               }

               else {
                   let s = botlog::fatal("Reached unreachable else",
                   Some("identity > cmd_promote()".to_string()), Some(&msg));
                   panic!("{}",s);
               };

               Log::flush();

           }
            _ => (),
        }



        let arg2 = argv.next();

        let targetchnl = arg2;

        */

        botinstance::botlog::trace(
            &format!("End of cmd_promote()"),
            Some("identity.rs > cmd_prommote()".to_string()),
            None,
        );
    }

    // BotCommand {
    //     module : BotModule(String::from("identity")),
    //     command : String::from("demote"), // command call name
    //     alias : vec![], // String of alternative names
    //     exec_body : actions_util::asyncbox(cmd_demote) ,
    //     help : String::from("demote"),
    //     required_roles : vec![
    //         UserRole::Mod(ChType::Channel(String::new())),
    //         UserRole::SupMod(ChType::Channel(String::new())),
    //         UserRole::Broadcaster,
    //         UserRole::BotAdmin,
    //         ],
    // }.add_to_modmgr(Arc::clone(&mgr));

    let tempb = BotCommand {
        module: BotModule(String::from("identity")),
        command: String::from("demote"), // command call name
        alias: vec![],                   // String of alternative names
        exec_body: actions_util::asyncbox(cmd_demote),
        help: String::from("demote"),
        required_roles: vec![
            UserRole::Mod(ChType::Channel(String::new())),
            UserRole::SupMod(ChType::Channel(String::new())),
            UserRole::Broadcaster,
            UserRole::BotAdmin,
        ],
    };

    tempb.add_to_modmgr(Arc::clone(&mgr)).await;

    // async fn cmd_demote(mut _chat:Arc<Mutex<BotInstance>>,_msg:PrivmsgMessage) {
    async fn cmd_demote(mut bot: BotAR, msg: PrivmsgMessage) {
        // println!("Called cmd demote");
        botinstance::botlog::debug(
            "Called cmd demote",
            Some("identity.rs > cmd_demote()".to_string()),
            Some(&msg),
        );
        Log::flush();

        // -- If the BotCommand.command was called (e.g., demote) & required roles were validated OUTSIDE of this call
        // , this is the current function body to execute

        /*
        - `promote` / `demote`
            - [ ] `SupMod` & `Broadcaster` & `BotAdmin` can run
            - [ ] `UserRole`s that can run, can
                - [ ] run `promote` on a regular `Chatter` to make them a `Mod`
                - [ ] run `demote` on a `Mod` to make them a `Chatter`
            - [ ] Only `BotAdmin` can :
                - [ ] target themselves to `promote` / `demote` , in the case that they want to make themselves either a `Mod` or `SupMod` for the channel temporarily
                - [ ] `promote admin <Chatter>` to assign them `BotAdmin` role
            - `[ ] Broadcaster` & `BotAdmin` can `demote` a `SupMod` to make them a `Mod` or `promote` the other way
         */

        /*
        Usage :

            promote <user>

            demote <user>

            promote -admin <user>

         */

        // [ ] #TODO : Need to define the body that calls demote()

        // [x] Unwraps arguments from message

        // let mut argv = msg.message_text.split(" ");

        // argv.next(); // Skip the command name

        // let arg1 = argv.next();

        // let arg2 = argv.next();

        let (arg1, arg2) = {
            let mut argv = msg.message_text.split(" ");

            argv.next(); // Skip the command name

            let arg1 = argv.next();

            let arg2 = argv.next();

            (arg1, arg2)
        };

        /*
        let mut sender_badge:Option<ChatBadge> = None;

        for b in &msg.badges {
            if b.name == "moderator" {
                sender_badge = Some(ChatBadge::Mod);
            } else if b.name == "broadcaster" {
                sender_badge = Some(ChatBadge::Broadcaster);
            }
        }
        */

        // ---

        /*
           => 2024.02.15 - The business logic seems embeded straight into demote() with the following in mind :
               - demote() atm doesn't take sender ChatBadge <-- the assumption is canuserrun() was done
                   for this user, and automatically assigned any roles that should get auto assigned
               - demote() returns a ChangeResult

               - [ ] So I think all I need to do here is parse out and pass input args to demote(), and output quirky messages based on ChangeResult

               -   [x] 1. Parse out the following
                       - Sender (e.g., Name & Badge)
                       - Target User (arg1)
                       - Target Channel (current channel)
                       - Msg or Msg.Message_Text (for later)

               - [x] 2. Run Demote()
                   - within demote(), getspecialuserroles() is called on both the sender and the target
                       - getspecialuserroles() only sends current db , while canuserrun() may change db depending on the most current state of the sender
                       - getspecialuserroles also borrows the sender's badge to evaluate

               - [ ] 3. Take ChangeResult and output response


        */

        /*


        -   [x] 1. Parse out the following
                - Sender (e.g., Name & Badge)
                - Target User (arg1)
                - Target Channel (current channel)
                - (no need) Msg or Msg.Message_Text (for later)

         */

        let sendername = msg.clone().sender.name;

        let mut sender_badge_mut: Option<ChatBadge> = None;

        for b in &msg.badges {
            if b.name == "moderator" {
                sender_badge_mut = Some(ChatBadge::Mod);
            } else if b.name == "broadcaster" {
                sender_badge_mut = Some(ChatBadge::Broadcaster);
            }
        }

        let sender_badge = sender_badge_mut;

        let targetusr = arg1;

        let targetchnl = msg.channel_login.to_lowercase();

        /*

        - [x] 2. Run Demote()
            - within demote(), getspecialuserroles() is called on both the sender and the target
                - getspecialuserroles() only sends current db , while canuserrun() may change db depending on the most current state of the sender
                - getspecialuserroles also borrows the sender's badge to evaluate


         */

        // [x] Get a required lock first

        let botlock = bot.read().await;
        let id = botlock.get_identity();
        let idlock = id.read().await;

        let rslt = match targetusr {
            Some(targetusr) => {
                botinstance::botlog::debug(
                    &format!("running demote()"),
                    Some("identity.rs > cmd_demote()".to_string()),
                    None,
                );
                Log::flush();

                idlock
                    .demote(
                        sendername.clone(),
                        &sender_badge,
                        targetusr.to_string(),
                        Some(ChType::Channel(targetchnl.clone())),
                    )
                    .await
            }

            None => {
                botinstance::botlog::debug(
                    &format!("No Targer User argument"),
                    Some("identity.rs > cmd_demote()".to_string()),
                    None,
                );
                Log::flush();

                ChangeResult::NoChange("No Targer User".to_string())
            }
        };

        /*

        - [x] 3. Take ChangeResult and output response

         */

        // let senderUserRole = {

        //     // note : getspecialuserroles will cover :
        //     //      - Internal roles stored at db for Mod & SupMod & BotAdmin
        //     //      - Broadcaster (based on target hchatter & channel)
        //     //  It MAY NOT COVER sutations where Sender has a Mod Badge, but not in DB yet as Mod
        //     //   - So ideally this covers that (at least returns that they're a mod and go ahead and run for now)
        //     //     - [ ] #TODO : This should also go ahead and add that mod to DB if possible as channel mod

        //     // let evalroles = vec![];

        //     let evalroles = match sender_badge {

        //         Some(ChatBadge::Mod) => {

        //             let mut rslroles = idlock.getspecialuserroles(
        //                 sendername.clone(),
        //                 Some(ChType::Channel(targetchnl.clone()))).await;

        //             rslroles.push(UserRole::Mod(ChType::Channel(targetchnl)));

        //             rslroles
        //         },
        //         _ => {
        //             idlock.getspecialuserroles(
        //                 sendername,
        //                 Some(ChType::Channel(targetchnl.clone()))).await
        //         }
        //     };

        //     // => 02.16 - I think better would just migrate over the logic within demote
        //     //          - If there's business reqs to evaluate , better to keep the ChangeResult
        //     //           consistent and also pass ChatBadge

        // }; // senderUserRole

        match rslt {
            ChangeResult::Success(a) => {
                // println!("Succesfully promoted : {a} ;");
                let outmsg = &format!("o7 Successfully demoted : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_demote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "o7 Successfully promoted : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
            ChangeResult::Failed(a) => {
                // println!("Failed to promote : {a} ; ");
                let outmsg = &format!("PoroSad failed to demote : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_demote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "PoroSad failed to promote : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
            ChangeResult::NoChange(a) => {
                // println!("No Changes Made : {a} ; ");
                let outmsg = &format!("uuh No Demotion Change : {a}");
                botinstance::botlog::debug(
                    outmsg,
                    Some("identity.rs > cmd_demote()".to_string()),
                    Some(&msg),
                );
                // let outmsg = "uuh No Promotion Change : ".to_string();
                botlock
                    .botmgrs
                    .chat
                    .say_in_reply_to(&msg, outmsg.to_string())
                    .await;
            }
        }

        // println!("tester");
        // println!("tester2");
    }

    let tempcomm = BotCommand {
        module: BotModule(String::from("identity")),
        command: String::from("getroles"), // command call name
        alias: vec![],                     // String of alternative names
        exec_body: actions_util::asyncbox(getroles),
        help: String::from("getroles"),
        required_roles: vec![
            UserRole::Mod(ChType::Channel(String::new())),
            UserRole::SupMod(ChType::Channel(String::new())),
            UserRole::Broadcaster,
            UserRole::BotAdmin,
        ],
    };

    tempcomm.add_to_modmgr(Arc::clone(&mgr)).await;

    // async fn getroles(bot:Arc<Mutex<BotInstance>>,msg:PrivmsgMessage) {
    async fn getroles(bot: BotAR, msg: PrivmsgMessage) {
        // println!("Called cmd getroles");
        botinstance::botlog::debug(
            "Called cmd getroles",
            Some("identity.rs > cmd_getroles()".to_string()),
            Some(&msg),
        );

        /*
        Usage

        getroles <user> <Channel>
        - If channel is provided, provide roles for that channel specifically

         */

        // IN other code areas , I see this
        // ServerMessage::Privmsg(msg) => {
        //     println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);

        // println!("{}",msg.message_text);
        let mut argv = msg.message_text.split(" ");

        // for v in argv {
        //     println!("args : {v}");
        // }

        argv.next(); // Skip the command name

        let arg1 = argv.next();

        // if arg == None {
        //     return ; // Do nothing if no arguments
        // }

        let targetuser = match arg1 {
            None => return, // exit if no arguments
            Some(arg) => arg,
        };

        // match String::from(arg1) {
        //     a if a == String::from("admin") => (),
        //     _ => (),
        // }

        // match argv[1] {
        //     String::from("admin") => (),

        // }

        let arg2 = argv.next();

        let targetchnl = arg2;

        // // let a = bot.read().ok().unwrap().get_identity();
        // let a = bot.lock().await;
        // // let a = a.lock().await;
        // // let a = a.get_identity().await;
        // let a = a.botmgrs;
        // // let a = *(*a).lock().await;
        // let a = *a.lock().await;
        // let a = a.identity;
        // let a = *a.lock().await;

        // let a = bot.clone();
        // let a = a.into_inner();
        // let a = a.botmgrs;
        // let a = a.into_inner();
        // let a = a.identity;
        // let a = a.into_inner();
        // let a = bot.clone();
        // let a = a.lock().await;
        // let a = a.get_identity();
        // let a = a.lock().await;
        // let a = bot.get_identity();
        let botlock = bot.read().await;
        // println!("botlock read");
        botinstance::botlog::trace(
            "botlock read",
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );
        let idlock = botlock.get_identity();
        // println!("got identity");
        botinstance::botlog::trace(
            "got identity",
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );
        let idlock = idlock.read().await; // <-- 02.12 - Latest where it gest stuck - before or at this point
                                          // println!("id lock");
        botinstance::botlog::trace(
            "id lock",
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );
        let sproles = match targetchnl {
            None => {
                // let bot = Rc::clone(&bot);
                //let bot = Arc::clone(&bot);
                // let a = bot.botmgrs.identity.getspecialuserroles(String::from(targetuser),None);
                // let a = Arc::try_unwrap(bot).ok().unwrap().into_inner().ok().unwrap();
                // let a = Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner();
                // let a = a.botmgrs.identity.getspecialuserroles(String::from(targetuser),None);
                // let a = a.ok().getspecialuserroles(String::from(targetuser),None);
                // let a = bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None);
                // println!("Retrieved User Roles >> {:?}",a);
                // let a = idlock.read().await;
                // idlock.getspecialuserroles(String::from(targetuser),None).await

                // [ ] If targetchnl is not provided, default to pulling the current channel
                idlock
                    .getspecialuserroles(
                        String::from(targetuser),
                        Some(ChType::Channel(msg.channel_login.to_lowercase())),
                    )
                    .await
            }
            Some(targetchnl) => {
                // let bot = Rc::clone(&bot);
                // let bot = Arc::clone(&bot);
                // let a = bot.botmgrs.identity.getspecialuserroles(String::from(targetuser), Some(ChType::Channel(String::from(targetchnl))));
                // Arc::try_unwrap(boxed_bot.clone()).ok().unwrap().into_inner()
                // let a = Arc::try_unwrap(bot).ok().unwrap().into_inner().ok().unwrap();
                // let a = Arc::try_unwrap(bot.clone()).ok().unwrap().into_inner();
                // let a = a.botmgrs.identity.getspecialuserroles(String::from(targetuser), Some(ChType::Channel(String::from(targetchnl))));
                // let a = bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None);
                // println!("Retrieved User Roles >> {:?}",a);
                // bot.read().ok().unwrap().rIdentity().getspecialuserroles(String::from(targetuser),None)
                // let a = a.read().await;

                // [ ] If caller is not a BotAdmin, they can only pull those related to the current channel for the target user
                // [ ] If caller is a BotAdmin, allow & return for target channel
                // let mut sender_badge:Option<ChatBadge> = None;

                // for b in &msg.badges {
                //     if b.name == "moderator" {
                //         sender_badge = Some(ChatBadge::Mod);
                //     } else if b.name == "broadcaster" {
                //         sender_badge = Some(ChatBadge::Broadcaster);
                //     }
                // }

                // match sender_badge {
                //     Some(ChatBadge::Mod) => {

                //     } ,
                //     Some(ChatBadge::Broadcaster) => {

                //     }
                //     _ => {

                //     }
                // }

                // [x]gets special roles for caller
                let callersproles = idlock
                    .getspecialuserroles(
                        msg.sender.name.to_lowercase(),
                        Some(ChType::Channel(targetchnl.to_lowercase().to_string())),
                    )
                    .await;
                // idlock.getspecialuserroles(String::from(targetuser),Some(ChType::Channel(targetchnl.to_lowercase().to_string()))).await
                // let a = callersproles.contains(&UserRole::Mod(ChType::Channel(targetchnl.to_lowercase().to_string())));
                if callersproles.contains(&UserRole::Mod(ChType::Channel(
                    targetchnl.to_lowercase().to_string(),
                ))) || callersproles.contains(&UserRole::SupMod(ChType::Channel(
                    targetchnl.to_lowercase().to_string(),
                ))) || callersproles.contains(&&UserRole::Broadcaster)
                {
                    idlock
                        .getspecialuserroles(
                            String::from(targetuser),
                            Some(ChType::Channel(targetchnl.to_lowercase())),
                        )
                        .await
                    // callersproles
                } else {
                    // Otherwise, don't get the target channel, return the current channel instead
                    idlock
                        .getspecialuserroles(
                            String::from(targetuser),
                            Some(ChType::Channel(msg.channel_login.to_lowercase())),
                        )
                        .await
                }
            }
        };

        // let sproles = idlock.getspecialuserroles(String::from(targetuser),).await;

        // println!("Retrieved User Roles >> {:?}",sproles);
        botinstance::botlog::debug(
            &format!("User roles of Target Chatter >> {:?}", sproles),
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );

        // # I believe at this stage I still have botlock active

        botinstance::botlog::debug(
            &format!("Evaluating special roles"),
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );

        // let mut outmsg = String::new();

        //let sproles = sproles;
        // let arg2 = arg2.unwrap();

        let outmsg = if ((targetuser.to_lowercase() == msg.channel_login.to_lowercase())
            && arg2.is_none())
            || (arg2.is_some() && arg2.unwrap() == targetuser.to_lowercase())
        {
            // First evaluates if they're broadcaster
            let mut outmsg = format!("FeelsWowMan they're the broadcaster. ");
            if sproles.contains(&UserRole::Mod(ChType::Channel(
                msg.channel_login.to_lowercase(),
            ))) || sproles.contains(&UserRole::SupMod(ChType::Channel(
                msg.channel_login.to_lowercase(),
            ))) || sproles.contains(&UserRole::BotAdmin)
            {
                outmsg = outmsg + &format!("Target chatter's user roles are : {:?}", sproles);
            }
            outmsg
        } else if sproles.contains(&UserRole::Mod(ChType::Channel(
            msg.channel_login.to_lowercase(),
        ))) || sproles.contains(&UserRole::SupMod(ChType::Channel(
            msg.channel_login.to_lowercase(),
        ))) || sproles.contains(&UserRole::BotAdmin)
        {
            format!("Target chatter's user roles are : {:?}", sproles)
        } else {
            format!("Target chatter has no special roles LULE ")
        };

        // if sproles.contains(&UserRole::Mod(msg.channel_login.to_lowercase())) {

        // } else if sproles.contains(&UserRole::Mod(msg.channel_login.to_lowercase())) {

        // }

        // let outmsg = match sproles
        // {

        //     // let mut outmsg = String::new();
        //     Some(sproles) => {

        //         let sproles = sproles.read().await;

        //         format!("Target chatter's user roles are : {:?}",sproles)

        //     }
        //     None => {
        //         // # NOTE : Broadcaster could be included in this

        //         // # below is checking if the provided text includes the username
        //         // let msg = msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase());
        //         botinstance::botlog::debug(&format!("Evaluating special roles > channel login : {} ; message text : {} ; ",&msg.channel_login,&msg.message_text),
        //         Some("identity.rs > init > getroles()".to_string()), Some(&msg));
        //         botinstance::botlog::debug(&format!("Evaluating special roles > bool evaluation : {} ",
        //                                                     msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase())),
        //         Some("identity.rs > init > getroles()".to_string()), Some(&msg));

        //         if msg.message_text.to_lowercase().contains(&msg.channel_login.to_lowercase()) {
        //             format!("FeelsWowMan they're the broadcaster ")
        //         } else {
        //             format!("Target chatter has no special roles LULE ")
        //         }

        //     }

        // };
        // let a = bot.identity.getuserroles(String::from("ModulatingForce"), Some(ChType::Channel(String::from("ModulatingForcebot"))));
        // println!("{:?}",a);

        botinstance::botlog::debug(
            &format!("Chat Say Reply message : {:?}", outmsg),
            Some("identity.rs > init > getroles()".to_string()),
            Some(&msg),
        );
        botlock.botmgrs.chat.say_in_reply_to(&msg, outmsg).await;

        // [ ] NOTE : After the above, I should receive only the roles in the context of the current channel I received this ideally and maybe BotAdmin ; not outside
    }

    // println!("End of Init MOdule add");
    botinstance::botlog::trace(
        "End of Init MOdule add",
        Some("identity.rs > init ".to_string()),
        None,
    );

    Log::flush();
}

// #[derive(Debug, PartialEq, Eq, Hash, Clone)]
// pub enum ChType {
//     Channel(String),
// }

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum UserRole {
    Chatter,
    Mod(ChType),    // String specifies Channel
    SupMod(ChType), // String specifies Channel
    Broadcaster,
    BotAdmin,
}

pub enum Permissible {
    Allow,
    Block,
}

#[derive(Clone)]
pub struct IdentityManager {
    // special_roles_users : HashMap<String,Vec<UserRole>>, // # <-- (!) This must be String instead of ChType because we're checking a User not a Channel
    // special_roles_users : Arc<Mutex<HashMap<String,Vec<UserRole>>>>, // # <-- (!) This must be String instead of ChType because we're checking a User not a Channel
    // special_roles_users : Arc<RwLock<HashMap<String,Vec<UserRole>>>>,
    special_roles_users: Arc<RwLock<HashMap<String, Arc<RwLock<Vec<UserRole>>>>>>,
    // parent_mgr : Box<crate::core::botinstance::BotManagers>,
    //parent_mgr : Option<Box<crate::core::botinstance::BotManagers>>,
}
/*
    HashMap<
            String, <-- Chatter / Username
         Vec<UserRole> -- <-- Vectors are basically arrays
        >

    -- [ ]
        let a = vec![]

        modulatingforce : vec![UserRole::BotAdmin,
                            UserRole::Mod(ChType::Channel("modulatingforcebot"))]
        modulatingforce : vec![UserRole::BotAdmin,
                            UserRole::Mod(ChType::Channel("modulatingforcebot"))]

*/

#[derive(Debug)]
pub enum ChatBadge {
    Broadcaster,
    Mod,
}

#[derive(Debug, PartialEq, Eq)]
pub enum ChangeResult {
    Success(String),
    Failed(String),
    NoChange(String),
}

impl IdentityManager {
    pub fn init() -> IdentityManager {
        let mut a = HashMap::new();
        for admn in adminvector() {
            a.insert(
                admn.to_lowercase(),
                Arc::new(RwLock::new(vec![UserRole::BotAdmin])),
            );
        }

        IdentityManager {
            special_roles_users: Arc::new(RwLock::new(a)),
            //parent_mgr : None,
        }
    }

    async fn add_role(&self, trgchatter: String, trg_role: UserRole) {
        let mut srulock = self.special_roles_users.write().await;
        let mut usrrolelock = srulock
            .get_mut(&trgchatter)
            .expect("Error retrieving roles")
            .write()
            .await;
        usrrolelock.push(trg_role);
    }

    async fn remove_role(&self, trgchatter: String, trg_role: UserRole) {
        let mut srulock = self.special_roles_users.write().await;
        let mut usrrolelock = srulock
            .get_mut(&trgchatter)
            .expect("Error retrieving roles")
            .write()
            .await;
        if let Some(indx) = usrrolelock.iter().position(|value| *value == trg_role) {
            usrrolelock.swap_remove(indx);
            //return ChangeResult::Success("Demoted successfully".to_string())
        }
    }

    async fn affirm_chatter_in_db(&self, trgchatter: String) {
        let mut srulock = self.special_roles_users.write().await;
        srulock
            .entry(trgchatter.clone())
            .or_insert(Arc::new(RwLock::new(vec![])));
        botinstance::botlog::trace(
            &format!(
                "Ensuring User in Roles {:?}",
                srulock.entry(trgchatter.clone())
            ),
            Some("IdentityManager > affirm_chatter_in_db()".to_string()),
            None,
        );
        Log::flush();
    }

    // [ ] Maybe I should create a can_user_run version that simply takes PrvMsg, but then calls can_user_run directly

    // pub fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Result<Permissible,Box<dyn Error>>
    // pub fn can_user_run_PRVMSG(&self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
    // pub async fn can_user_run_PRVMSG(self,msg:&PrivmsgMessage,cmdreqroles:Vec<UserRole>) -> Permissible
    pub async fn can_user_run_PRVMSG(
        &mut self,
        msg: &PrivmsgMessage,
        cmdreqroles: Vec<UserRole>,
    ) -> (Permissible, ChangeResult) {
        // println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);

        // [ ] Check what Badges in PrivmsgMessage
        // println!{"Checking within PRVMSG"};
        botinstance::botlog::debug(
            "Checking within PRVMSG",
            Some("identity.rs > can_user_run_PRVMSG()".to_string()),
            Some(&msg),
        );

        let mut sender_badge: Option<ChatBadge> = None;

        for b in &msg.badges {
            if b.name == "moderator" {
                sender_badge = Some(ChatBadge::Mod);
            } else if b.name == "broadcaster" {
                sender_badge = Some(ChatBadge::Broadcaster);
            }
        }

        // if &msg.badges.contains(Badge{}) {

        // }

        // if let Some(sender_badge) = sender_badge {
        // match sender_badge {
        //     Some(sender_badge) => {
        // return &self.can_user_run(msg.sender.name.to_owned(),
        //     ChType::Channel(msg.channel_login.to_owned()),
        //     sender_badge,
        //     cmdreqroles
        // return self.can_user_run(msg.sender.name.to_owned(),
        // let a = Arc::new(Mutex::new(self));
        // let mut a = a.lock().await;
        // let a = **a;
        // let a = a.can_user_run(msg.sender.name.to_owned(),
        // ChType::Channel(msg.channel_login.to_owned()),
        // sender_badge,
        // cmdreqroles
        //  ) ;
        // let a = *self;
        // let a = Arc::new(Mutex::new(a));
        // let a = a.lock().await.can_user_run(msg.sender.name.to_owned(),
        //                         ChType::Channel(msg.channel_login.to_owned()),
        //                         sender_badge,
        //                                     cmdreqroles
        //                                     ) ;
        // return a;
        // return self.can_user_run(msg.sender.name.to_owned(),
        //                         ChType::Channel(msg.channel_login.to_owned()),
        //                         sender_badge,
        //                                     cmdreqroles
        //                                     ).await

        // * NOTE : We're preferring to pass the ChangeResult up , where we have access to Chat via BotInstance
        //   that have more strained chatting rules
        //     let evalpermissible = self.can_user_run(msg.sender.name.to_owned(),
        //                             ChType::Channel(msg.channel_login.to_owned()),
        //                             sender_badge,
        //                                         cmdreqroles
        //                                         ).await ;
        //                                         evalpermissible
        // // }
        // None => {

        // }
        // here , sender_badge is likely None
        // This could be a regular chatter, BotAdmin,SupserMod

        // [ ] Call can_user_run()
        // (self,Permissible::Block)
        // (Permissible::Block,ChangeResult::NoChange("".to_string()))

        self.can_user_run(
            msg.sender.name.to_owned(),
            ChType::Channel(msg.channel_login.to_owned()),
            sender_badge,
            cmdreqroles,
        )
        .await
    }

    pub async fn can_user_run(
        &mut self,
        usr: String,
        channelname: ChType,
        chat_badge: Option<ChatBadge>,
        cmdreqroles: Vec<UserRole>, // ) -> Result<Permissible,Box<dyn Error>> {
    ) -> (Permissible, ChangeResult) {
        // println!{"Checking within can_user_run()"};
        botinstance::botlog::debug(
            &format!(
                "Checking within can_user_run() : 
                            usr : {} ; channel : {:?} ; badge : {:?} ; cmdreqroles : {:?}",
                usr, channelname, chat_badge, cmdreqroles
            ),
            Some("identity.rs > can_user_run()".to_string()),
            None,
        );
        /*
        canUserRun -

        Input :
            usr:String,
            channelname:ChType,
            chat_badge:ChatBadge,
            cmdreqroles:Vec<UserRole>

        Output : Result<Permissible,Box<dyn Error>>
            Some Possible outcomes : Ok(Permissible::Allow) , Ok(Permissible::Block)


        Description
            For a Given Chatter (with any special ChatBadge) who ran the Command at a Given Channel , check if that user can
            run the command based on the given cmdreqroles required by the command

            Inputs and business logic determine if the user can run the command based on the command's required roles
         */

        // Requirements
        /*
           [x] If cmdreqroles is empty vector , automatically assume Ok(Permissible::Allow)
           [x] If chatBadge::Broadcaster  ...
               [x] and cmdreqroles includes UserRole::Broadcaster , Ok(Permissible::Allow)
               [x] and cmdreqroles includes UserRole::Mod("") OR UserRole::SupMod("")  , Ok(Permissible::Allow)
           [x] If chatBadge::Mod ...
               [x] Check if they have either UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType)
                   [x] If not, assign them UserRole::Mod(channelname::ChType)
           [x] If cmdreqroles includes UserRole::Mod("") , checks if chatter has UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
           [x] If cmdreqroles includes UserRole::SupMod("") , checks if chatter has UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)
           [x] If cmdreqroles includes UserRole::BotAdmin and chatter has UserRole::BotAdmin , Ok(Permissible::Allow)
           [x] Otherwise, Ok(Permissible::Block)
        */

        // [x] If cmdreqroles is empty vector , automatically assume Ok(Permissible::Allow)

        // let idar = Arc::new(RwLock::new(self));

        let usr = usr.to_lowercase();

        if cmdreqroles.len() == 0 {
            // return Ok(Permissible::Allow)
            return (
                Permissible::Allow,
                ChangeResult::NoChange("Command has no required cmdreqroles".to_string()),
            );
        }

        let mut modrolechange = ChangeResult::NoChange("".to_string());

        match chat_badge {
            // [x] If chatBadge::Broadcaster  ...
            // [x] and cmdreqroles includes UserRole::Broadcaster , Ok(Permissible::Allow)
            // [x] and cmdreqroles includes UserRole::Mod("") OR UserRole::SupMod("")  , Ok(Permissible::Allow)
            Some(ChatBadge::Broadcaster) => {
                if cmdreqroles.contains(&UserRole::Broadcaster)
                    || cmdreqroles.contains(&UserRole::Mod(ChType::Channel(String::new())))
                    || cmdreqroles.contains(&UserRole::SupMod(ChType::Channel(String::new())))
                {
                    // return Ok(Permissible::Allow)
                    return (
                        Permissible::Allow,
                        ChangeResult::NoChange("Broadcaster Role".to_string()),
                    );
                }
            }

            // [x] If chatBadge::Mod ...
            //     [x] Check if they have either UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType)
            //         [x] If not, assign them UserRole::Mod(channelname::ChType)
            Some(ChatBadge::Mod) => {
                // println!("Mod Chatbadge detected");
                botinstance::botlog::info(
                    "Mod Chatbadge detected",
                    Some("identity.rs > can_user_run()".to_string()),
                    None,
                );

                // println!("debug special roles : {:?}",self.special_roles_users);
                // println!("debug usr : {}",&usr.to_lowercase());

                // let Some((k,v)) = self.special_roles_users.get_key_value(usr);
                // match self.special_roles_users.get_mut(&usr.to_lowercase()) {
                // match self.special_roles_users.get(&usr.to_lowercase()) {
                // println!("Creating clone");
                botinstance::botlog::trace(
                    "Creating arc clone",
                    Some("identity.rs > can_user_run()".to_string()),
                    None,
                );

                let roleslock = Arc::clone(&(*self).special_roles_users);

                // println!("Read lock on : Special_Roles_User"); // <-- after this is slightly different between working and problem
                botinstance::botlog::trace(
                    "Read lock on : Special_Roles_User",
                    Some("identity.rs > can_user_run()".to_string()),
                    None,
                );

                // {

                //     // If target user doesn't exist in special_roles_users , add with blank vector roles
                //     let mut srulock = self.special_roles_users.write().await;
                //     srulock.entry(usr.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                //     botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(usr.clone())),
                //     Some("identity.rs > promote()".to_string()), None);
                //     Log::flush();
                // }
                self.affirm_chatter_in_db(usr.clone()).await;

                let mut roleslock = roleslock.write().await;
                match (*roleslock).get(&usr.to_lowercase()) {
                    Some(usrroles)
                        if usrroles
                            .read()
                            .await
                            .contains(&UserRole::Mod(channelname.clone()))
                            || usrroles
                                .read()
                                .await
                                .contains(&UserRole::SupMod(channelname.clone())) =>
                    {
                        // <-- working got to this point
                        // println!("contains mod : {}", usrroles.read().await.contains(&UserRole::Mod(channelname.clone())));
                        // println!("contains supmod : {}", usrroles.read().await.contains(&UserRole::SupMod(channelname.clone())));

                        // Do nothing when theh have a mod badge and have either a supmod or mod badge for the channel
                        // println!("Already a mod in roles");
                        botinstance::botlog::trace(
                            "Already a mod in roles",
                            Some("identity.rs > can_user_run()".to_string()),
                            None,
                        );
                    }
                    _ => {
                        // In the event they have a mod badge , are running a bot command, but don't have a channel mod role yet...
                        // println!("lock created > adding with a mod role o7");
                        botinstance::botlog::trace(
                            "lock created > adding with a mod role o7",
                            Some("identity.rs > can_user_run()".to_string()),
                            None,
                        );

                        // botinstance::botlog::notice("Assigning ModRole to Chatter",
                        //     Some("identity.rs > can_user_run()".to_string()), None);

                        let mut roleslock = roleslock;
                        let mut a = roleslock.get_mut(&usr.to_lowercase()).unwrap();
                        let mut alock = a.write().await;

                        alock.push(UserRole::Mod(channelname.clone()));

                        modrolechange = ChangeResult::Success("Auto Promoted Mod".to_string());

                        // alock.get_mut(&usr.to_lowercase())
                        // .get_or_insert_with(|| UserRole::Mod(channelname.clone()))
                        // // .expect("ERROR")
                        // .unwrap()
                        // .write().await
                        // // .get_mut()
                        // .push(UserRole::Mod(channelname.clone()));
                    } // <-- I'm assuming problem got to here
                }
            }
            _ => (), // Don't handle other roles here
        }

        // [x] If cmdreqroles includes UserRole::Mod("") , checks if chatter has UserRole::Mod(channelname::ChType) or UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)

        // println!("cmd required roles : {:?}",cmdreqroles);
        botinstance::botlog::trace(
            &format!("cmd required roles : {:?}", cmdreqroles),
            Some("identity.rs > can_user_run()".to_string()),
            None,
        );

        if cmdreqroles.contains(&UserRole::Mod(ChType::Channel(String::new()))) {
            // match self.special_roles_users.get(&channelname) {
            //     Some(usrroles) => {},
            //     None => (),

            // }

            // println!("Command requires Mod Role");
            botinstance::botlog::trace(
                "Command requires Mod Role",
                Some("identity.rs > can_user_run()".to_string()),
                None,
            );

            if let Some(a) = (&*self)
                .special_roles_users
                .read()
                .await
                .get(&usr.to_lowercase())
            {
                // println!("Special roles found for user");
                botinstance::botlog::trace(
                    "Special roles found for user",
                    Some("identity.rs > can_user_run()".to_string()),
                    None,
                );

                if a.read().await.contains(&UserRole::Mod(channelname.clone()))
                    || a.read()
                        .await
                        .contains(&UserRole::SupMod(channelname.clone()))
                {
                    // return Ok(Permissible::Allow);
                    // println!("Special roles found for user : A mod idenfified ");
                    botinstance::botlog::trace(
                        "> Special Role Identified : Mod ",
                        Some("identity.rs > can_user_run()".to_string()),
                        None,
                    );
                    return (Permissible::Allow, modrolechange);
                }
            }
        }

        // [x] If cmdreqroles includes UserRole::SupMod("") , checks if chatter has UserRole::SupMod(channelname::ChType) to determine if Ok(Permissible::Allow)

        if cmdreqroles.contains(&UserRole::SupMod(ChType::Channel(String::new()))) {
            if let Some(a) = (&*self)
                .special_roles_users
                .read()
                .await
                .get(&usr.to_lowercase())
            {
                if a.read()
                    .await
                    .contains(&UserRole::SupMod(channelname.clone()))
                {
                    // return Ok(Permissible::Allow);
                    return (Permissible::Allow, modrolechange);
                }
            }
        }

        // [x] If cmdreqroles includes UserRole::BotAdmin and chatter has UserRole::BotAdmin , Ok(Permissible::Allow)

        // println!("Eval cmdreqroles with botadmin : {}",cmdreqroles.contains(&UserRole::BotAdmin));
        botinstance::botlog::trace(
            &format!(
                "Eval cmdreqroles with botadmin : {}",
                cmdreqroles.contains(&UserRole::BotAdmin)
            ),
            Some("identity.rs > can_user_run()".to_string()),
            None,
        );

        if cmdreqroles.contains(&UserRole::BotAdmin) {
            // println!("special roles get : {:?}",(&*self).special_roles_users.read().await.get(&usr.to_lowercase()));
            botinstance::botlog::trace(
                &format!(
                    "special roles get : {:?}",
                    (&*self)
                        .special_roles_users
                        .read()
                        .await
                        .get(&usr.to_lowercase())
                ),
                Some("identity.rs > can_user_run()".to_string()),
                None,
            );

            if let Some(a) = (&*self)
                .special_roles_users
                .read()
                .await
                .get(&usr.to_lowercase())
            {
                println!(
                    "special roles contains BotAdmin: {}",
                    a.read().await.contains(&UserRole::BotAdmin)
                );
                botinstance::botlog::trace(
                    &format!(
                        "special roles contains BotAdmin: {}",
                        a.read().await.contains(&UserRole::BotAdmin)
                    ),
                    Some("identity.rs > can_user_run()".to_string()),
                    None,
                );

                if a.read().await.contains(&UserRole::BotAdmin) {
                    // return Ok(Permissible::Allow);
                    return (Permissible::Allow, modrolechange);
                }
            }
        }

        (
            Permissible::Block,
            ChangeResult::NoChange("Not any permissiable condition".to_string()),
        )
    }

    // pub async fn promote(&mut self,trgchatter:String,channel:Option<ChType>,trg_role:Option<UserRole>) -> ChangeResult {
    pub async fn promote(
        &self,
        authorizer: String,
        authorizer_badge: &Option<ChatBadge>,
        trgchatter: String,
        channel: Option<ChType>,
        trg_role: Option<UserRole>,
    ) -> ChangeResult {
        botinstance::botlog::trace(
            &format!(
            "IN VARS for promote() : auth : {} ; authbadge : {:?} ; trg : {} ; Channel {:?} ; {:?}",
                        authorizer,authorizer_badge,trgchatter,channel,trg_role),
            Some("identity.rs > promote()".to_string()),
            None,
        );
        Log::flush();

        /*
            [x] 1. Check if Authorizer Mod Badge then Auto Promote to Mod if not Mod
            [x] 2. Get Authorizer & Target Chatter Roles with a Given Channel
            [x] 3. If the authorizer & Target Chatters are the same, and the Authorizer is not a Admin, return no change
            [x] 4a. If Authorizer is BotAdmin & trg_role is Some(BotAdmin) , set Target as BotAdmin and return
            [x] 4b. If target is Broadcaster, return NoChange
            [ ] 4c. If Authorizer is a SupMod,Broadcaster,BotAdmin , can Promote Target Chatter > Mod
                - NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
            [ ] 4d. If Authorizer is a Broadcaster,BotAdmin , can Promote a Target Mod > SupMod
                - NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod


        */

        // [x] 1. Check if Authorizer Mod Badge then Auto Promote to Mod if not Mod

        let trgchatter = trgchatter.to_lowercase();

        let (authusrroles, trgusrroles) = if let Some(channel) = channel.clone() {
            let mut authusrroles = self
                .getspecialuserroles(authorizer.to_lowercase().clone(), Some(channel.clone()))
                .await;

            {
                // mut block

                // let authusrroles_mut = &mut authusrroles;
                // [x] Add Mod(channel) to authusrroles
                // [x] #TODO also add to DB if possible?
                match *authorizer_badge {
                    Some(ChatBadge::Mod)
                        if (!authusrroles.contains(&UserRole::Mod(channel.clone()))
                            && !authusrroles.contains(&UserRole::SupMod(channel.clone()))) =>
                    {
                        // (*authusrroles_mut).push(UserRole::Mod(channel.clone()));
                        authusrroles.push(UserRole::Mod(channel.clone()));

                        // let mut srulock = self.special_roles_users.write().await;
                        // srulock
                        //     .get_mut(&trgchatter)
                        //     .expect("Error getting roles")
                        //     // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                        //     .write().await
                        //     .push(UserRole::Mod(channel.clone()));

                        self.affirm_chatter_in_db(authorizer.clone()).await;
                        self.add_role(authorizer.clone(), UserRole::Mod(channel.clone()))
                            .await;
                    }

                    _ => (),
                }
            } // mut block

            // [x] 2. Get Authorizer & Target Chatter Roles

            let trgusrroles = self
                .getspecialuserroles(trgchatter.to_lowercase().clone(), Some(channel.clone()))
                .await;

            (authusrroles, trgusrroles)
        } else {
            let mut authusrroles = self
                .getspecialuserroles(authorizer.to_lowercase().clone(), None)
                .await;
            let trgusrroles = self
                .getspecialuserroles(trgchatter.to_lowercase().clone(), None)
                .await;
            (authusrroles, trgusrroles)
        };

        //  [x] 3. If the authorizer & Target Chatters are the same, and the Authorizer is not a Admin, return no change
        if trgchatter == authorizer && !authusrroles.contains(&UserRole::BotAdmin) {
            return ChangeResult::NoChange("Can't target yourself".to_string());
        }

        // [x] 4a. If Authorizer is BotAdmin & trg_role is Some(BotAdmin) , set Target as BotAdmin and return
        if authusrroles.contains(&UserRole::BotAdmin) && trg_role == Some(UserRole::BotAdmin) {
            if trgusrroles.contains(&UserRole::BotAdmin) {
                return ChangeResult::NoChange("Already has the role".to_string());
            } else {
                // {
                //     let mut srulock = self.special_roles_users.write().await;

                //     srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                //     botinstance::botlog::trace(&format!("Ensuring Target Chatter in Roles > {:?}",srulock.entry(trgchatter.clone())),
                //     Some("identity.rs > promote()".to_string()), None);
                //     Log::flush();
                // }
                self.affirm_chatter_in_db(trgchatter.clone()).await;

                // {

                //     let mut srulock = self.special_roles_users.write().await;

                //     srulock
                //         .get_mut(&trgchatter)
                //         .expect("Error getting roles for the user")
                //         .write().await
                //         .push(UserRole::BotAdmin); // <-- Adds the specific role
                //     botinstance::botlog::trace(&format!("Inserting Role > {:?}",srulock.entry(trgchatter.clone())),
                //     Some("identity.rs > promote()".to_string()), None);
                //     Log::flush();
                // }
                self.add_role(trgchatter.clone(), UserRole::BotAdmin).await;

                return ChangeResult::Success("Promotion Successful".to_string());
            }
        }

        // [x] 4b. If target is Broadcaster, return NoChange

        if trgusrroles.contains(&UserRole::Broadcaster) {
            return ChangeResult::NoChange("Can't target broadcaster".to_string());
        }

        /*
           [ ] 4c. If Authorizer is a SupMod,Broadcaster,BotAdmin , can Promote Target Chatter > Mod
               - NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
           [ ] 4d. If Authorizer is a Broadcaster,BotAdmin , can Promote a Target Mod > SupMod
               - NOTE : We do not validate trg_role here - app logic requires you to promote 1 to Mod and 1 more to SupMod
        */

        // let authhasnsreqroles = match channel.clone() {

        //     Some(channel) => authusrroles.contains(&UserRole::SupMod(channel.clone())) ||
        //                                 authusrroles.contains(&UserRole::BotAdmin) ||
        //                                 authusrroles.contains(&UserRole::Broadcaster) ,
        //     None => authusrroles.contains(&UserRole::BotAdmin),
        // };

        if let Some(trg_chnl) = channel.clone() {
            if !trgusrroles.contains(&UserRole::Broadcaster)
                && !trgusrroles.contains(&UserRole::Mod(trg_chnl.clone()))
                && !trgusrroles.contains(&UserRole::SupMod(trg_chnl.clone()))
            {
                // target user is neither Mod nor SupMod && not broadcaster
                // target's Next Role would be Mod
                // Authorizer must be SupMod,Broadcaster,BotAdmin
                // > Promote target to Mod
                if authusrroles.contains(&UserRole::SupMod(trg_chnl.clone()))
                    || authusrroles.contains(&UserRole::Broadcaster)
                    || authusrroles.contains(&UserRole::BotAdmin)
                {
                    // {

                    //     // If target user doesn't exist in special_roles_users , add with blank vector roles
                    //     let mut srulock = self.special_roles_users.write().await;
                    //     srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                    //     botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(trgchatter.clone())),
                    //     Some("identity.rs > promote()".to_string()), None);
                    //     Log::flush();
                    // }
                    self.affirm_chatter_in_db(trgchatter.clone()).await;

                    // {
                    //     // promote target after
                    //     let mut srulock = self.special_roles_users.write().await;
                    //     srulock
                    //         .get_mut(&trgchatter)
                    //         .expect("Error getting roles")
                    //         .write().await
                    //         .push(UserRole::Mod(trg_chnl.clone())); // Role to Add
                    //     botinstance::botlog::trace(&format!("Adding Roles to Chatter {:?}",srulock.entry(trgchatter.clone())),
                    //     Some("identity.rs > promote()".to_string()), None);
                    //     Log::flush();
                    // }
                    self.add_role(trgchatter.clone(), UserRole::Mod(trg_chnl.clone()))
                        .await;

                    return ChangeResult::Success(String::from("Promotion Successful"));
                }
                // Other else conditions would be mostly spcecial responses like ChangeResult::NoChange or ChangeResult::Fail
                // related to authusrroles
                else {
                    return ChangeResult::Failed(String::from("You're not permitted to do that"));
                }
            } else if !trgusrroles.contains(&UserRole::Broadcaster)
                && trgusrroles.contains(&UserRole::Mod(trg_chnl.clone()))
                && !trgusrroles.contains(&UserRole::SupMod(trg_chnl.clone()))
            //
            {
                // target user is a Mod && not broadcaster
                // target's Next Role would be SupMod
                // [ ] #todo Check first if target have SupMod - Optional but could be done to cleanup first
                // Authorizer must be Broadcaster,BotAdmin
                // > Promote target to SupMod

                if authusrroles.contains(&UserRole::Broadcaster)
                    || authusrroles.contains(&UserRole::BotAdmin)
                {
                    // { // Inserts user if doesn't exist
                    //     let mut srulock = self.special_roles_users.write().await;
                    //     srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                    //     botinstance::botlog::trace(&format!("Ensuring User in Roles {:?}",srulock.entry(trgchatter.clone())),
                    //     Some("identity.rs > promote()".to_string()), None);
                    //     Log::flush();
                    // }
                    self.affirm_chatter_in_db(trgchatter.clone()).await;

                    // { // Adds the requested role for the user
                    //     let mut srulock = self.special_roles_users.write().await;
                    //     srulock
                    //         .get_mut(&trgchatter)
                    //         .expect("Error getting roles")
                    //         // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                    //         .write().await
                    //         .push(UserRole::SupMod(trg_chnl.clone()));
                    //     botinstance::botlog::trace(&format!("Adding Required Role > {:?}",srulock.entry(trgchatter.clone())),
                    //     Some("identity.rs > promote()".to_string()), None);
                    //     Log::flush();
                    // }

                    self.add_role(trgchatter.clone(), UserRole::SupMod(trg_chnl.clone()))
                        .await;

                    // {  // Removes the lower role (mod) from the user
                    //     let mut srulock = self.special_roles_users.write().await;
                    //     let mut uroleslock = srulock
                    //             .get_mut(&trgchatter)
                    //             .expect("Error getting roles")
                    //             .write().await;
                    //     if let Some(indx) = uroleslock.iter().position(|value| *value == UserRole::Mod(trg_chnl.clone())){
                    //         uroleslock.swap_remove(indx);
                    //     }

                    //     botinstance::botlog::trace(&format!("Removing lower role > {:?}",uroleslock),
                    //     Some("identity.rs > promote()".to_string()), None);
                    //     Log::flush();
                    // }

                    self.remove_role(trgchatter, UserRole::Mod(trg_chnl.clone()))
                        .await;

                    return ChangeResult::Success(String::from("Promotion Successful"));
                } else {
                    return ChangeResult::Failed(String::from("You're not permitted to do that"));
                }
            } else if !trgusrroles.contains(&UserRole::Broadcaster)
                && trgusrroles.contains(&UserRole::SupMod(trg_chnl.clone()))
            {
                // target user is a SuMod && not broadcaster
                // No Change
                return ChangeResult::Failed(String::from("Already highest available role"));
            } else {
                // since handling for channel is already done, will be handling other trguserroles situations here
                // other situations includes :
                /*
                   [-] targetuser is broadcaster >> no need - this was done earlier in the function
                   [?] ?
                */

                // At the moment, without any new roles, this should not be reached

                botinstance::botlog::warn(
                    &format!("Code Warning : add handing for other trgusrroles"),
                    Some("identity.rs > promote()".to_string()),
                    None,
                );
                return ChangeResult::Failed(String::from("Code Warning"));
            }

            // let trghasreqroles =

            // {

            //     // If target user doesn't exist in special_roles_users , add with blank vector roles
            //     let mut srulock = self.special_roles_users.write().await;
            //     srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
            //     botinstance::botlog::trace(&format!("Ensuring Chatter in Roles {:?}",srulock.entry(trgchatter.clone())),
            //     Some("identity.rs > promote()".to_string()), None);
            //     Log::flush();
            // }
            // {
            //     // promote target after
            //     let mut srulock = self.special_roles_users.write().await;
            //     srulock
            //         .get_mut(&trgchatter)
            //         .expect("Error getting roles")
            //         // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
            //         .write().await
            //         .push(UserRole::Mod(trg_chnl.clone())); // Role to Add
            //     botinstance::botlog::trace(&format!("Adding Roles to Chatter {:?}",srulock.entry(trgchatter.clone())),
            //     Some("identity.rs > promote()".to_string()), None);
            //     Log::flush();
            // }

            // return ChangeResult::Success(String::from("Promotion Successful"));
        };

        // if authhasnsreqroles {

        //     {

        //         // If target user doesn't exist in special_roles_users , add with blank vector roles
        //         let mut srulock = self.special_roles_users.write().await;
        //         srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
        //         botinstance::botlog::trace(&format!("SRLOCK - 1st write > {:?}",srulock.entry(trgchatter.clone())),
        //         Some("identity.rs > promote()".to_string()), None);
        //         Log::flush();
        //     }
        //     {
        //         // promote target after
        //         let mut srulock = self.special_roles_users.write().await;
        //         srulock
        //             .get_mut(&trgchatter)
        //             .expect("Error getting roles")
        //             // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
        //             .write().await
        //             .push(UserRole::Mod(trg_chnl));
        //         botinstance::botlog::trace(&format!("SRLOCK - 2st write > {:?}",srulock.entry(trgchatter.clone())),
        //         Some("identity.rs > promote()".to_string()), None);
        //         Log::flush();
        //     }

        //     return ChangeResult::Success(String::from("Promotion Successful"));

        // }

        // authusrroles.contains(&UserRole::Mod(()))

        /*


        let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;


        let rolemap = chatterroles;

        match trg_role {
            Some(UserRole::Mod(_)) => {


                if let Some(trg_chnl) = channel.clone() {

                    // [ ] 1. If trg_role & trgchatter is a Mod or SupMod of the target channel, return NoChange

                    let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;
                    let rolemap = chatterroles;
                    // let rolemap = rolemap.unwrap();
                    if rolemap.contains(&UserRole::Mod(trg_chnl.clone())) {
                        return ChangeResult::NoChange(String::from("Target User already has Target Role"));
                    } else if rolemap.contains(&UserRole::Broadcaster) {
                        return ChangeResult::NoChange(String::from("No need to do that for broadcaster"));
                    }

                    // # otherwise, trg_role for the given chnl is not assigned to the trgchatter
                    // chatterroles.push(UserRole::Mod(trg_chnl.clone()));
                    // let a = self.special_roles_users;
                    // let b = a.write().await;
                    // // let c = b.get_mut(&trgchatter);
                    // let c = (*b).;

                    // [ ] 2. Ensure an entry in Special_Roles_user for trgchatter, and push Mod(Channel) for the Target User

                    // [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway

                    {

                        // If target user doesn't exist in special_roles_users , add with blank vector roles
                        let mut srulock = self.special_roles_users.write().await;
                        srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                        botinstance::botlog::trace(&format!("SRLOCK - 1st write > {:?}",srulock.entry(trgchatter.clone())),
                        Some("identity.rs > promote()".to_string()), None);
                        Log::flush();
                    }
                    {
                        // promote target after
                        let mut srulock = self.special_roles_users.write().await;
                        srulock
                            .get_mut(&trgchatter)
                            .expect("Error getting roles")
                            // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                            .write().await
                            .push(UserRole::Mod(trg_chnl));
                        botinstance::botlog::trace(&format!("SRLOCK - 2st write > {:?}",srulock.entry(trgchatter.clone())),
                        Some("identity.rs > promote()".to_string()), None);
                        Log::flush();
                    }

                    return ChangeResult::Success(String::from("Promotion Successful"));
                }


            },
            Some(UserRole::SupMod(_)) =>
            {
                    if let Some(trg_chnl) = channel.clone() {

                        // [ ] 1. If trg_role & trgchatter is a Mod or SupMod of the target channel, return NoChange

                        let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;
                        let rolemap = chatterroles;
                        // let rolemap = rolemap.unwrap();
                        if rolemap.contains(&UserRole::SupMod(trg_chnl.clone())) {
                            return ChangeResult::NoChange(String::from("Target User already has Target Role"));
                        } else if rolemap.contains(&UserRole::Broadcaster) {
                            return ChangeResult::NoChange(String::from("No need to do that for broadcaster"));
                        }
                        // # otherwise, trg_role for the given chnl is not assigned to the trgchatter
                        // chatterroles.push(UserRole::Mod(trg_chnl.clone()));
                        // let a = self.special_roles_users;
                        // let b = a.write().await;
                        // // let c = b.get_mut(&trgchatter);
                        // let c = (*b).;


                        // [ ] 2. Ensure an entry in Special_Roles_user for trgchatter, and push SupMod(Channel) for the Target User

                        // [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway

                        {
                            let mut srulock = self.special_roles_users.write().await;
                            srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                            botinstance::botlog::trace(&format!("SRLOCK - 1st write > {:?}",srulock.entry(trgchatter.clone())),
                            Some("identity.rs > promote()".to_string()), None);
                            Log::flush();
                        }
                        {
                            let mut srulock = self.special_roles_users.write().await;
                            srulock
                                .get_mut(&trgchatter)
                                .expect("Error getting roles")
                                // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                                .write().await
                                .push(UserRole::SupMod(trg_chnl.clone()));
                            botinstance::botlog::trace(&format!("SRLOCK - 2st write > {:?}",srulock.entry(trgchatter.clone())),
                            Some("identity.rs > promote()".to_string()), None);
                            Log::flush();
                        }
                        {
                            let mut srulock = self.special_roles_users.write().await;
                            // srulock
                            //     .get_mut(&trgchatter)
                            //     .expect("Error getting roles")
                            //     // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                            //     .write().await
                            //     .(UserRole::Mod(trg_chnl));
                            // let indx = srulock.iter().position()
                            let mut uroleslock = srulock
                                    .get_mut(&trgchatter)
                                    .expect("Error getting roles")
                                    // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                                    .write().await;
                            if let Some(indx) = uroleslock.iter().position(|value| *value == UserRole::Mod(trg_chnl.clone())){
                                uroleslock.swap_remove(indx);
                            }

                            botinstance::botlog::trace(&format!("SRLOCK - 2st write > {:?}",uroleslock),
                            Some("identity.rs > promote()".to_string()), None);
                            Log::flush();
                        }

                        return ChangeResult::Success(String::from("Promotion Successful"));
                    }
                } ,
            Some(UserRole::BotAdmin) => {



                let chatterroles = self.getspecialuserroles(trgchatter.clone(), channel.clone()).await;
                let rolemap = chatterroles;

                botinstance::botlog::trace(&format!("Target Role : BotAdmin"),
            Some("identity.rs > promote()".to_string()), None);

               // [x] 1. Check their roles first if they already have botadmin
               // [x] 2. Know that prior to promote() , BotAdmins should have been validated before being able to pass the BotAdmin target

                // [x] 1. Check target chatter's roles first if they already have botadmin
                botinstance::botlog::trace(&format!("Eval rolemap.contains(BotAdmin) : {}",rolemap.contains(&UserRole::BotAdmin)),
                Some("identity.rs > promote()".to_string()), None);

                botinstance::botlog::trace(&format!("Eval rolemap.contains(BotAdmin) > Rolemap : {:?}",rolemap),
                Some("identity.rs > promote()".to_string()), None);

                // [ ] (!) This seems to be an issue - rolemap by this point is blank
                if rolemap.contains(&UserRole::BotAdmin) {
                    return ChangeResult::NoChange(String::from("Target User already has Target Role"));
                }
                // # otherwise, trg_role for the given chnl is not assigned to the trgchatter
                // chatterroles.push(UserRole::Mod(trg_chnl.clone()));

                // [x] (!!) AROUND HERE - check if the user exists first, and at least add the user as we're promoting anyway

                {
                    let mut srulock = self.special_roles_users.write().await;

                    srulock.entry(trgchatter.clone()).or_insert(Arc::new(RwLock::new(vec![])));
                    botinstance::botlog::trace(&format!("SRLOCK - 1st write > {:?}",srulock.entry(trgchatter.clone())),
                    Some("identity.rs > promote()".to_string()), None);
                    Log::flush();
                }

                {

                    let mut srulock = self.special_roles_users.write().await;

                    srulock
                        .get_mut(&trgchatter)
                        // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                        .expect("Error getting roles")
                        .write().await
                        .push(UserRole::BotAdmin);
                    botinstance::botlog::trace(&format!("SRLOCK - 2nd write > {:?}",srulock.entry(trgchatter.clone())),
                    Some("identity.rs > promote()".to_string()), None);
                    Log::flush();
                }
                botinstance::botlog::trace(&format!("Target Role : BotAdmin >> Successful"),
                    Some("identity.rs > promote()".to_string()), None);

                return ChangeResult::Success(String::from("Promotion Successful"));
            },
            Some(_) => {
                botinstance::botlog::warn(&format!("Runtime reached undeveloped code"),
                Some("identity.rs > promote()".to_string()), None);
            },
            None => {
                botinstance::botlog::warn(&format!("Runtime reached undeveloped code"),
                Some("identity.rs > promote()".to_string()), None);
            },
        }

        */

        // match chatterroles {
        //     Some(chatterroles) => {

        //         // [x] chatter already has the target role
        //         if chatterroles.contains(&trg_role) {
        //             return ChangeResult::NoChange(String::from("Target User already has Target Role"));
        //         }

        //         // By this point, chatteroles does not contain target role
        //         // match trgRole {
        //         //     Some(trgRole) => {
        //         //         match trgRole {
        //         //             UserRole::Mod(a) => {

        //         //             },
        //         //             UserRole::SupMod(a) => (),
        //         //             UserRole::BotAdmin => (),
        //         //             _ => (), // <-- do nothing with al other options
        //         //         }
        //         //     },
        //         //     None => {
        //         //         /*
        //         //         - If trgRole is None , then promote by implicit rules . For example,
        //         //             - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
        //         //             - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
        //         //             - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
        //         //          */
        //         //     },

        //         // }

        //         // let trgRole = match trgRole {
        //         //     Some(UserRole::Mod(a)) => a,
        //         //     Some(UserRole::SupMod(a)) => a,
        //         //     Some(UserRole::BotAdmin) => UserRole::BotAdmin,
        //         //     None => {
        //         //         /*
        //         //         - If trgRole is None , then promote by implicit rules . For example,
        //         //             - For UserRoles without Mod or SupMod & Caller is SupMod | Broadcaster | BotAdmin > To Mod
        //         //             - For Mod & Caller is SupMod | Broadcaster | BotAdmin > To SupMod
        //         //             - For UserRoles without BotAdmin & Caller is BotAdmin > To BotAdmin
        //         //          */
        //         //     },

        //         // };

        //         // if let Some(trgRole) = trgRole {

        //         //     // [x] chatter already has the target role
        //         //     if chatterroles.contains(&trgRole) {
        //         //         return ChangeResult::NoChange(String::from("Target User already has Target Role"));
        //         //     }

        //         //     // [ ] trgRole should be assigned based on the input channel
        //         //     let roletoassign = UserRole::
        //         // }

        //     },
        //     _ => (),
        // }
        botinstance::botlog::warn(
            &format!("Runtime reached undeveloped code"),
            Some("identity.rs > promote()".to_string()),
            None,
        );
        ChangeResult::Failed(String::from("ERROR"))
    }

    pub async fn demote(
        &self,
        authorizer: String,
        authorizer_badge: &Option<ChatBadge>,
        trgchatter: String,
        channel: Option<ChType>,
        // trg_role:Option<UserRole>
    ) -> ChangeResult {
        // botinstance::botlog::trace(&format!("IN VARS for demote() : Authorizer : {:?} ; Target Chatter : {} ; Target Channel : {:?} ; Targer Role {:?}",
        //                 authorizer,trgchatter,channel,trg_role),
        botinstance::botlog::trace(&format!("IN VARS for demote() : Authorizer : {:?} ; Target Chatter : {} ; Target Channel : {:?}",
                    authorizer,trgchatter,channel), Some("identity.rs > demote()".to_string()), None);
        Log::flush();

        /*
           Check authorizer roles (if any) for the target channel
           Check Targer User's roles (if any) for the target channel
           Target Channel may be NONE in the case of Non-Channel related roles (FUTURE ENH)

           Use the roles of the above to determine whether the authorizer can demote the target user or not
        */

        // [x] 1. If Authorizer's Badge is Mod, ensuring Sender is in DB as Mod(Channel)

        let trgchatter = trgchatter.to_lowercase();

        if let Some(channel) = channel {
            let mut authusrroles = self
                .getspecialuserroles(authorizer.to_lowercase().clone(), Some(channel.clone()))
                .await;
            // let authusrroles = authusrroles;
            {
                // let authusrroles_mut = &mut authusrroles;
                // [x] Add Mod(channel) to authusrroles
                // [x] #TODO also add to DB if possible?
                match *authorizer_badge {
                    Some(ChatBadge::Mod)
                        if (!authusrroles.contains(&UserRole::Mod(channel.clone()))
                            && !authusrroles.contains(&UserRole::SupMod(channel.clone()))) =>
                    {
                        // (*authusrroles_mut).push(UserRole::Mod(channel.clone()));
                        authusrroles.push(UserRole::Mod(channel.clone()));

                        // [ ] below pushes mod to authorizer
                        // let mut srulock = self.special_roles_users.write().await;
                        // srulock
                        //     .get_mut(&trgchatter)
                        //     .expect("Error getting roles")
                        //     // !! [ ] Unsure what happens if promoting a chatter that doesn't exist at
                        //     .write().await
                        //     .push(UserRole::Mod(channel.clone()));

                        self.add_role(authorizer.clone(), UserRole::Mod(channel.clone()))
                            .await;
                    }
                    _ => (),
                }
            }

            // [x] 2. Targer User's Vec<UserRole>

            let trgusrroles = self
                .getspecialuserroles(trgchatter.to_lowercase().clone(), Some(channel.clone()))
                .await;

            // [x] 3. Return if Authorizer & Target are same chatter and Authorizer is not a BotAdmin
            if trgchatter == authorizer && !authusrroles.contains(&UserRole::BotAdmin) {
                return ChangeResult::NoChange("Can't target yourself".to_string());
            }

            // [x] 4a. Authorizers who are BotAdmin, Broadcaster or Supermod can demote a Mod

            if (authusrroles.contains(&UserRole::BotAdmin)
                || authusrroles.contains(&UserRole::Broadcaster)
                || authusrroles.contains(&UserRole::SupMod(channel.clone())))
                && trgusrroles.contains(&UserRole::Mod(channel.clone()))
            {
                // // [ ] Below removes Mod from trgchatter
                // let mut srulock = self.special_roles_users.write().await;
                // let mut usrrolelock = srulock
                //     .get_mut(&trgchatter)
                //     .expect("Error getting roles")
                //     .write().await;
                // if let Some(indx) = usrrolelock.iter().position(|value| *value == UserRole::Mod(channel.clone())){
                //     usrrolelock.swap_remove(indx);
                //     return ChangeResult::Success("Demoted successfully".to_string())
                // }
                self.remove_role(trgchatter.clone(), UserRole::Mod(channel.clone()))
                    .await;
                return ChangeResult::Success("Demoted successfully".to_string());
            }
            // [x] 4b. Authorizers who are BotAdmin, Broadcaster can demote a SupMod
            else if (authusrroles.contains(&UserRole::BotAdmin)
                || authusrroles.contains(&UserRole::Broadcaster))
                && trgusrroles.contains(&UserRole::SupMod(channel.clone()))
            {
                // [ ] For Trgchatter, below pushes Mod UserRole and removes SupMod
                // let mut srulock = self.special_roles_users.write().await;
                // let mut usrrolelock = srulock
                //     .get_mut(&trgchatter)
                //     .expect("Error getting roles")
                //     .write().await;
                // usrrolelock.push(UserRole::Mod(channel.clone())); // pushes Mod , and removes SupMod
                // if let Some(indx) = usrrolelock.iter().position(|value| *value == UserRole::SupMod(channel.clone())){
                //     usrrolelock.swap_remove(indx);
                //     return ChangeResult::Success("Demoted successfully".to_string())
                // }

                self.add_role(trgchatter.clone(), UserRole::Mod(channel.clone()))
                    .await;
                self.remove_role(trgchatter.clone(), UserRole::SupMod(channel.clone()))
                    .await;
                return ChangeResult::Success("Demoted successfully".to_string());
            }
            // [x] 4c. When Target chatter isnt a Mod or SupMod to demote
            else if !trgusrroles.contains(&UserRole::Mod(channel.clone()))
                && !trgusrroles.contains(&UserRole::SupMod(channel.clone()))
            {
                return ChangeResult::Failed(
                    "Target chatter does not have a role that can be demoted".to_string(),
                );
            }
            // [x] 4d. When they're only a Mod
            else if authusrroles.contains(&UserRole::Mod(channel.clone())) {
                return ChangeResult::Failed("You're not permitted to do that".to_string());
            }
        }

        botinstance::botlog::warn(&format!("Potential Unhandled Demotion Condition : Consider explicitely adding in for better handling"), 
    Some("identity.rs > demote()".to_string()), None);
        Log::flush();
        ChangeResult::Failed(String::from("Did not meet criteria to demote succesfully"))
    }

    // pub async fn getspecialuserroles(&self,chattername:String,channel:Option<ChType>) -> Option<Arc<RwLock<Vec<UserRole>>>> {
    pub async fn getspecialuserroles(
        &self,
        chattername: String,
        channel: Option<ChType>,
    ) -> Vec<UserRole> {
        /*
           Note : Ideally this be called for a given chatter name ?
        */

        // [ ] !!! TODO: I don't think below is evaluating by given channel
        botinstance::botlog::debug(
            &format!(
                "IN VARS > chattername {} ; channel {:?}",
                chattername, channel
            ),
            Some("IdentityManager > getspecialuserroles()".to_string()),
            None,
        );

        // resulting vector
        let mut evalsproles = vec![];

        let chattername = chattername.to_lowercase();

        // Checks if broadcaster
        let channel_out = match channel {
            Some(channel_tmp) => {
                match channel_tmp {
                    ChType::Channel(channel_tmp) => {
                        // In this block, Some input channel is given
                        // We're comparing the channel name with chattername to determine if they're a broadcaster
                        if chattername == channel_tmp.to_lowercase() {
                            evalsproles.push(UserRole::Broadcaster);
                        }

                        Some(ChType::Channel(channel_tmp))
                    } // _ => ()
                }
            }
            None => None,
        };

        let rolesa = Arc::clone(&self.special_roles_users);

        let a = rolesa.read().await;
        // let a = Arc::clone(a)
        let a = a;
        let vecroles = &(*a);
        let vecroles = vecroles.get(&chattername);
        match vecroles {
            Some(a) => {
                // [ ] This needs to take the user roles for the user, then yield only the one for the channel if channel is explicitely provided
                // Some(Arc::clone(a))
                match channel_out {
                    Some(channel) => {
                        // let eval = a.read().await.contains(&UserRole::Mod(channel));
                        // let eval = a.read().await.contains(&UserRole::SupMod(channel));
                        botinstance::botlog::debug(
                            &format!("INTERNAL > All Roles found {:?}", &a),
                            Some("IdentityManager > getspecialuserroles()".to_string()),
                            None,
                        );

                        // a.read().await.contains(&UserRole::BotAdmin)
                        botinstance::botlog::trace(
                            &format!(
                                "INTERNAL > eval special roles contains botadmin : {:?}",
                                a.read().await.contains(&UserRole::BotAdmin)
                            ),
                            Some("IdentityManager > getspecialuserroles()".to_string()),
                            None,
                        );

                        if a.read().await.contains(&UserRole::BotAdmin) {
                            evalsproles.push(UserRole::BotAdmin);
                        }
                        if a.read().await.contains(&UserRole::Mod(channel.clone())) {
                            evalsproles.push(UserRole::Mod(channel.clone()));
                        }
                        if a.read().await.contains(&UserRole::SupMod(channel.clone())) {
                            evalsproles.push(UserRole::SupMod(channel.clone()));
                        }
                        // else {};
                    }
                    None => {
                        // here , do nothing if the channel not provided
                        // [ ] TODO : Future is to provide all maybe ?
                        // ... no I think missing this is an issue for when the flag is -admin and channel is None?
                        //
                        // => 02.13 - Decided That None is provided as a Channel, we can output non-channel related roles like BotAdmin
                        if a.read().await.contains(&UserRole::BotAdmin) {
                            evalsproles.push(UserRole::BotAdmin);
                        }
                    }
                }
            }
            None => {
                // here, the user has no special listed roles. Note though Broadcaster is not stored in special roles
                // Do nothing in this case
                // There may be an issue if the chattername does not exist at the moment in special_roles_users
                // In this case, evalsproles would only contain Broadcaster flags if any
            }
        }

        botinstance::botlog::debug(
            &format!("OUT > evalsproles {:?}", &evalsproles),
            Some("IdentityManager > getspecialuserroles()".to_string()),
            None,
        );

        return evalsproles;
    }
}

#[cfg(test)]
mod core_identity {

    use casual_logger::Extension;

    use super::*;

    #[test]
    fn user_role_identity() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);
        // let result = 2 + 2;
        // assert_eq!(result, 4);
        assert_eq!(
            UserRole::SupMod(ChType::Channel("strong".to_string())),
            UserRole::SupMod(ChType::Channel("Strong".to_lowercase()))
        );
    }

    #[tokio::test]
    async fn promote_workflow_01() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);

        let test_id_mgr = IdentityManager::init();

        // [x] Mod Attempts to Promote User
        let channel = Some(ChType::Channel("twitchchanneltest".to_string()));
        let trgchatter = "regularChatter".to_string();
        let authorizer_badge = &Some(ChatBadge::Mod);
        let authorizer = "chatMod".to_string();
        let trg_role = None;

        let rslt = test_id_mgr
            .promote(
                authorizer,
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role,
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Failed(String::from("You're not permitted to do that"))
        );
    }

    #[tokio::test]
    async fn promote_workflow_02() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);

        let test_id_mgr = IdentityManager::init();

        // [x] Broadcaster Promotes Chatter to SupMod
        let channel = Some(ChType::Channel("broadcasterer".to_string()));
        let trgchatter = "regularChatter".to_string();
        let authorizer_badge = &Some(ChatBadge::Broadcaster);
        let authorizer = "broadcasterer".to_string();
        let trg_role = None;

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(trgchatter.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::Mod(ChType::Channel("broadcasterer".to_string()))));

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(trgchatter.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::SupMod(ChType::Channel(
            "broadcasterer".to_string()
        ))));

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Failed(String::from("Already highest available role"))
        );
    }

    #[tokio::test]
    async fn promote_workflow_03() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);

        let test_id_mgr = IdentityManager::init();

        // [x] SupMod Promotes Chatter to SupMod

        // [x] Broadcaster first promotes a SupMod

        let broadcaster = "broadcasterer".to_string();
        let broadcaster_badge = &Some(ChatBadge::Broadcaster);
        let channel = Some(ChType::Channel(broadcaster.clone()));
        let supchatter = "superModerator".to_string();
        let trg_role = None;

        let rslt = test_id_mgr
            .promote(
                broadcaster.clone(),
                broadcaster_badge,
                supchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .promote(
                broadcaster.clone(),
                broadcaster_badge,
                supchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(supchatter.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::SupMod(channel.unwrap())));

        // [x] SupMod Attempts to Promote Chatter to SupMod

        // let broadcaster = "broadcasterer".to_string();
        let authorizer = supchatter;
        let authorizer_badge = &Some(ChatBadge::Broadcaster);
        let channel = Some(ChType::Channel(broadcaster.clone()));
        let trgchatter = "regularChatter".to_string();
        let trg_role = None;

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(trgchatter.clone(), channel.clone())
            .await;

        // assert!(rslt.contains(&UserRole::Mod(ChType::Channel("broadcasterer".to_string()))));
        assert!(rslt.contains(&UserRole::Mod(channel.clone().unwrap())));

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        // assert_eq!(rslt, ChangeResult::Success("Promotion Successful".to_string()));
        assert_eq!(
            rslt,
            ChangeResult::Failed("You're not permitted to do that".to_string())
        );
    }

    #[tokio::test]
    async fn promote_workflow_04() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);

        let test_id_mgr = IdentityManager::init();

        // [x] BotAdmin Promotes Chatter to SupMod

        // [x] Create BotAdmin first

        let botadmin = "botadministrator".to_string();
        let botadmin_badge = &None;

        test_id_mgr.affirm_chatter_in_db(botadmin.clone()).await;
        test_id_mgr
            .add_role(botadmin.clone(), UserRole::BotAdmin)
            .await;

        let rslt = test_id_mgr
            .getspecialuserroles(botadmin.clone(), None)
            .await;

        assert!(rslt.contains(&UserRole::BotAdmin));

        // [x] SupMod Attempts to Promote Chatter to SupMod

        // let broadcaster = "broadcasterer".to_string();
        let authorizer = botadmin;
        let authorizer_badge = botadmin_badge;
        let channel = Some(ChType::Channel("somechannel".to_string()));
        let trgchatter = "regularChatter".to_string();
        let trg_role = None;

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(trgchatter.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::Mod(channel.clone().unwrap())));

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        // assert_eq!(rslt, ChangeResult::Success("Promotion Successful".to_string()));
        assert_eq!(
            rslt,
            ChangeResult::Success("Promotion Successful".to_string())
        );

        let rslt = test_id_mgr
            .getspecialuserroles(trgchatter.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::SupMod(channel.clone().unwrap())));

        let rslt = test_id_mgr
            .promote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
                trg_role.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Failed(String::from("Already highest available role"))
        );
    }

    #[tokio::test]
    async fn demote_workflow_01() {
        Log::set_file_ext(Extension::Log);
        // Log::set_level(Level::Trace);

        // [x] SupMod demotes a mod

        // [x] create a SupMod first

        let test_id_mgr = IdentityManager::init();

        let supmod = "supmoder".to_string();
        // let supmod_badge = &None;
        let channel = Some(ChType::Channel("somechannel".to_string()));

        test_id_mgr.affirm_chatter_in_db(supmod.clone()).await;
        test_id_mgr
            .add_role(supmod.clone(), UserRole::SupMod(channel.clone().unwrap()))
            .await;

        let rslt = test_id_mgr
            .getspecialuserroles(supmod.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::SupMod(channel.clone().unwrap())));

        // [x] Create regular mod

        let regmod = "moder".to_string();
        // let supmod_badge = &None;
        // let channel = Some(ChType::Channel("somechannel".to_string()));

        test_id_mgr.affirm_chatter_in_db(regmod.clone()).await;
        test_id_mgr
            .add_role(regmod.clone(), UserRole::Mod(channel.clone().unwrap()))
            .await;

        let rslt = test_id_mgr
            .getspecialuserroles(regmod.clone(), channel.clone())
            .await;

        assert!(rslt.contains(&UserRole::Mod(channel.clone().unwrap())));

        // [x] Regular mod attempts to demote a supmod

        let authorizer = regmod.clone();
        let authorizer_badge = &None;
        let trgchatter = supmod.clone();

        let rslt = test_id_mgr
            .demote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Failed("You're not permitted to do that".to_string())
        );

        // [x] SupMod demotes regular mod

        let authorizer = supmod;
        let authorizer_badge = &None;
        let trgchatter = regmod;

        let rslt = test_id_mgr
            .demote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Success("Demoted successfully".to_string())
        );

        let rslt = test_id_mgr
            .demote(
                authorizer.clone(),
                authorizer_badge,
                trgchatter.clone(),
                channel.clone(),
            )
            .await;

        assert_eq!(
            rslt,
            ChangeResult::Failed(
                "Target chatter does not have a role that can be demoted".to_string()
            )
        );
    }
}