#![deny(unused_must_use)]

#[macro_use]
extern crate log;
#[macro_use]
extern crate smart_default;
#[macro_use]
extern crate serde;
#[macro_use]
extern crate thiserror;
extern crate elefren;

use elefren::entities::event::Event;
use log::LevelFilter;
use elefren::entities::notification::NotificationType;
use elefren::entities::account::Account;
use elefren::status_builder::Visibility;
use elefren::{Registration, Scopes, StatusBuilder, FediClient};
use tokio_stream::{Stream, StreamExt};
use elefren::scopes;
use crate::store::{NewGroupOptions, StoreOptions};
use elefren::debug::NotificationDisplay;

mod store;
mod group_handle;
mod utils;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    env_logger::Builder::new()
        .filter_level(LevelFilter::Debug)
        .write_style(env_logger::WriteStyle::Always)
        .filter_module("rustls", LevelFilter::Warn)
        .filter_module("reqwest", LevelFilter::Warn)
        .init();

    let store = store::ConfigStore::new(StoreOptions {
        store_path: "groups.json".to_string(),
        save_pretty: true
    }).await?;

    /*
    let mut new_group = store.auth_new_group(NewGroupOptions {
        server: "https://botsin.space".to_string(),
        acct: "betty@botsin.space".to_string()
    }).await?;
    // */

    let mut groups = store.spawn_groups().await;
    //groups.push(new_group);


/*
    let mut betty = groups.remove(0);

    let notifications = betty.client.notifications().await?;
    let mut iter = notifications.items_iter();

    let mut num = 0;
    while let Some(n) = iter.next_item().await {
        debug!("A notification: {}", NotificationDisplay(&n));
        num += 1;
        if num > 10 {
            break;
        }
    }

    return Ok(());
    */

    let mut handles = vec![];

    for mut g in groups {
        handles.push(tokio::spawn(async move {
            g.run().await
        }));
    }

    futures::future::join_all(handles).await;

    /*

    let client = if let Ok(data) = elefren::helpers::toml::from_file("group-actor-data.toml") {
        FediClient::from(data)
    } else {
        register().await?
    };

    let you = client.verify_credentials().await?;
    println!("{:#?}", you);

    let mut events = client.streaming_user().await?;

    while let Some(event) = events.next().await {
        match event {
            Event::Update(status) => {
                info!("Status: {:?}", status);
            },
            Event::Notification(notification) => {
                info!("Notification: {:?}", notification.notification_type);
                debug!("{:?}", notification);

                /*
                match notification.notification_type {
                    NotificationType::Mention => {
                        if let Some(status) = notification.status {
                            if status.content.contains("/gi") {
                                debug!("GRPIGNORE!");
                            } else if status.content.contains("/gb") {
                                debug!("GROUP BOOST PREV!");
                                if let Some(id) = status.in_reply_to_id {
                                    let _ = client.reblog(&id);
                                }
                            }
                            // else if status.content.contains("/gping") {
                            //     let post = StatusBuilder::new()
                            //         .status(format!("@{} hello", &notification.account.acct))
                            //         .content_type("text/markdown")
                            //         //.in_reply_to(status.id)
                            //         .visibility(Visibility::Unlisted)
                            //         .build().expect("error build status");
                            //
                            //     let _ = client.new_status(post);
                            // }
                            else {
                                info!("BOOSTING");
                                let _ = client.reblog(&status.id);
                            }
                        }
                    }
                    NotificationType::Follow => {
                        info!("New follower!");

                        let post = StatusBuilder::new()
                            .status(format!("@{} welcome to the group!", &notification.account.acct))
                            .content_type("text/markdown")
                            .visibility(Visibility::Unlisted)
                            .build().expect("error build status");

                        let _ = client.new_status(post).await;
                    }
                    _ => {}
                }
                */
            },
            Event::Delete(id) => {
                info!("Delete: {}", id);
            },
            Event::FiltersChanged => {
                info!("FiltersChanged");
                // ???
            },
        }
    }

    */

    println!("Main loop ended!");

    Ok(())
}

/*
async fn register() -> anyhow::Result<FediClient> {
    let registration = Registration::new("https://piggo.space")
        .client_name("group-actor")
        .force_login(true)
        .scopes(
            Scopes::read(scopes::Read::Accounts)
                | Scopes::read(scopes::Read::Notifications)
                | Scopes::read(scopes::Read::Statuses)
                | Scopes::read(scopes::Read::Follows)
                | Scopes::write(scopes::Write::Statuses)
                | Scopes::write(scopes::Write::Media)
        )
        .build().await?;
    let client = elefren::helpers::cli::authenticate(registration).await?;
    elefren::helpers::toml::to_file(&*client, "group-actor-data.toml")?;
    Ok(client)
}
*/