#[derive(Clone, Debug)]
pub enum ExtraTimeline {
    Public,
    Local,
}

    url: &str,
    token: Option<String>,

    url: String,
    token: String,

    tl: Option<ExtraTimeline>,

    let client = generator(sns, format!("https://{}", url), token.clone(), None);

    let client = generator(sns, format!("https://{}", url), Some(token), None);

    let streaming = if token.is_some() {
        client.user_streaming(format!("wss://{}", url))
    } else {
        client.public_streaming(format!("wss://{}", url))

    let streaming = match tl {
        Some(ExtraTimeline::Public) => client.public_streaming(format!("wss://{}", url)),
        Some(ExtraTimeline::Local) => client.local_streaming(format!("wss://{}", url)),
        None => client.user_streaming(format!("wss://{}", url)),

                if crate::logger::egosa(mes.clone(), filter.clone()) {

                if crate::logger::egosa(mes.clone(), filter.clone(), tl.clone()) {

use streamer::ExtraTimeline;

        },
    };
    let extra_tl = match dotenvy::var("EXTRA_TIMELINE") {
        Err(_) => None,
        Ok(tl_type) => match tl_type.to_lowercase().as_str() {
            "public" => Some(ExtraTimeline::Public),
            "local" => Some(ExtraTimeline::Local),
            _ => panic!("* EXTRA_TIMELINE is invalid. Valid values are Public or Local."),

        return

        return;

        Ok(token) => {
            if token.is_empty() {
                None
            } else {
                Some(token)
            }
        }

        Ok(token) => token,

    let filter = logger::Filter::new(include, exclude, user_include, user_exclude);

    let filter = logger::Filter::new(
        extra_tl.clone(),
        include,
        exclude,
        user_include,
        user_exclude,
    );

    streamer::streaming(
        sns,
        url.as_str(),
        token,
        logging_method,
        logging_url,
        filter,
    )
    .await;

    // Extra Timeline
    let extra_tl_handle = if let Some(tl) = extra_tl {
        tokio::spawn(streamer::streaming(
            sns.clone(),
            url.clone(),
            token.clone(),
            logging_method.clone(),
            logging_url.clone(),
            filter.clone(),
            Some(tl),
        ))
    } else {
        tokio::spawn(async {})
    };
    // Home Timeline
    let home_tl_handle = tokio::spawn(streamer::streaming(
        sns.clone(),
        url.clone(),
        token.clone(),
        logging_method.clone(),
        logging_url.clone(),
        filter.clone(),
        None,
    ));
    let _ = tokio::join!(home_tl_handle, extra_tl_handle);

use crate::streamer::ExtraTimeline;

    extra_tl: Option<ExtraTimeline>,

        extra_tl: Option<ExtraTimeline>,

            extra_tl,

pub fn egosa(message: megalodon::entities::status::Status, settings: Filter) -> bool {

pub fn egosa(
    message: megalodon::entities::status::Status,
    settings: Filter,
    tl: Option<ExtraTimeline>,
) -> bool {
    // Remove dupicates from Home Timeline
    if tl.is_none()
        && matches!(settings.extra_tl, Some(ExtraTimeline::Public))
        && message.visibility == megalodon::entities::StatusVisibility::Public
    {
        return false;
    }
    if tl.is_none()
        && matches!(settings.extra_tl, Some(ExtraTimeline::Local))
        && !message.account.acct.contains("@")
        && message.visibility == megalodon::entities::StatusVisibility::Public
    {
        return false;
    }

EXTRA_TIMELINE=追加で監視対象にするタイムライン(PublicまたはLocal)

`EXTRA_TIMELINE`の挙動について

`ACCESS_TOKEN`は状態によって挙動が異なります。

1. 未設定の場合、HTLのみを監視します。

1. 設定されていない場合  
アクセストークンの生成処理が走ります。

2. Publicが指定されている場合、HTLに加えてGTL(「すべてのネットワーク」(Pleroma)、「連合タイムライン」(Mastodon))も監視します。(GTLが使用できるサーバーのみ)

2. 設定されているが空の場合(`ACCESS_TOKEN=`の状態)  
監視対象がGTL(「すべてのネットワーク」(Pleroma)、「連合タイムライン」(Mastodon))になります。

3. Localが指定されている場合、HTLに加えてLTL(「公開タイムライン」(Pleroma))も監視します。(LTLが使用できるサーバーのみ)

3. 設定されていて、中身が存在する場合(`ACCESS_TOKEN=xxxxxxxxxx`の状態)  
監視対象がHTLになります。