//use super::{auth, handlers};
use log::{debug, error, info};
use serde_json::Value as JsonValue;
use tdlib_autogen::Update;

#[derive(Clone)]
pub struct UpdateHandler(pub crate::airdata::AsyncData);

impl tdlib_rs::update::Handler for UpdateHandler {
    fn handle_json(
        &self,
        client: tdlib_rs::client::Client,
        req: JsonValue,
    ) -> futures::future::BoxFuture<'static, ()> {
        //let data = self.0.clone();
        Box::pin(async move {
            let update: Update = serde_json::from_value(req.clone()).map_err(|err| error!("going to panic: invalid update: {:?} {:?}", req, err)).expect("invalid update");
            match update {
                Update::UpdateAuthorizationState(state) => {
                    if let Err(e) = crate::auth::continue_auth(&client, state.authorization_state).await {
                        error!("auth failed: {}", e);
                    }
                }
                Update::UpdateOption(upd) => {
                    debug!("update option: '{}'", upd.name);
                }
                /*
                UpdateMessageContent(update) => {
                    handlers::update_message_content(data, update).await;
                }
                UpdateNewMessage(update) => {
                    handlers::update_new_message(&client, data.clone(), update).await;
                }*/
                Update::UpdateConnectionState(upd) => {
                    info!("connection: {:?}", upd.state);
                }
                Update::UpdateUser(update) => {
                    //let id = update.user.id;
                    let name = format!("{}{}", update.user.first_name, update.user.last_name);
                    info!("update user: {}, status: {}", name, update.user.status);
                    //let _ = data.insert_user(update.user).await;
                    //info!("update user {}", data.get_username_lossy(id).await);
                }
                Update::UpdateUserStatus(update) => {
                    info!(
                    "{} is now {}",
                    //data.get_username_lossy(update.user_id).await,
                    update.user_id, update.status
                );
                }/*
                UpdateNewChat(update) => {
                let chat = update.chat;
                info!("new chat: {}", chat.title);
                let _ = data.insert_chat(chat).await;
                }
                UpdateDeleteMessages(update) => {
                handlers::update_delete_messages(data, update).await;
                }
                UpdateDiceEmojis(_)
                | UpdateSelectedBackground(_)
                | UpdateHavePendingNotifications(_)
                | UpdateUnreadChatCount(_)
                | UpdateChatLastMessage(_)
                | UpdateChatChatList(_)
                | UpdateChatReadInbox(_)
                | UpdateScopeNotificationSettings(_)
                | UpdateUserFullInfo(_) => {}*/
                /*UpdateFile(update) => {
                    trace!(
                        "Update file {}: progress: {}/{}",
                        update.file.id,
                        update.file.local.downloaded_size,
                        update.file.size
                    );
                }*/
                _ => {} //debug!("unknown update: {:?}", update),
            }
        })
    }
}