extern crate actix;
extern crate env_logger;
extern crate futures;
extern crate hyper;
extern crate tokio;
extern crate tokio_threadpool;
extern crate url;

#[macro_use]
extern crate json;
extern crate rust_tdlib;

// use json::object;
use actix::prelude::*;
use json::*;
use rust_tdlib::Tdlib;
use std::io;
use std::sync::atomic::{AtomicPtr, Ordering};
use std::{thread, time};

use futures::sync::mpsc;

use tokio::prelude::*;

fn get_authorized_client(client: &Tdlib, app_id: &str, app_hash: &str, phone: &str) -> Result<()> {
    // let client = Tdlib::new();

    println!("client: {:?}", client);

    loop {
        let resp = client.receive(2.0);

        // let mut auth_state = AuthState::Initial;

        match resp {
            Some(r) => {
                let event = json::parse(&r).unwrap();

                // println!("json: {}", event);
                // println!("event type: {}", event["@type"]);

                if let JsonValue::Short(ref t) = event["@type"] {
                    match t.as_str() {
                        "updateAuthorizationState" => {
                            let authorization_state = &event["authorization_state"];

                            // println!("authorization_state: {}", authorization_state);

                            match authorization_state["@type"] {
                                JsonValue::String(ref s)
                                    if s == "authorizationStateWaitTdlibParameters" =>
                                {
                                    // auth_state = AuthState::AuthorizationStateWaitTdlibParameters;

                                    let req = json::stringify(config(app_id, app_hash));

                                    client.send(&req[..]);
                                }
                                JsonValue::String(ref s)
                                    if s == "authorizationStateWaitEncryptionKey" =>
                                {
                                    // auth_state = AuthState::AuthorizationStateWaitEncryptionKey;
                                    let req = json::stringify(
                                        object!{"@type" => "checkDatabaseEncryptionKey"},
                                    );
                                    client.send(&req[..]);
                                }
                                JsonValue::String(ref s)
                                    if s == "authorizationStateWaitPhoneNumber" =>
                                {
                                    // auth_state = AuthState::AuthorizationStateWaitPhoneNumber;
                                    let req = json::stringify(object!{
                                    "@type" => "setAuthenticationPhoneNumber",
                                        "phone_number" => phone,
                                        "allow_flash_call" => false,
                                        "is_current_phone_number" => false
                                    });
                                    client.send(&req[..]);
                                }
                                JsonValue::Short(ref s) if s == "authorizationStateWaitCode" => {
                                    // auth_state = AuthState::AuthorizationStateWaitCode;

                                    if let Ok(code) = read_user_input() {
                                        let req = json::stringify(object!{
                                            "@type" => "checkAuthenticationCode",
                                            "code" => code,
                                        });
                                        client.send(&req[..]);
                                    } else {
                                        println!("wrong input",)
                                    }
                                }
                                JsonValue::Short(ref s)
                                    if s == "authorizationStateWaitPassword" =>
                                {
                                    // auth_state = AuthState::AuthorizationStateWaitCode;

                                    if let Ok(password) = read_user_input() {
                                        let req = json::stringify(object!{
                                            "@type" => "checkAuthenticationPassword",
                                            "password" => password,
                                        });
                                        client.send(&req[..]);
                                    } else {
                                        println!("wrong input",)
                                    }
                                }
                                JsonValue::Short(ref s) if s == "authorizationStateReady" => {
                                    println!("READY!!",);

                                    return Ok(());
                                }
                                // JsonValue::String(ref s) => println!("other {}", s),
                                _ => println!("other state: {}", authorization_state["@type"]),
                            }
                        }

                        "error" => println!("ERROR: {}", event["message"]),
                        "ok" => println!("ok: {}", r),
                        // JsonValue::Short(ref t) => println!("other {}", t),
                        ref _t => (),
                    }
                }
            }
            None => println!("Empty response"),
        }
    }
    // return Err;
}

pub struct TdlibBox {
    client: Tdlib,
}

unsafe impl Send for TdlibBox {}

fn get_messages_stream(
    client: Tdlib,
) -> (
    std::thread::JoinHandle<()>,
    futures::sync::mpsc::Receiver<String>,
) {
    let bx = TdlibBox { client };
    let (mut tx, rx) = mpsc::channel(1);

    let th = thread::spawn(move || loop {
        if let Some(msg) = bx.client.receive(2.0) {
            match tx.send(msg).wait() {
                Ok(_tx) => {
                    tx = _tx;
                }
                Err(v) => {
                    panic!("Wut? {}", v);
                }
            }
        }
    });

    (th, rx)
}

#[derive(Message)]
struct IncomingMessage {
    msg: std::string::String,
}

struct ReceiverActor;

impl StreamHandler<IncomingMessage, io::Error> for ReceiverActor {
    fn handle(&mut self, item: IncomingMessage, ctx: &mut Context<ReceiverActor>) {
        println!("msg: {}", item.msg);
    }

    fn finished(&mut self, ctx: &mut Self::Context) {
        println!("finished");
    }
}

impl Actor for ReceiverActor {
    type Context = Context<Self>;

    // fn started(&mut self, ctx: &mut Context<Self>) {
    //     // add stream
    //     // Self::add_stream(once::<IncomingMessage, io::Error>(Ok(IncomingMessage)), ctx);
    // }
}

impl Handler<IncomingMessage> for ReceiverActor {
    type Result = ();

    fn handle(&mut self, msg: IncomingMessage, _: &mut Context<Self>) {
        let event = json::parse(&msg.msg).unwrap();

        if let JsonValue::Short(ref t) = event["@type"] {
            match t.as_str() {
                "updateNewChat" => {
                    // println!(
                    //     "json: {} {} {}",
                    //     event["chat"]["type"], event["chat"]["id"], event["chat"]["title"]
                    // );
                    if(event["chat"]["title"] == "Rust Beginners"){
                        println!("Found Rust Beginners: {}", event["chat"]["type"]["supergroup_id"])
                    }
                }
                // "chats" => println!("chat: {}", event),
                // "supergroup" => println!("supergroup: {}", event),
                "error" => println!("error: {}", event),
                _ => (),
            }
        }
    }
}

struct SenderActor {
    client_ptr: std::sync::atomic::AtomicPtr<Tdlib>,
}

#[derive(Message)]
struct OutgoingMessage {
    msg: std::string::String,
}
impl Actor for SenderActor {
    type Context = Context<Self>;
}

impl Handler<OutgoingMessage> for SenderActor {
    type Result = ();

    fn handle(&mut self, msg: OutgoingMessage, ctx: &mut Context<Self>) {
        println!("will send: {}", msg.msg);

        unsafe {
            let client = &*self.client_ptr.load(Ordering::Relaxed);
            client.send(msg.msg.as_str());
        }

        // ctx.run_later(time::Duration::from_secs(5), move |act, _ctx| unsafe {
        //     let client = &*act.client_ptr.load(Ordering::Relaxed);
        //     client.send(msg.msg.as_str());
        // });
    }
}

fn main() {
    env_logger::init();
    Tdlib::set_log_verbosity_level(1);

    let app_id = "";
    let app_hash = "";
    let phone = "+";

    let system = actix::System::new("test");
    let mut client = Tdlib::new();

    if let Ok(()) = get_authorized_client(&client, app_id, app_hash, phone) {
        println!("got it");

        let client_ptr = AtomicPtr::new(&mut client);
        let (th, msg_stream) = get_messages_stream(client);

        actix::System::run(|| {
            ReceiverActor::create(|ctx| {
                ctx.add_message_stream(msg_stream.map(|msg| IncomingMessage { msg }));
                ReceiverActor {}
            });

            let supergroup_id: i32 = 1241722061;
            let sender = SenderActor::create(|ctx| SenderActor { client_ptr });

            // let req = json::stringify(object!{
            // "@type" => "getSupergroup",
            // "supergroup_id" => chat_id,
            // });

            sender.do_send(OutgoingMessage {
                msg: json::stringify(object!{
                "@type" => "getChats",
                "limit" => 100,
                }),
            });

            sender.do_send(OutgoingMessage {
                msg: json::stringify(object!{
                "@type" => "getSupergroup",
                "supergroup_id" => supergroup_id,
                }),
            });
        });
    } else {
        println!("failed");
    }
}

fn read_user_input() -> io::Result<String> {
    let mut input = String::new();
    print!("code: ",);

    io::stdin().read_line(&mut input)?;
    Ok(input.trim().to_string())
}

fn config(api_id: &str, api_hash: &str) -> json::JsonValue {
    let cfg = object!{
        "@type" => "tdlibParameters",
        "api_hash" => api_hash,
        "api_id" => api_id,
        "application_version" => "tdlib",
        "database_directory" => "tdlib",
        "device_model" => "My PC",
        "enable_storage_optimizer" => true,
        "files_directory" => json::Null,
        "ignore_file_names" => true,
        "system_language_code" => "en",
        "system_version" => "Unknown",
        "use_chat_info_database" => true,
        "use_file_database" => true,
        "use_secret_chats" => false,
        "use_test_dc" => false
    };

    object!{
        "@type" => "setTdlibParameters",
        "parameters" => cfg
    }
}