forcebot_rs/src/core/botinstance.rs

use tokio::sync::mpsc::UnboundedReceiver;
use twitch_irc::login::StaticLoginCredentials;
use twitch_irc::ClientConfig;
use twitch_irc::SecureTCPTransport;
use twitch_irc::TwitchIRCClient;
use twitch_irc::message::PrivmsgMessage;
use twitch_irc::message::ServerMessage;
use twitch_irc::transport::tcp::TCPTransport;
use twitch_irc::transport::tcp::TLS;
use std::env;
use dotenv::dotenv;

use std::collections::HashMap;

use rand::Rng;



use crate::core::ratelimiter::RateLimiter;
use crate::core::ratelimiter;

use crate::core::botmodules;
use crate::core::botmodules::ModulesManager;
use crate::core::identity::{IdentityManager,Permissible};


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


pub use ChType::Channel;

pub enum ModType {
    BotModule(String),
}

pub use ModType::BotModule;

#[derive(Clone)]
pub struct Chat {
    pub ratelimiters : HashMap<ChType,RateLimiter>, // used to limit messages sent per channel 
    pub client : TwitchIRCClient<TCPTransport<TLS>,StaticLoginCredentials>, 
}

impl Chat {


    pub fn init(ratelimiters:HashMap<ChType, RateLimiter>,
        client:TwitchIRCClient<TCPTransport<TLS>, StaticLoginCredentials>) -> Chat {
            Chat{
                ratelimiters : ratelimiters,
                client : client,
            } 
    }

    pub fn init_channel(&mut self, chnl:ChType) -> () {
        let n = RateLimiter::new();
        self.ratelimiters.insert(chnl,n);
    } 



	pub async fn say_in_reply_to(&mut self, msg:& PrivmsgMessage , mut outmsg:String) -> () {
        /*
        formats message before sending to TwitchIRC 

        - [x] Custom String Formatting (e.g., adding random black spaces)
        - [x] Ratelimiter Handling
        - [ ] Checkf if BotActions is Enabled & Caller is Allowed to Run

         */
		
		// self.client.say_in_reply_to(msg,outmsg).await.unwrap();

        // // let contextratelimiter = ratelimiters.get_mut(&msg.channel_login).expect("ERROR: Issue with Rate limiters");
        let contextratelimiter = self.ratelimiters
            .get_mut(&Channel(String::from(&msg.channel_login)))
            .expect("ERROR: Issue with Rate limiters");
        // let contextratelimiter = self.ratelimiters.get(&msg.channel_login).expect("ERROR: Issue with Rate limiters");
    
        match contextratelimiter.check_limiter() {
            ratelimiter::LimiterResp::Allow => {
                let maxblanks = rand::thread_rng().gen_range(1..=20);
                //let mut outmsg = "GotTrolled ".to_owned();
                // let mut outmsg = "annytfLurk ".to_owned();
    
                for _i in 1..maxblanks {
                    let blankspace: &str = "󠀀";
                    outmsg.push_str(blankspace);
                }
    
                // client.say_in_reply_to(&msg,outmsg).await.unwrap();
                self.client.say_in_reply_to(msg,outmsg).await.unwrap();
                println!("(#{}) > {}", msg.channel_login, "rate limit counter increase");
                contextratelimiter.increment_counter();
                println!("{:?}",self.ratelimiters);
            },
            ratelimiter::LimiterResp::Skip => {
                (); // do nothing otherwise
            }
	
	    }
    }
	
	async fn say(&self, _:String, _:String) -> () {
		// more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say
		
		
		// self.client.say(msg,outmsg).await.unwrap();
		
		
	}
	
	
	async fn me(&self, _:String, _:String) -> () {
		// more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say
		
		
		// self.client.me(msg,outmsg).await.unwrap();
		
		
	}
	
	async fn me_in_reply_to(&self, _:String, _:String) -> () {
		// more info https://docs.rs/twitch-irc/latest/twitch_irc/client/struct.TwitchIRCClient.html#method.say
		
		
		// self.client.me(msg,outmsg).await.unwrap();
		
		
	}


}



pub struct BotManagers {
    pub botmodules : ModulesManager,
    pub identity : IdentityManager,
}

impl BotManagers {

    pub fn init() -> BotManagers {
        BotManagers {
            botmodules : ModulesManager::init(),
            identity : IdentityManager::init(),
        }
    }
}

pub struct BotInstance
{
	prefix : char,
	bot_channel : ChType,
    pub incoming_messages : UnboundedReceiver<ServerMessage>,
    pub chat : Chat,
    // pub botmodules : ModulesManager,
	twitch_oauth : String,
	pub bot_channels : Vec<ChType>,
    // pub identity : IdentityManager,
    pub botmgrs : BotManagers,
}



impl BotInstance 
{


    pub fn init() -> BotInstance
    {
        dotenv().ok();

        let login_name = env::var("login_name").unwrap().to_owned();
        let oauth_token = env::var("access_token").unwrap().to_owned();
        let prefix = env::var("prefix").unwrap().to_owned().chars().next().expect("ERROR : when defining prefix");

        /*
        Vector of channels to join
        */

        let mut botchannels = Vec::new();

        for chnl in env::var("bot_channels").unwrap().split(',') {
            // println!("(Env Var # {})",chnl);
            botchannels.push(Channel(String::from(chnl)));
        }

        let config = ClientConfig::new_simple(
            StaticLoginCredentials::new(login_name.to_owned(), Some(oauth_token.to_owned()))
        );

        let (incoming_messages, client) =
        TwitchIRCClient::<SecureTCPTransport, StaticLoginCredentials>::new(config);

        // hashmap for channels and their associated ratelimiters
        let mut ratelimiters = HashMap::new();

        for Channel(chnl) in &botchannels {
            // For each channel in botchannels

            client.join(chnl.to_owned()).unwrap();

            // ratelimiters are a hashmap of channel and a corresponding rate limiter 
            let n = RateLimiter::new();
            ratelimiters.insert(Channel(String::from(chnl)),n);
            //self.chat.ratelimiters.insert(Channel(String::from(chnl)),n);
        }



        // let bm = &mut ModulesManager::init();

        

        let b = BotInstance {
            prefix : prefix,
            bot_channel : Channel(login_name) ,
            incoming_messages : incoming_messages,
            //client : client,
            chat : Chat {
                    ratelimiters : ratelimiters,
                    client : client,
                } ,
            // botmodules : ModulesManager::init(),
            twitch_oauth : oauth_token,
            bot_channels : botchannels,    
            // identity : IdentityManager::init(),
            botmgrs : BotManagers::init(),
        };


        println!("{:?}",b.chat.ratelimiters);


        b
    }

    pub async fn runner(mut self) -> () {

        let join_handle = tokio::spawn(async move {

            while let Some(message) = self.incoming_messages.recv().await {
                // Below can be used to debug if I want to capture all messages
                // println!("Received message: {:?}", message);
    
                match message {
                    ServerMessage::Notice(msg) => {
                        // if let Some(chnl) = msg.channel_login {
                        //     println!("NOTICE : (#{}) {}", chnl, msg.message_text);
                        // }
                        match msg.channel_login {
                            Some(chnl) => println!("NOTICE : (#{}) {}", chnl, msg.message_text),
                            None => println!("NOTICE : {}", msg.message_text),
                        }
                    }
                    ServerMessage::Privmsg(msg) => {
                        println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);

                        println!("Privmsg section");

                        // b.listener_main_prvmsg(&msg);
                        self.listener_main_prvmsg(msg).await;
                        // - BotCommand listener should likely need to be called within the above


                    },
                    ServerMessage::Whisper(msg) => {
                        println!("(w) {}: {}", msg.sender.name, msg.message_text);
                    },
                    ServerMessage::Join(msg) => {
                        println!("JOINED: {}", msg.channel_login);
                    },
                    ServerMessage::Part(msg) => {
                        println!("PARTED: {}", msg.channel_login);
                    },
                    _ => {}
                }
            }
        });
    
    
    
    
    
        join_handle.await.unwrap();
    }


// -----------------
// PRIVATE FUNCTIONS 


    // async fn listener_main_prvmsg(&mut self,msg:PrivmsgMessage) -> () {
    async fn listener_main_prvmsg(&self,msg:PrivmsgMessage) -> () {

        // println!("(#{}) {}: {}", msg.channel_login, msg.sender.name, msg.message_text);
                            
        // // [ ] Need to run through all Listener Bodies for Enabled Modules for the context of the message (e.g., ModStatus is Enabled in the context for the channel)

        for (_m,acts) in &self.botmgrs.botmodules.botactions {
            for a in acts {

                match a {

                    crate::core::botmodules::BotAction::C(c) => {
                        /* 
                        BotCommand handling -
                        - [x] Checks if the input message is a prefix with command name or alias
                        - [ ] Validate User can run based on identityModule(From_Bot)::can_user_run(
                                                        _usr:String,
                                                        _channelname:ChType,
                                                        _chat_badge:ChatBadge,
                                                        _cmdreqroles:Vec<UserRole>)
                        */

                        let inpt = msg.message_text.split("\n").next().expect("ERROR during BotCommand");

                        // [x] Check if a bot command based on ...
                        //    [x] prefix + command

                        let mut confirmed_bot_command = false;
                        if inpt == self.prefix.to_string() + c.command.as_str() {
                            confirmed_bot_command = true;
                        } 

                        //    [x] prefix + alias
                        for alias in &c.alias {
                            if inpt == self.prefix.to_string() + alias.as_str() {
                                confirmed_bot_command = true;
                            } 
                        }

                        if confirmed_bot_command {

                            // self.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone());
                            
                            // [ ] Around here, validate if permissable before executing
                            // match self.identity.clone().can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
                            //     Ok(Permissible::Allow) => c.execute(self.chat.clone(), msg.clone()).await,
                            //     Ok(Permissible::Block) => println!("User Not allowed to run command"),
                            //     _ => (),
                            // }

                            match self.botmgrs.identity.to_owned().can_user_run_PRVMSG(&msg, c.required_roles.clone()) {
                                // Ok(Permissible::Allow) => (),
                                Permissible::Allow => {
                                    println!("Executed as permissible");
                                    c.execute(self.chat.clone(), msg.clone()).await;
                                }
                                Permissible::Block => println!("User Not allowed to run command"),
                                // _ => (),
                            }

                            // c.execute(self.chat.clone(), msg.clone()).await;
                        }
                    },

                    crate::core::botmodules::BotAction::L(l) => l.execute(self.chat.clone(), msg.clone()).await,

                    _ => (),
                }
            }
        };

        // // [ ] There should be a BotCommand Listener to check for prefixes ran

        println!("End of Separate Listener Main prvmsg");

    }

    

}






// ======================================
// ======================================
// ======================================
// ======================================

// UNIT TEST MODULES





#[cfg(test)]
mod tests {
    fn always() {
        assert_eq!(1,1);
    }
}