#[derive(Debug)]
pub enum LoggerType {
    Stdout,
    Discord,
}

    match logger.logger_type.to_lowercase().as_str() {
        "stdout" => {

    match logger.logger_type {
        LoggerType::Stdout => {

        "discord" => {

        LoggerType::Discord => {

        _ => Err("* Unkown logger."),

use crate::logger::LoggerType;

    pub fn new(software: SNS, instance_url: String, token: String) -> Self {
        Config {

    pub fn new(
        software_name: String,
        instance_url: String,
        token: String,
    ) -> Result<Config, String> {
        let software = match software_name.to_lowercase().as_str() {
            "pleroma" => SNS::Pleroma,
            "mastodon" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Mastodon
            }
            "firefish" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Firefish
            }
            "friendica" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Friendica
            }
            unsupported => {
                return Err(format!("* Software {} is unknown!", unsupported));
            }
        };
        if token.is_empty() {
            eprintln!("* ACCESS_TOKEN is not set. Generating...");
            let _ = crate::streamer::oath(software, instance_url.as_str());
            return Err(String::new());
        }
        Ok(Config {

        }

        })

    pub logger_type: String,

    pub logger_type: LoggerType,

    pub fn new(logger_type: String, logger_url: Option<String>) -> Self {

    pub fn new(logger_name: String, logger_url: Option<String>) -> Logger {
        let logger_type = match logger_name.to_lowercase().as_str() {
            "stdout" => LoggerType::Stdout,
            "discord" => LoggerType::Discord,
            _ => {
                eprintln!("* LOGGER is not set. Falling back to stdout.");
                LoggerType::Stdout
            }
        };

    let software = match dotenvy::var("SOFTWARE") {
        Err(_) => {

    // Parse CONFIG
    let Ok(software) = dotenvy::var("SOFTWARE") else {

        }
        Ok(software) => match software.to_lowercase().as_str() {
            "pleroma" => SNS::Pleroma,
            "mastodon" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Mastodon
            }
            "firefish" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Firefish
            }
            "friendica" => {
                eprintln!("* Software other than Pleroma is not tested!");
                SNS::Friendica
            }
            unsupported => {
                return Err(format!("* Software {} is unknown!", unsupported));
            }
        },

    };
    let Ok(token) = dotenvy::var("ACCESS_TOKEN") else {
        eprintln!("* ACCESS_TOKEN is not set. Generating...");
        crate::streamer::oath(software, instance_url.as_str()).await;
        return Err(String::new());
    };
    let logging_method = match dotenvy::var("LOGGER") {
        Ok(l) => l,
        Err(_) => {
            eprintln!("* LOGGER is not set. Falling back to stdout.");
            "stdout".to_string()
        }

    let token = dotenvy::var("ACCESS_TOKEN").unwrap_or_default();

    // Parse LOGGER
    let logging_method = dotenvy::var("LOGGER").unwrap_or_default();

    // Parse FILTER
    // TODO?: Parse in new() function instead of here?

    let Ok(filter) = Filter::new(

    // Setting
    let config = Config::new(software, instance_url, token)?;
    let _config = CONFIG.get_or_init(|| config);
    let filter = Filter::new(

    ) else {
        return Err("* invalid regex syntax!".to_string());
    };
    let _config = CONFIG.get_or_init(|| Config::new(software, instance_url, token));

    )?;

    let _logger = LOGGER.get_or_init(|| Logger::new(logging_method, logging_url));

    let logger = Logger::new(logging_method, logging_url);
    let _logger = LOGGER.get_or_init(|| logger);