g_lib 0.2.0

#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(non_upper_case_globals)]
/*
    image = "0.24.5"
    sqlite = "0.30.3"
    serde_json = "1.0.59"
    tokio = { version = "1.24.2", features = ["full"] }
    rand = "0.8.5"
    reqwest = { version = "0.11", features = ["blocking", "json"] }
    actix-web = "4.3.1"
    serde = "1.0.152"
    lettre = "0.10"
*/
pub use self::lettre::MailServiceProvider::*;

/// Use to Send E-Mail  OR  Use "lettre" lib easily
/// 
///
/// # Examples
///
/// ```
/// // SenderMailAdress@crates.io => RecieverMailAdress@crates.io
/// let MailSender =
/// g_lib::lettre::MailSender::new("{SenderMailAddress}@crates.io", "{AppPassword}", g_lib::Gmail);
/// MailSender
///    .send("{RecieverMailAdress}@crates.io", "{Subject}", "{Body}")
///    .unwrap();
///
/// ```
pub mod lettre {
    #[derive(PartialEq)]
    pub enum MailServiceProvider {
        Gmail,
        Etc,
    }
    pub struct MailSender {
        sEmail: String,
        sPw: String,
        MailServiceProvider: MailServiceProvider,
    }

    impl MailSender {
        pub fn new(
            srEmail: &str,
            srPw: &str,
            MailServiceProvider: MailServiceProvider,
        ) -> MailSender {
            let _MailSender = MailSender {
                sEmail: srEmail.to_owned(),
                sPw: srPw.to_owned(),
                MailServiceProvider: MailServiceProvider,
            };

            return _MailSender;
        }

        pub fn send(
            &self,
            srReceiverEmail: &str,
            srSubject: &str,
            srBody: &str,
        ) -> Result<(), String> {
            use lettre::message::header::ContentType;
            use lettre::transport::smtp::authentication::Credentials;
            use lettre::{Message, SmtpTransport, Transport};

            let EmailContent = Message::builder()
                .from((&self.sEmail).parse().unwrap())
                //reply_to("sproutz1319@gmail.com".parse().unwrap())
                .to(srReceiverEmail.parse().unwrap())
                .subject(srSubject)
                .header(ContentType::TEXT_PLAIN)
                .body(srBody.to_owned())
                .unwrap();

            let Creds = Credentials::new((&self.sEmail).to_owned(), (&self.sPw).to_owned());

            let SmtpTransporter = match self.MailServiceProvider {
                MailServiceProvider::Gmail => SmtpTransport::relay("smtp.gmail.com")
                    .unwrap()
                    .credentials(Creds)
                    .build(),
                _ => {
                    let sErrMsg = "Err : Failed to Find MailServiceProvider";
                    return Err(sErrMsg.to_owned());
                }
            };

            // Send the email
            match SmtpTransporter.send(&EmailContent) {
                Ok(_) => {
                    return Ok(());
                }
                Err(e) => {
                    let sErrMsg = format!("Err : lettre::MailSender.send : {:?}", e);
                    return Err(sErrMsg);
                }
            }
        }
    }
}

/// Use to Handle Vector
///
pub mod Vector {
    pub fn Get_uCountValueInVector<T>(Value: T, vT: &Vec<T>) -> u64
    where
        T: std::cmp::PartialEq,
    {
        let mut uCount: u64 = 0;
        for T_ in vT {
            if *T_ == Value {
                uCount += 1;
            }
        }

        return uCount;
    }
    #[inline]
    pub fn RemoveAllValueFromVec<T>(vec: &mut Vec<T>, value: T)
    where
        T: std::cmp::PartialEq,
    {
        let mut i: usize = 0;

        while i < vec.len() {
            if vec[i] == value {
                vec.remove(i);
            } else {
                i += 1;
            }
        }
    }
}
/// Use to deal with User Input in CLI.
/// 
pub mod stdio {

    pub fn std_flush() {
        std::io::Write::flush(&mut std::io::stdout().lock()).expect("Failed stdio::std_flush()");
    }

    #[inline]
    pub fn WaitUntilEnter() {
        std_flush();
        let _ = Get_sInput("Wait Until Inputed :");
    }

    #[inline]
    pub fn Get_sInput(sInputText: &str) -> String {
        if sInputText != "" {
            print!("{}", sInputText);
            std_flush();
        }

        let mut sInput = String::new();
        std::io::stdin().read_line(&mut sInput).unwrap();
        sInput = sInput[..sInput.len() - 2].to_owned();

        return sInput;
    }
}
/// Use to use "image" lib easily.
///
pub mod image {
    pub fn Save_ImageInAnotherName(
        sInputImagePath: &str,
        sOutputImagePath: &str,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let img = image::io::Reader::open(sInputImagePath)?.decode()?;
        img.save(sOutputImagePath)?;

        return Ok(());
    }
}
/// Use to Handle HashMap.
///
pub mod HashMap {
    pub fn Sort_HashmapByKey<K, V>(HashMap: &mut std::collections::HashMap<K, V>)
    where
        K: std::clone::Clone,
        K: std::cmp::Eq,
        K: std::hash::Hash,
        K: std::cmp::Ord,
        V: std::clone::Clone,
    {
        let mut sorted_keys: Vec<K> = HashMap.keys().cloned().collect();
        sorted_keys.sort();

        let mut NewHashMap: std::collections::HashMap<K, V> = std::collections::HashMap::new();
        for key in sorted_keys {
            let Value = HashMap.get(&key).unwrap().to_owned();
            NewHashMap.insert(key, Value);
        }
        *HashMap = NewHashMap;
    }

    pub fn Get_KeyByValueInHashMap<T, V>(
        map: &std::collections::HashMap<T, V>,
        value: V,
    ) -> Option<T>
    where
        V: std::cmp::PartialEq,
        T: Clone,
        V: Clone,
    {
        let map1 = (*map).clone();
        for (key, val) in map1.iter() {
            if *val == value {
                return Some((*key).clone());
            }
        }
        None
    }
    pub fn Get_vKeyInHashmap<T, V>(h_: &std::collections::HashMap<T, V>) -> Vec<T>
    where
        T: Clone,
    {
        let vKey: Vec<T> = h_.keys().map(|k| (*k).clone()).collect();
        return vKey;
    }
}
pub fn Get_sNumInForm(iNum: i64, sDelimeter: &str, uCount: usize) -> String {
    let sNum = &iNum.to_string();
    let uLen = sNum.len();
    let mut sReturn = String::from("");

    let mut i = uLen % uCount;
    sReturn.push_str(&sNum[0..i]);

    while i <= uLen - 1 {
        sReturn.push_str(sDelimeter);
        sReturn.push_str(&sNum[i..i + uCount]);

        i += uCount;
    }
    return sReturn;
}
/// Use to handle file and Set Working Directory.
pub mod fs {

    /// # Examples
    /// ```
    /// let sCurDir = g_lib::Get_sCurDir();
    /// ```
    #[inline]
    pub fn Get_sCurDir() -> String {
        return std::env::current_dir()
            .unwrap()
            .into_os_string()
            .into_string()
            .unwrap();
    }
    /// # Examples
    /// ```
    /// g_lib::Set_sCurDir("A:\\Rust").unwrap();
    /// ```
    pub fn Set_CurDir(sDir: &str) -> Result<(), std::io::Error> {
        std::env::set_current_dir(sDir)?;

        return Ok(());
    }

    /// # Examples
    /// ```
    /// let sRead = g_lib::Get_sReadByFileName("Rust.txt");
    /// ```
    pub fn Get_sReadByFileName(sFileName: &str) -> String {
        let text = std::fs::read_to_string(sFileName).unwrap();
        return text;
    }

    /// # Examples
    /// ```
    /// let bFile = g_lib::fs::Get_bFileInDirectory("MDA");
    /// println!("bFile :{}", &bFile);
    /// ```
    pub fn Get_bFileInCurDir(sName: &str) -> bool {
        let path = std::path::Path::new(sName);
        return path.exists();
    }
}

/// Use to use Other Web Api easily 
/// 
pub mod WebApi {
    pub fn Get_sWebApiResponse(sUrl: &str) -> String {
        let response = reqwest::blocking::get(sUrl).unwrap();
        return response.text().unwrap();
    }

    pub fn Get_jWebApiResponse(sUrl: &str) -> serde_json::Value {
        let response = reqwest::blocking::get(sUrl).unwrap();
        let sResponse = response.text().unwrap();
        let jResponse = crate::serde_json::Get_JsonValueByString(&sResponse);
        return jResponse;
    }

    pub mod Riot {
        #[derive(Debug, PartialEq, Clone)]
        pub struct LolPlayer {
            pub sPlayerPuuid: String,
            pub uPlayerNum: u64,
            pub sPlayerCharacter: String,
        }

        impl LolPlayer {
            pub fn new(
                sPlayerCharacter: &String,
                uPlayerNum: u64,
                sPlayerPuuid: &String,
            ) -> LolPlayer {
                return LolPlayer {
                    sPlayerPuuid: sPlayerPuuid.to_owned(),
                    uPlayerNum: uPlayerNum,
                    sPlayerCharacter: sPlayerCharacter.to_owned(),
                };
            }
        }

        #[derive(Debug, Clone)]
        pub struct LolKillLog {
            pub uMin: u64,
            pub uSec: u64,
            pub Victim: LolPlayer,
            pub Killer: LolPlayer,
            pub vRelaters: Vec<LolPlayer>,
        }

        impl LolKillLog {
            pub fn new(
                uMin: u64,
                uSec: u64,
                Victim: LolPlayer,
                Killer: LolPlayer,
                vRelaters: Vec<LolPlayer>,
            ) -> LolKillLog {
                return LolKillLog {
                    uMin,
                    uSec,
                    Victim,
                    Killer,
                    vRelaters,
                };
            }

            pub fn Get_uTotalSeconds(&self) -> u64 {
                let uTotalSeconds = self.uMin * 60 + self.uSec;
                return uTotalSeconds;
            }
            pub fn Get_bContainsCharacterName(&self, sCharacter: &str) -> bool {
                let svRelatersCharacter = Self::Get_svRelatersCharacter(self);

                let bContainsCharacterName = svRelatersCharacter.contains(&sCharacter.to_owned());
                return bContainsCharacterName;
            }

            pub fn Get_svRelatersCharacter(&self) -> Vec<String> {
                let vRelaters = &self.vRelaters;
                let mut svRelaters: Vec<String> = Vec::new();
                for Relater in vRelaters {
                    svRelaters.push(Relater.sPlayerCharacter.to_owned());
                }

                return svRelaters;
            }

            pub fn Get_svRelatersPuuid(&self) -> Vec<String> {
                let vRelaters = &self.vRelaters;
                let mut svRelatersPuuid: Vec<String> = Vec::new();
                for Relater in vRelaters {
                    svRelatersPuuid.push(Relater.sPlayerPuuid.to_owned());
                }

                return svRelatersPuuid;
            }
        }
        impl PartialEq for LolKillLog {
            fn eq(&self, other: &Self) -> bool {
                self.Get_uTotalSeconds() == other.Get_uTotalSeconds()
            }
        }
        impl Eq for LolKillLog {}
        impl Ord for LolKillLog {
            fn cmp(&self, other: &Self) -> std::cmp::Ordering {
                self.Get_uTotalSeconds().cmp(&other.Get_uTotalSeconds())
            }
        }

        impl PartialOrd for LolKillLog {
            fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
                Some(self.cmp(other))
            }
        }

        impl std::fmt::Display for LolKillLog {
            fn fmt(&self, Formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                let mut sRelaters: Vec<String> = Vec::new();
                for i in 0..self.vRelaters.len() {
                    let sRelater = &self.vRelaters[i].sPlayerCharacter;
                    sRelaters.push(sRelater.to_owned());
                }
                return write!(
                    Formatter,
                    "{}m {}s {} killed {} ( Relaters = {:?} )",
                    self.uMin,
                    self.uSec,
                    self.Killer.sPlayerCharacter,
                    self.Victim.sPlayerCharacter,
                    sRelaters,
                );
            }
        }
        pub struct RiotDevelop {
            sRiotDeveloperApiKey: String,
            sUserName: String,
        }

        impl RiotDevelop {
            pub fn new(sRiotDeveloperApiKey: &str) -> Result<RiotDevelop, String> {
                let sUrl = "https://kr.api.riotgames.com/lol/platform/v3/champion-rotations/"
                    .to_owned()
                    + "?api_key="
                    + sRiotDeveloperApiKey;
                let jRiotUserInfo = crate::WebApi::Get_jWebApiResponse(&sUrl);
                match (&jRiotUserInfo)["maxNewPlayerLevel"] {
                    serde_json::Value::Null => {
                        //println!("Err Invalid Riot Api Key : Get a new one.");
                        return Err("Invalid Riot Api Key. Get a new one.".to_owned());
                    }

                    _ => {
                        return Ok(RiotDevelop {
                            sRiotDeveloperApiKey: sRiotDeveloperApiKey.to_owned(),
                            sUserName: String::new(),
                        })
                    }
                }
            }

            fn Get_sUrlHexBysRiotGameName(sName: &str) -> String {
                let sName = sName.to_owned();
                let vyName = sName.as_bytes();
                let mut sReturn = String::new();
                for yName in vyName {
                    let sHex = crate::Get_sHexByiDecimal(*yName as i32);
                    sReturn += &("%".to_owned() + &sHex);
                }
                sReturn = sReturn.to_uppercase();
                return sReturn;
            }

            pub fn Get_jRiotUserInfo(&mut self, sUserName: &str) -> serde_json::Value {
                self.sUserName = sUserName.to_owned();
                let sUrl = "https://kr.api.riotgames.com/lol/summoner/v4/summoners/by-name/"
                    .to_owned()
                    + &Self::Get_sUrlHexBysRiotGameName(sUserName)
                    + "?api_key="
                    + &self.sRiotDeveloperApiKey;
                let jRiotUserInfo = crate::WebApi::Get_jWebApiResponse(&sUrl);
                return jRiotUserInfo;
            }

            fn Get_sRiotUserPuuidByJson(jRiotUserInfo: serde_json::Value) -> String {
                return jRiotUserInfo["puuid"].as_str().unwrap().to_owned();
            }

            pub fn Get_sRiotUserPuuid(&mut self, sUserName: &str) -> String {
                let jRiotUserInfo = self.Get_jRiotUserInfo(sUserName);
                let sRiotUserPuuid = Self::Get_sRiotUserPuuidByJson(jRiotUserInfo);
                return sRiotUserPuuid;
            }
            fn Get_sMatchesByPuuid(&self, sPuuid: &str) -> String {
                 let sUrl = "https://asia.api.riotgames.com/lol/match/v5/matches/by-puuid/"
                    .to_owned()
                    + sPuuid
                    + "/ids"
                    + "?api_key="
                    + &self.sRiotDeveloperApiKey;
                let sMatches = crate::WebApi::Get_sWebApiResponse(&sUrl);
                return sMatches;
            }

            pub fn Get_svMatchesPuuid(&mut self, sUserName: &str) -> Vec<String> {
                let sRiotUserPuuid = self.Get_sRiotUserPuuid(sUserName);
                let sListOfLolMatches = Self::Get_sMatchesByPuuid(self, &sRiotUserPuuid);
                let svListOfLolMatches = crate::SplitString(
                    &sListOfLolMatches[2..&sListOfLolMatches.len() - 2],
                    "\",\"",
                );
                return svListOfLolMatches;
            }

            pub fn Get_jMatchTimeline(&self, sMatchPuuid: &str) -> serde_json::Value {
                let sUrl = "https://asia.api.riotgames.com/lol/match/v5/matches/".to_owned()
                    + sMatchPuuid
                    + "/timeline"
                    + "?api_key="
                    + &self.sRiotDeveloperApiKey;
                let jMatchTimeline = crate::WebApi::Get_jWebApiResponse(&sUrl);
                return jMatchTimeline;
            }

            fn Get_hUserRecog(
                jMatchTimeline: &serde_json::Value,
            ) -> std::collections::HashMap<u64, String> {
                let mut hUserRecog: std::collections::HashMap<u64, String> =
                    std::collections::HashMap::new();
                let jParticipantsInfo = &jMatchTimeline["info"]["participants"];
                for i in 0..crate::serde_json::Get_uLenOfJsonValue(jParticipantsInfo) {
                    let uParticipantId = (&jParticipantsInfo)[i]["participantId"].as_u64().unwrap();
                    let sUserPuuid = (jParticipantsInfo)[i]["puuid"].as_str().unwrap().to_owned();
                    hUserRecog.insert(uParticipantId, sUserPuuid);
                    crate::HashMap::Sort_HashmapByKey(&mut hUserRecog);
                }
                return hUserRecog;
            }

            pub fn Get_vLolKillLogs<B>(
                &self,
                jMatchTimeline: &serde_json::Value,
                mut bfnCondition: B,
            ) -> Vec<LolKillLog>
            where
                B: FnMut(&LolKillLog) -> bool,
            {
                let _jWatching = &jMatchTimeline["info"]["frames"];
                let mut vKillLogs: Vec<LolKillLog> = Vec::new();
                let hUserRecog = Self::Get_hUserRecog(jMatchTimeline);
                //(&_WatchingJson)[i]["events"][j]
                for i in 0..crate::serde_json::Get_uLenOfJsonValue(_jWatching) {
                    for j in 0..crate::serde_json::Get_uLenOfJsonValue(&_jWatching[i]["events"]) {
                        //Get Victim Info
                        let soVicName =
                            &_jWatching[i]["events"][j]["victimDamageDealt"][0]["name"].as_str();
                        let sVicName = match soVicName {
                            None => continue,
                            Some(_) => soVicName.unwrap().to_owned(),
                        };
                        let uVictimNum =
                            *(&_jWatching[i]["events"][j]["victimId"].as_u64().unwrap());

                        let sVictimPuuid = hUserRecog.get(&uVictimNum).unwrap();
                        let Victim = LolPlayer::new(&sVicName, uVictimNum, sVictimPuuid);

                        let jVictimDamageReceived =
                            &_jWatching[i]["events"][j]["victimDamageReceived"];

                        //Get Killer Info
                        let sKillerCharacter = jVictimDamageReceived
                            [crate::serde_json::Get_uLenOfJsonValue(jVictimDamageReceived) - 1]
                            ["name"]
                            .as_str()
                            .unwrap()
                            .to_owned();
                        let uKillerNum =
                            (&_jWatching[i])["events"][j]["killerId"].as_u64().unwrap();

                        let sKillerPuuid = hUserRecog.get(&uKillerNum).unwrap();

                        let Killer = LolPlayer::new(&sKillerCharacter, uKillerNum, sKillerPuuid);

                        //Get Relaters Info
                        let mut vRelaters: Vec<LolPlayer> = Vec::new();
                        for i in 0..crate::serde_json::Get_uLenOfJsonValue(jVictimDamageReceived) {
                            let sRelaterCharacter = (jVictimDamageReceived)[i]["name"]
                                .as_str()
                                .unwrap()
                                .to_owned();
                            if sRelaterCharacter.contains("Minion")
                                || sRelaterCharacter.contains("Turret")
                            {
                                continue;
                            }

                            let uRelaterNum =
                                *(&jVictimDamageReceived[i]["participantId"].as_u64().unwrap());

                            // println!("sRelaterCharacter {}", sRelaterCharacter);
                            // println!("uRelaterNum {}", uRelaterNum);

                            // println!("hUserRecog : {:?}", &hUserRecog);
                            // println!("uRelaterNum : {}", &uRelaterNum);
                            let sRelaterPuuid = hUserRecog.get(&uRelaterNum).unwrap();
                            let Relater =
                                LolPlayer::new(&sRelaterCharacter, uRelaterNum, sRelaterPuuid);
                            if vRelaters.contains(&Relater) {
                                continue;
                            }
                            vRelaters.push(Relater);
                        }
                        //sv_Relaters.retain(|s| !(*s).contains("Minion") && !(*s).contains("Turret"));

                        //Get Time Info
                        let uTimeStamp =
                            (_jWatching)[i]["events"][j]["timestamp"].as_u64().unwrap() / 1000;
                        let uMin = uTimeStamp / 60;
                        let uSec = uTimeStamp % 60;

                        let KillLog = LolKillLog {
                            uMin: uMin,
                            uSec: uSec,
                            Victim: Victim,
                            Killer: Killer,
                            vRelaters: vRelaters,
                        };
                        //Test_LolKillLog {}

                        vKillLogs.push(KillLog);
                        //
                        // uTimeStamp, uMin, uSec, sVicName, sKiller, v_Relaters
                    }
                }
                vKillLogs.retain(|elem| bfnCondition(elem));
                return vKillLogs;
            }
            pub fn Get_vAllLolKillLogs(
                &self,
                jMatchTimeline: &serde_json::Value,
            ) -> Vec<LolKillLog> {
                let vAllLolKillLogs = self.Get_vLolKillLogs(jMatchTimeline, |_| true);
                return vAllLolKillLogs;
            }

            pub fn Get_vLolKillLogsByUserName(
                &mut self,
                jMatchTimeline: &serde_json::Value,
                sUserName: &str,
            ) -> Vec<LolKillLog> {
                let sPlayerPuuid = self.Get_sRiotUserPuuid(sUserName);
                let vLolKillLogs = self.Get_vLolKillLogs(jMatchTimeline, |LolKillLog| {
                    LolKillLog.Get_svRelatersPuuid().contains(&sPlayerPuuid)
                });
                return vLolKillLogs;
            }

            pub fn Get_sUserCharacter(
                &mut self,
                jMatchTimeline: &serde_json::Value,
                sUserName: &str,
            ) -> Option<String> {
                let sUserPuuid = self.Get_sRiotUserPuuid(sUserName);
                let _jWatching = &jMatchTimeline["info"]["frames"];
                let hUserRecog = Self::Get_hUserRecog(jMatchTimeline);
                //(&_WatchingJson)[i]["events"][j]
                for i in 0..crate::serde_json::Get_uLenOfJsonValue(&_jWatching) {
                    for j in 0..crate::serde_json::Get_uLenOfJsonValue(&_jWatching[i]["events"]) {
                        //Get Victim Info
                        let soVicName =
                            &_jWatching[i]["events"][j]["victimDamageDealt"][0]["name"].as_str();
                        let sVicName = match soVicName {
                            None => continue,
                            Some(_) => soVicName.unwrap().to_owned(),
                        };
                        let uVictimNum =
                            *(&_jWatching[i]["events"][j]["victimId"].as_u64().unwrap());

                        let sVictimPuuid = hUserRecog.get(&uVictimNum).unwrap().to_owned();

                        let jVictimDamageReceived =
                            &_jWatching[i]["events"][j]["victimDamageReceived"];

                        if sVictimPuuid == sUserPuuid {
                            return Some(sVicName);
                        }
                        //Get Killer Info
                        let sKillerCharacter = jVictimDamageReceived
                            [crate::serde_json::Get_uLenOfJsonValue(jVictimDamageReceived) - 1]
                            ["name"]
                            .as_str()
                            .unwrap()
                            .to_owned();
                        let uKillerNum =
                            (&_jWatching[i])["events"][j]["killerId"].as_u64().unwrap();

                        let sKillerPuuid = hUserRecog.get(&uKillerNum).unwrap().to_owned();

                        if sKillerPuuid == sUserPuuid {
                            return Some(sKillerCharacter);
                        }
                        //Get Relaters Info
                        for i in 0..crate::serde_json::Get_uLenOfJsonValue(jVictimDamageReceived) {
                            let sRelaterCharacter = (jVictimDamageReceived)[i]["name"]
                                .as_str()
                                .unwrap()
                                .to_owned();
                            if sRelaterCharacter.contains("Minion")
                                || sRelaterCharacter.contains("Turret")
                            {
                                continue;
                            }

                            let uRelaterNum =
                                *(&jVictimDamageReceived[i]["participantId"].as_u64().unwrap());

                            // println!("sRelaterCharacter {}", sRelaterCharacter);
                            // println!("uRelaterNum {}", uRelaterNum);

                            // println!("hUserRecog : {:?}", &hUserRecog);
                            // println!("uRelaterNum : {}", &uRelaterNum);
                            let sRelaterPuuid = hUserRecog.get(&uRelaterNum).unwrap().to_owned();

                            if sRelaterPuuid == sUserPuuid {
                                return Some(sRelaterCharacter);
                            }
                        }
                        //sv_Relaters.retain(|s| !(*s).contains("Minion") && !(*s).contains("Turret"));

                        //Get Time Info

                        //
                        // uTimeStamp, uMin, uSec, sVicName, sKiller, v_Relaters
                    }
                }

                return None;
            }
        }
    }
}

/// Use to Get Pointer Address 
/// 
pub fn Get_PointerAddress<T>(variable: &T) -> *const T {
    let Pointer = variable as *const _;
    return Pointer;
}

pub fn Get_sHexByiDecimal(iDecimal: i32) -> String {
    return format!("{:x}", iDecimal);
}
/// Use to Encode With Utf-8
/// 
pub fn EncodeUtf8(s_: String) -> Vec<u8> {
    return s_.as_bytes().to_owned();
}

/// Use to Change `Vec<String>` to String
/// 
pub fn Get_sv2s(sFront: &str, svMid: &Vec<String>, sEnd: &str, sDelimiter: &str) -> String {
    let mut sVectorToString = String::new();

    for sMid in svMid {
        let elem = sFront.to_owned() + sMid + sEnd + sDelimiter;
        sVectorToString += &elem;
    }

    sVectorToString = sVectorToString[..sVectorToString.len() - sDelimiter.len()].to_owned();
    return sVectorToString;
}

pub fn Get_bSameType<T, U>(__Var1: &T, __Var2: &U) -> bool {
    return std::any::type_name::<T>() == std::any::type_name::<U>();
}

/// Use to Use SqlDb easily  OR  Use "sqlite" lib easily
/// 
/// # Examples
/// ```
/// let Db = g_lib::SqlDb::new("{DbName}.sqlite3");
/// let sCondition = format!("{ColumnName} Like \"%{}%\"", "Rust");
/// 
/// let vRows = Db.select("{TableName}", &sCondition);
/// // OR 
/// let vRows = Db.execute_sQuery("SELECT * FROM {DbName} WHERE {ColumnName} LIKE\"%RUST%\"")
/// 
/// if vRows.len() == 0 {
///     println!("0 Data selected");
///     return;
/// }
/// 
/// for u in 0..vRows.len() {
///     let sPrint = format!(
///         "{} : {}",
///         u + 1,
/// 
///         g_lib::SqlDb::Get_sValueFromDbRow("{ColumnName}", &vRows[u]).unwrap()
///         // OR
///         g_lib::SqlDb::Get_iValueFromDbRow("{ColumnName}", &vRows[u]).unwrap()
/// 
///     );
///     println!("{}", &sPrint);
/// }
/// ```
pub struct SqlDb {
    ConnToDb: sqlite::Connection,
}
impl SqlDb {
    pub fn new(sFilePartName: &str) -> SqlDb {
        return SqlDb {
            ConnToDb: sqlite::open(sFilePartName)
                .expect("Error g_lib line 33: Failed to create sqlite"),
        };
    }
    pub fn create_table(&mut self, sTable: &str, sValues: String) {
        let sQuery = "CREATE TABLE ".to_owned() + sTable + " (" + &sValues + ")";
        self.execute_sQuery(&sQuery);
    }

    pub fn insert_s(&mut self, sTable: &str, sValues: &str) {
        let sQuery = "INSERT INTO ".to_owned() + sTable + " VALUES (" + sValues + ")";
        self.execute_sQuery(&sQuery);
    }

    pub fn insert_sv(&mut self, sTable: &str, svValues: &Vec<String>) {
        
        let mut sValues = String::new();

        for sWord in svValues {
            sValues += "\"";
            sValues += sWord;
            sValues += "\"";
            sValues += ", ";
        }
        sValues = sValues[..sValues.len() - 2].to_owned();
        let sQuery = "INSERT INTO ".to_owned() + sTable + " VALUES (" + &sValues + ")";
        self.execute_sQuery(&sQuery);
    }

    pub fn insert_h_s2s(
        &mut self,
        sTable: &str,
        hValues_s2s: &std::collections::HashMap<String, String>,
    ) {
        //Get vKeys
        let vKeys = crate::HashMap::Get_vKeyInHashmap(hValues_s2s);

        //Get vValues
        let mut vValue: Vec<String> = Vec::new();
        for Key in &vKeys {
            vValue.push(hValues_s2s.get(Key).unwrap().to_owned());
        }

        assert_eq!(vKeys.len(), vValue.len());
        //INSERT INTO 테이블 이름 (열1, 열2, ...) VALUE (값1, 값2 , ….)

        //Get sKeyQuery
        let sKeyQuery = Get_sv2s("", &vKeys, "", ", ");

        let sValueQuery = Get_sv2s("\"", &vValue, "\"", ", ");
        let sQuery = "INSERT INTO ".to_owned()
            + sTable
            + " ("
            + &sKeyQuery
            + ") VALUES ("
            + &sValueQuery
            + ")";
        self.execute_sQuery(&sQuery);
    }
    pub fn update(&mut self, sTable: &str, sSetVariables: String, sCondition: String) {
        let sQuery = "UPDATE ".to_owned()
            + sTable
            + " SET "
            + &sSetVariables
            + " WHERE "
            + &sCondition.replace("==", "=");
        self.execute_sQuery(&sQuery);
    }

    pub fn select(&self, sTable: &str, sCondition: &str) -> Vec<sqlite::Row> {


        let sQuery: String = "SELECT * FROM ".to_string()
            + sTable
            + " WHERE "
            + &sCondition.replace("==", "=").replace(',', " and ");
        let g_rows: Vec<sqlite::Row> = self
            .ConnToDb
            .prepare(sQuery)
            .unwrap()
            .into_iter()
            .map(|row| row.unwrap())
            .collect();
        return g_rows;
    }

    pub fn delete(&mut self, sTable: &str, sCondition: &str) {
        let sQuery =
            "DELETE FROM ".to_owned() + sTable + " WHERE " + &sCondition.replace("==", "=");
        self.execute_sQuery(&sQuery);
    }

    pub fn execute_sQuery(&self, sQuery: &str) -> Vec<sqlite::Row> {
        let sUpperQuery = sQuery[0..6].to_owned().to_ascii_uppercase();

        if sUpperQuery.contains(";") {
            return Vec::new();
        } else if sUpperQuery.contains("SELECT") {
            let g_rows: Vec<sqlite::Row> = self
                .ConnToDb
                .prepare(sQuery)
                .unwrap()
                .into_iter()
                .map(|row| row.unwrap())
                .collect();
            //let b = &a.cloned();
            return g_rows;
        } else {
            let _ = &self
                .ConnToDb
                .execute(sQuery)
                .expect("Error g_lib line 64: Given sql sQuery might be wrong. Check it Again");
            return Vec::new();
        }
    }
    fn Get_ValueFromDbRow<'a, T>(sColumn: &str, Row: &'a sqlite::Row) -> Result<T, String>
    where
        T: Clone,
        T: TryFrom<&'a sqlite::Value, Error = sqlite::Error>,
    {
        let Value = Row.read::<T, _>(sColumn).to_owned();
        return Ok(Value);
    }

    #[inline]
    pub fn Get_sValueFromDbRow(sColumn: &str, Row: &sqlite::Row) -> Result<String, String> {
        let sValue = Row.read::<&str, _>(sColumn).to_owned();
        return Ok(sValue);
    }

    pub fn Get_iValueFromDbRow(sColumn: &str, Row: &sqlite::Row) -> Result<i64, String> {
        let sValue = Row.read::<i64, _>(sColumn).to_owned();
        return Ok(sValue);
    }
}

/// Use to Get Type of Variable as String
/// 
#[inline]
pub fn Get_sTypeOfVariable<T>(__Variable: &T) -> String {
    let mut sTypeOfVariable = std::any::type_name::<T>().to_string();

    let svRemovePattern: Vec<&str> = vec!["alloc::vec::", "alloc::string::", "hash::map::"];

    for sRemovePattern in svRemovePattern {
        sTypeOfVariable = sTypeOfVariable.replace(sRemovePattern, "");
    }

    return sTypeOfVariable;
}
/// Use to Decode `&[u8]` to String
#[inline]
pub fn Decode_utf8(data: &[u8]) -> String {
    return std::str::from_utf8(&data).expect("Error g_lib line 127: Failed to Decode_utf8").to_owned();
}
/// Use to use TcpServer easily 
/// 
/// # Examples
/// ```
/// fn s2sFunc(sInput : String) -> String {
///     return sInput.replace("Python", "Rust");
/// }
///
///fn main() {
///     let TCP_Server = g_lib::TcpServer::new("127.0.0.1", 8000);
///     TCP_Server.start_s2s(s2sFunc);
/// }
/// ```
pub struct TcpServer {
    listener: std::net::TcpListener,
}

impl TcpServer {
    pub fn new(sIp: &str, iPort: u16) -> TcpServer {
        let sAddress: String = sIp.to_owned() + ":" + &iPort.to_string();

        let sErrorMsg =
            "Error g_lib line 135 :Failed to Create TcpListnerer at ".to_owned() + &sAddress;
        let listener = std::net::TcpListener::bind(&sAddress).expect(&sErrorMsg);
        println!("Server listening on [{}]", sAddress);
        let TcpServer = TcpServer { listener: listener };
        return TcpServer;
    }
    pub fn start_s2s(&self, func: fn(String) -> String) {
        for stream in self.listener.incoming() {
            match stream {
                Ok(stream) => {
                    println!("New connection : [{}]", stream.peer_addr().unwrap());
                    std::thread::spawn(move || {
                        // connection succeeded
                        Self::handle_client_s2s(stream, func)
                    });
                }

                Err(e) => {
                    println!("Error line 158: {}", e);
                    /* connection failed */
                }
            }
        }
    }

    fn handle_client_s2s(mut stream: std::net::TcpStream, func: fn(String) -> String) {
        const iByteSize: usize = 4096;

        let mut byteFromClient: &[u8];
        let u8EndUtf8Code = &3;
        loop {
            let mut byte = [0_u8; iByteSize]; // using 4096 byte buffer

            match std::io::Read::read(&mut stream, &mut byte) {
                Ok(size) => {
                    byteFromClient = &byte[0..size];
                    let mut sClientMsg: String = String::new();
                    sClientMsg.push_str(&crate::Decode_utf8(byteFromClient));

                    if byteFromClient.contains(u8EndUtf8Code) {
                        //Main
                        let sReturnText: String = func(sClientMsg.clone());

                        let sClientAddr = stream.peer_addr().unwrap().to_string();

                        match std::io::Write::write(&mut stream, sReturnText.as_bytes()) {
                            Ok(_) => {
                                println!(
                                    "[{}] sClientMsg :{}, sReturnText :{};",
                                    sClientAddr, sClientMsg, sReturnText
                                );
                            }

                            Err(_) => {
                                println!(
                                        "An error occurred while sending Msg, terminating connection with {}",
                                        stream.peer_addr().unwrap()
                                    );
                                stream.shutdown(std::net::Shutdown::Both).unwrap();
                                break;
                            }
                        }
                    }
                }

                Err(_) => {
                    println!(
                        "An error occurred, terminating connection with {}",
                        stream.peer_addr().unwrap()
                    );
                    stream.shutdown(std::net::Shutdown::Both).unwrap();
                    return;
                }
            }
        }
    }
}

impl Drop for TcpServer {
    fn drop(&mut self) {
        let sAddress = &self.listener.local_addr().unwrap().to_string();
        println!("TcpServer at {} closed.", sAddress);
    }
}

#[inline]
pub fn Get_sIpNuPort() -> (String, u16) {
    let sGoogleIp = "142.251.42.132:80";
    let _TcpStream = std::net::TcpStream::connect(sGoogleIp).unwrap();
    let local_addr = _TcpStream.local_addr().unwrap();
    return (local_addr.ip().to_string(), local_addr.port());
}


/// sleep ( seconds ( float ) )

#[inline]
pub fn sleep(fSeconds: f32) {
    std::thread::sleep(std::time::Duration::from_secs_f32(fSeconds));
}

/// Use to Use "rand" lib easily  OR  Get Random Numbers
pub mod rand {
    pub fn Get_iRandomNum(iMin: i32, iMax: i32) -> i32 {
        assert!(iMin <= iMax);

        let mut rng = rand::thread_rng();
        let random_number = rand::Rng::gen_range(&mut rng, iMin..iMax + 1);
        return random_number;
    }

    pub fn Get_ivDifferentRandomNum(iMin: i32, iMax: i32, iCount: u64) -> Vec<i32> {
        let mut arr: Vec<i32> = Vec::new();

        for i in iMin..iMax + 1 {
            arr.push(i);
        }

        let mut ivDifferentRandomNum: Vec<i32> = Vec::new();

        for _ in 0..iCount {
            let iRandomIndex = Get_iRandomNum(0, (arr.len() - 1) as i32) as usize;
            ivDifferentRandomNum.push(arr[iRandomIndex]);
            arr.remove(iRandomIndex);
        }

        return ivDifferentRandomNum;
    }
}

/// Use to Use "serde_json" lib easily  OR  Handle json
pub mod serde_json {
    pub fn Get_uLenOfJsonValue(js_: &serde_json::Value) -> usize {
        let uLenOfJson = match js_ {
            serde_json::Value::Object(map) => map.len(),
            serde_json::Value::Array(vec) => vec.len(),
            _ => 0, // for non-object and non-array values
        };

        return uLenOfJson;
    }

    #[inline]
    pub fn SaveJsonByJsonValue(sJsonValue: serde_json::Value, sFileName: String) {
        std::fs::write(
            sFileName,
            serde_json::to_string_pretty(&sJsonValue).unwrap(),
        )
        .unwrap();
    }

    #[inline]
    pub fn SaveJsonByString(sFileName: String, sText: &str) {
        let _JsonValue = Get_JsonValueByString(sText);
        SaveJsonByJsonValue(_JsonValue, sFileName);
    }

    #[inline]
    pub fn Get_JsonValueByString(sText: &str) -> serde_json::Value {
        let JsonValue: serde_json::Value =
            { serde_json::from_str::<serde_json::Value>(sText).unwrap() };
        // Save the JSON structure into the other file.
        return JsonValue;
    }
}
/// Use to Get `Vec<String>` that split-ed from `&str`
/// 
/// # Examples
/// ```
/// let srText = "Hello Rust Python World";
/// let svText = g_lib::SplitString(srText, " ");
/// println!("{:?}", &svText);
/// ```
#[inline]
pub fn SplitString(sText: &str, sSplitText: &str) -> Vec<String> {
    let mut sv_: Vec<String> = sText
        .split(sSplitText)
        .map(|s| s.parse().unwrap())
        .collect();
    crate::Vector::RemoveAllValueFromVec(&mut sv_, " ".to_owned());
    return sv_;
}
/// Use to Use "actix_web" lib easily  OR  Make Web-Back-end
/// 
/// # Examples
/// ```
/// #![allow(non_snake_case)]
/// mod g_lib;

/// // !!! Be CareFull On Using "Load_CommonHttpResponse" !!!
/// fn Load_CommonHttpResponse(
///     sFullHtmlFileName: &str,
///     session: &actix_session::Session,
/// ) -> actix_web::HttpResponse {
/// 
///     match session.get::<String>("sId").expect("GetKeyError : session") {
///         Some(sId) => {
///             let Db = g_lib::Db::new("LogIn.sqlite3");

///             let sCondition = format!("sId = \"{}\"", &sId);
///             let vRows = Db.select("LogIn", &sCondition);

///             assert_eq!(1, vRows.len());
///             let _Row = &vRows[0];

///             let sUserName = g_lib::Db::Get_sValueFromDbRow("sUserName", _Row).unwrap();
///             let iUserPoint = g_lib::Db::Get_iValueFromDbRow("uUserPoint", _Row).unwrap();
///             let sUserPoint = g_lib::Get_sNumInForm(iUserPoint, ",", 3);
///             let sPhoneNumber = g_lib::Db::Get_sValueFromDbRow("sId", _Row).unwrap();

///             let mut sHtml = g_lib::actix_web::Get_sHtmlFile(sFullHtmlFileName);
///             sHtml = sHtml
///                 .replace("{sUserName}", &sUserName)
///                 .replace("{sUserPoint}", &sUserPoint)
///                 .replace("{sPhoneNumber}", &sPhoneNumber);
///             let HttpResponse = g_lib::actix_web::Get_HttpResponseByHtml(sHtml);
///             return HttpResponse;
///         }
///         None => return g_lib::actix_web::Get_HttpResponse_Redirect("/login"),
///     }
/// }
/// 
/// async fn page_login(
///     session: actix_session::Session,
///     req: actix_web::HttpRequest,
/// ) -> impl actix_web::Responder {
/// 
///     println!("page_login");
///     let sFullHtmlFileName = "./static/LogIn.html";
///     let sHtml = g_lib::actix_web::Get_sHtmlFile(sFullHtmlFileName);
///     let HttpResponse = g_lib::actix_web::Get_HttpResponseByHtml(sHtml);
///     return HttpResponse;
/// }
/// 
/// async fn page_reservation(
///     session: actix_session::Session,
///     req: actix_web::HttpRequest,
/// ) -> impl actix_web::Responder {
/// 
///     println!("page_reservation");
///     let sFullHtmlFileName = "./static/UseReservation.html";
///     let HttpResponse = Load_CommonHttpResponse(sFullHtmlFileName, &session);
///     return HttpResponse;
/// }
/// 
/// async fn post_logout(
///     session: actix_session::Session,
///     form: actix_web::web::Form<LogOut>,
///     ) -> impl actix_web::Responder {
/// 
///     println!("post_logout");
///     session.remove("id");
///     return g_lib::actix_web::Get_HttpResponse_Redirect("/login");
///}

/// #[actix_web::main]
/// async fn main() {
///     println!("Start main");

///     g_lib::Set_CurDir("A:\\Rust").unwrap();

///     let WebServer = actix_web::HttpServer::new(|| {
///         actix_web::App::new()
///             .wrap(
///                 actix_session::SessionMiddleware::builder(
///                     actix_session::storage::CookieSessionStore::default(),
///                     actix_web::cookie::Key::from(&[0; 64]),
///                 )
///                 .cookie_secure(false) //Change to True When publish your Web to Public
///                 // customize session and cookie expiration
///                 .session_lifecycle(
///                     actix_session::config::PersistentSession::default()
///                         .session_ttl(actix_web::cookie::time::Duration::minutes(10)),
///                 )
///                 .build(),
///             )
///             .service(g_lib::actix_web::Get_GetService(
///                 vec!["/login", "/"],
///                 page_login,
///             ))
///             .service(g_lib::actix_web::Get_GetService(
///                 vec!["/reservation"],
///                 page_reservation,
///             ))
///     
///     })
///     .bind("127.0.0.1:8000")
///     .unwrap()
///     .run();
///     WebServer.await.unwrap();
/// }

/// ```
pub mod actix_web {
    

    pub fn Get_sHtmlFile(sFullHtmlFileName: &str) -> String {
        let sHtml = match std::fs::read_to_string(sFullHtmlFileName) {
            Ok(sHtml) => sHtml,
            Err(_) => {
                let s404HtmlFullName = crate::fs::Get_sCurDir() + "\\static\\404Error.html";
                let sHtml = std::fs::read_to_string(s404HtmlFullName).unwrap();
                sHtml
            }
        };
        return sHtml;
    }

    pub fn Get_HttpResponseByHtmlFileName(sFullHtmlFileName: &str) -> actix_web::HttpResponse {
        let sHtml = Get_sHtmlFile(sFullHtmlFileName);
        return actix_web::HttpResponse::Ok()
            .content_type("text/html")
            .body(sHtml);
    }

    pub fn Get_GetService<F, Args>(vPath: Vec<&str>, func: F) -> actix_web::Resource
    where
        F: actix_web::Handler<Args>,
        Args: actix_web::FromRequest + 'static,
        F::Output: actix_web::Responder + 'static,
    {
        return actix_web::web::resource(vPath).route(actix_web::web::get().to(func));
    }

    pub fn Get_PostService<F, Args>(vPath: Vec<&str>, func: F) -> actix_web::Resource
    where
        F: actix_web::Handler<Args>,
        Args: actix_web::FromRequest + 'static,
        F::Output: actix_web::Responder + 'static,
    {
        return actix_web::web::resource(vPath).route(actix_web::web::post().to(func));
    }

    pub fn Get_HttpResponseByHtml(sHtml: String) -> actix_web::HttpResponse {
        return actix_web::HttpResponse::Ok()
            .content_type("text/html")
            .body(sHtml);
    }

    pub fn Get_HttpResponse_Redirect(sPath: &str) -> actix_web::HttpResponse {
        return actix_web::HttpResponse::Found()
            .append_header(("Location", sPath))
            .finish();
    }
}

/// sleep in tokio async ( seconds ( float ) )
pub async fn sleep_async(fSeconds: f32) {
    tokio::time::sleep(tokio::time::Duration::from_secs_f32(fSeconds)).await;
}