#[macro_use]
extern crate log;
#[macro_use]
extern crate failure;
#[macro_use]
extern crate smart_default;
#[macro_use]
extern crate serde;
#[macro_use]
use elefren::{
    helpers::cli,
    prelude::*,
    entities::prelude::*,
    http_send::HttpSender,
};

use failure::Fallible;
use crate::bootstrap::Config;
use crate::store::Store;

use native_tls::TlsConnector;
use std::io::{Read, Write};
use std::net::TcpStream;
use websocket::OwnedMessage;

mod bootstrap;
mod store;

type EleRegistratered = elefren::registration::Registered<HttpSender>;

/// Wrapper for the long tuple with Registration state
#[derive(Serialize,Deserialize,Debug)]
struct ElefrenRegistration {
    parts: (String, String, String, String, Scopes, bool),
}

const KEY_OAUTH_REGISTRATION: &str = "elefren.registration";
const KEY_OAUTH_SESSION: &str = "elefren.session";

fn main() {
    let config : Config = bootstrap::init().expect("error init config");

    debug!("Loaded config: {:#?}", config);

    let mut store = Store::from_file(&config.store);
    store.set_autosave(true);

    let registered = register(&mut store, &config);

    let client = open_session(&mut store, registered);

    debug!("Listening to events");

    let connector = TlsConnector::new().unwrap();

    use websocket::ClientBuilder;

    let url = format!("wss://{host}/api/v1/streaming/?stream=user&access_token={token}", host=config.instance, token=client.data.token);
    debug!("WS url = {}", &url);
    let mut client = ClientBuilder::new(&url)
        .expect("Error create ClientBuilder")
        .connect_secure(Some(connector))
        .expect("Error connect to wss");

    for m in client.incoming_messages() {
        match m {
            Ok(OwnedMessage::Text(text)) => {
                debug!("Got msg: {}", text);
            },
            Ok(OwnedMessage::Close(text)) => {
                debug!("Close");
                break;
            },
            Ok(any) => {
                debug!("Unhandled msg: {:?}", any);
            }
            Err(e) => {
                error!("{}", e);
                break;
            },
        }
    }
    info!("Exit.");
}

fn register(store : &mut Store, config : &Config) -> EleRegistratered {
    match store.get::<ElefrenRegistration>(KEY_OAUTH_REGISTRATION) {
        Some(reg) => {
            info!("Loaded registration from store");

            EleRegistratered::from_parts(
                // this sucks
                &reg.parts.0, &reg.parts.1, &reg.parts.2, &reg.parts.3, reg.parts.4, reg.parts.5
            )
        }
        None => {
            info!("Creating a new registration");

            let registered = Registration::new(&format!("https://{}", config.instance))
                .client_name("manabu")
                .build().expect("error register");
            store.put(KEY_OAUTH_REGISTRATION, ElefrenRegistration { parts : registered.clone().into_parts() });
            registered
        }
    }
}

fn open_session(store : &mut Store, registered: EleRegistratered) -> Mastodon<HttpSender> {
    match store.get::<elefren::Data>(KEY_OAUTH_SESSION) {
        Some(data) => {
            info!("Reusing saved authorization.");

            let cli = Mastodon::from(data);
            // TODO check if the session is live, somehow
            cli
        }
        None => {
            info!("Creating new authorization.");

            let cli = cli::authenticate(registered).expect("error auth");
            store.put(KEY_OAUTH_SESSION, cli.data.clone());
            cli
        }
    }
}