/**
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 */

#include <glib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>

// Libpurple Plugin Includes
#include "notify.h"
#include "plugin.h"
#include "version.h"
#include "account.h"
#include "accountopt.h"
#include "blist.h"
#include "cmds.h"
#include "conversation.h"
#include "connection.h"
#include "debug.h"
#include "privacy.h"
#include "prpl.h"
#include "roomlist.h"
#include "status.h"
#include "util.h"
#include "prpl.h"
#include "prefs.h"
#include "util.h"
#include "eventloop.h"
#include "request.h"

// telegram-purple includes
#include "telegram.h"
#include "telegram-purple.h"
#include "structures.h"
#include "net.h"

#define CONFIG_DIR ".telegram-purple"
#define BUDDYNAME_MAX_LENGTH 128

static PurplePlugin *_telegram_protocol = NULL;
PurpleGroup *tggroup;

void tgprpl_login_on_connected();

void message_allocated_handler (struct telegram *instance, struct message *M);
void peer_allocated_handler (struct telegram *instance, void *user);
void user_info_received_handler (struct telegram *instance, struct tgl_user *user, int showInfo);
void download_finished_handler (struct telegram *instance, struct download *D);
void telegram_on_phone_registration (struct telegram *instance);
void telegram_on_client_registration (struct telegram *instance);
void on_new_user_status(struct telegram *instance, void *user);
void on_user_typing(struct telegram *instance, void *user);
void on_chat_joined (struct telegram *instance, peer_id_t chatid);
static PurpleChat *blist_find_chat_by_id(PurpleConnection *gc, const char *id);
static void tgprpl_has_output(void *handle);

static const char *chat_id_get_comp_val (PurpleConnection *gc, int id, char *value)
{
    gchar *name = g_strdup_printf ("%d", id);
    PurpleChat *ch = blist_find_chat_by_id(gc, name);
    g_free (name);
    GHashTable *table = purple_chat_get_components(ch);
    return g_hash_table_lookup(table, value);
}

/**
 * Assure that the given chat is opened
 */
static PurpleConversation *chat_show (PurpleConnection *gc, int id)
{
    debug ("show chat");
    telegram_conn *conn = purple_connection_get_protocol_data(gc);

    PurpleConversation *convo = purple_find_chat(gc, id);
    if (convo) {
        if (purple_conv_chat_has_left(PURPLE_CONV_CHAT(convo)))
        {
            serv_got_joined_chat(gc, id, chat_id_get_comp_val(gc, id, "subject"));
        }
    } else {
        gchar *name = g_strdup_printf ("%d", id);
        if (g_hash_table_contains (conn->joining_chats, name)) {
            // already joining this chat
        } else {
            // mark chat as already joining
            g_hash_table_insert(conn->joining_chats, name, 0);

            // join chat first
            do_get_chat_info (conn->tg, MK_CHAT(id));
            telegram_flush (conn->tg);
        }
        g_free(name);
    }
    return convo;
}

static PurpleChat *get_chat_by_id (PurpleConnection *gc, int id)
{
    gchar *name = g_strdup_printf ("%d", id);
    PurpleChat *chat = blist_find_chat_by_id (gc, name);
    g_free (name);
    return chat;
}

/**
 * Returns the base icon name for the given buddy and account.
 * If buddy is NULL and the account is non-NULL, it will return the
 * name to use for the account's icon. If both are NULL, it will
 * return the name to use for the protocol's icon.
 *
 * This must be implemented.
 */
static const char *tgprpl_list_icon(PurpleAccount * acct, PurpleBuddy * buddy)
{
    return "telegram";
}

static telegram_conn *get_conn_from_buddy (PurpleBuddy *buddy)
{
     telegram_conn *c = purple_connection_get_protocol_data (
        purple_account_get_connection (purple_buddy_get_account (buddy)));
     return c;
}

/**
 * Allows the prpl to add text to a buddy's tooltip.
 */
static void tgprpl_tooltip_text(PurpleBuddy * buddy, PurpleNotifyUserInfo * info, gboolean full)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_tooltip_text()\n");

    debug ("purple_buddy_get_protocol_data: %s\n", buddy->name);
	peer_id_t *peer = purple_buddy_get_protocol_data(buddy);
	if(peer == NULL)
	{
		purple_notify_user_info_add_pair_plaintext(info, "Status", "Offline");
		return;
	}
	peer_t *P = user_chat_get (get_conn_from_buddy(buddy)->tg->bl, *peer);
	purple_notify_user_info_add_pair_plaintext(info, "Status", P->user.status.online == 1 ? "Online" : "Offline");
	struct tm *tm = localtime ((void *)&P->user.status.when);
	char buffer [21];
	sprintf  (buffer, "[%04d/%02d/%02d %02d:%02d:%02d]", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
	purple_notify_user_info_add_pair_plaintext(info, "Last seen: ", buffer);
}


/*  OUTPUT  */

/**
 * Libpurple announced that new output should be written to the write-handle
 */
static void tgprpl_output_cb(gpointer data, gint source, PurpleInputCondition cond)
{
    mtproto_handle *conn = data;
    if (!conn->mtp) {
        debug ("connection no longer existing, do nothing. \n");
        return;
    }
    if (mtp_write_output(conn->mtp) == 0) {
        debug("no output, removing output...\n");
        purple_input_remove(conn->wh);
        conn->wh = 0;
    }
}

/**
 * Telegram announced new output in its buffers
 */
static void tgprpl_has_output(void *handle)
{
    debug("tgprpl_has_output(%p)\n", handle);
    mtproto_handle *conn = handle;
    if (! conn->wh) {
        conn->wh = purple_input_add(conn->fd, PURPLE_INPUT_WRITE, tgprpl_output_cb, handle);
    }
}

/*
 * Libpurple announced that new input should be read from the read-handle
 */
static void tgprpl_input_cb(gpointer data, gint source, PurpleInputCondition cond)
{
    mtproto_handle *conn = data;
    debug("tgprpl_input_cb()\n");
    if (!conn->fd) {
        debug("conn for handle no longer existing, not reading input\n");
        return;
    }
    mtp_read_input(conn->mtp);

    if (conn->mtp) {
        // processing of the answer may have inserted new queries
        telegram_flush (conn->mtp->instance);

        // free all mtproto_connections that may have errored
        mtproto_free_closed(conn->mtp->instance, 0);
    }
}

/**
 * Telegram requests a new connectino to our configured proxy
 */
void telegram_on_proxy_request(struct telegram *tg, struct proxy_request *req)
{
    telegram_conn *conn = tg->extra;
    req->extra = tg;
    purple_proxy_connect (conn->gc, conn->pa, req->DC->ip, req->DC->port, 
        tgprpl_login_on_connected, req);
}

/**
 * Handle a proxy-close of telegram
 * 
 * Remove all open inputs added to purple
 */
void telegram_on_proxy_close(void *handle)
{
    mtproto_handle *conn = handle; 
    debug ("Closing proxy-handles - fd: %d, write-handle: %d, read-handle: %d\n", 
        conn->fd, conn->wh, conn->rh);
    if (conn->rh) {
        purple_input_remove (conn->rh);
    }
    if (conn->wh) {
        purple_input_remove (conn->wh);
    }
    conn->rh = conn->wh = 0;
    conn->mtp = 0;
    tfree (conn, sizeof(mtproto_handle));
}

void phone_registration_entered (PurpleConnection* gc, PurpleRequestFields* fields)
{
    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    const char* first = purple_request_fields_get_string(fields, "first_name");
    const char* last = purple_request_fields_get_string(fields, "last_name");
    const char* code = purple_request_fields_get_string(fields, "code");
    if (!first || !last || !code) {
        telegram_on_phone_registration (conn->tg);
        return;
    }

    do_send_code_result_auth (conn->tg, code, first, last);
    telegram_flush (conn->tg);
}


void telegram_on_phone_registration (struct telegram *instance)
{
    telegram_conn *conn = instance->extra;

    purple_debug_info(PLUGIN_ID, "Phone is not registered, registering...\n");

    PurpleRequestFields* fields = purple_request_fields_new();
    PurpleRequestField* field = 0;

    PurpleRequestFieldGroup* group = purple_request_field_group_new("Registration");
    field = purple_request_field_string_new("first_name", "First Name", "", 0);
    purple_request_field_group_add_field(group, field);
    field = purple_request_field_string_new("last_name", "Last Name", "", 0);
    purple_request_field_group_add_field(group, field);
    purple_request_fields_add_group(fields, group);

    group = purple_request_field_group_new("Authorization");
    field = purple_request_field_string_new("code", "Telegram Code", "", 0);
    purple_request_field_group_add_field(group, field);
    purple_request_fields_add_group(fields, group);

    purple_request_fields(conn->gc, "Register", "Please register your phone number.", NULL, fields, "Ok",
         G_CALLBACK( phone_registration_entered ), "Cancel", NULL, conn->pa, NULL, NULL, conn->gc);
}

void client_registration_entered (gpointer data, const gchar *code)
{
    struct telegram *tg = data;
    do_send_code_result (tg, code);
    telegram_flush (tg);
}

void client_registration_canceled (gpointer data)
{
    struct telegram *tg = data;
    telegram_conn *conn = tg->extra;
    
    purple_connection_error_reason(conn->gc,
        PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED, "registration canceled");
}

gboolean queries_timerfunc (gpointer data) {
   debug ("queries_timerfunc()\n");
   telegram_conn *conn = data;
   work_timers (conn->tg);
   telegram_flush (conn->tg);

   if (conn->updated) {
       debug ("State updated, storing current session...\n");
       conn->updated = 0;
       telegram_store_session (conn->tg);
   }
   return 1;
}

void telegram_on_client_registration (struct telegram *instance)
{
    purple_debug_info(PLUGIN_ID, "Client is not registered, registering...\n");
    telegram_conn *conn = instance->extra;

    purple_request_input(
        conn->gc, // handle   (the PurpleAccount) 
        "Telegram Code",     // title 
        "Enter Telegram Code", // primary 
        "Telegram wants to verify your identity, please enter the code, that you have received via SMS.", // secondary 
        NULL,     // default_value 
        0,    // multiline     
        0,    // masked         
        "code",   // hint 
        "OK",     // ok_text      
        G_CALLBACK(client_registration_entered), // ok_cb 
        "Cancel", // cancel_text 
        G_CALLBACK(client_registration_canceled), // cancel_cb 
        conn->pa, // account    
        NULL,     // who 
        NULL,     // conv  
        conn->tg  // user_data      
    );
}

void telegram_on_ready (struct telegram *instance)
{
     purple_debug_info(PLUGIN_ID, "telegram_on_ready().\n");
     telegram_conn *conn = instance->extra;
     purple_connection_set_state(conn->gc, PURPLE_CONNECTED);
     purple_connection_set_display_name(conn->gc, purple_account_get_username(conn->pa));
     purple_blist_add_account(conn->pa);
     tggroup = purple_find_group("Telegram");
     if (tggroup == NULL) {
         purple_debug_info (PLUGIN_ID, "PurpleGroup = NULL, creating");
         tggroup = purple_group_new ("Telegram");
         purple_blist_add_group (tggroup, NULL);
     }
     do_get_difference(instance, 0);
     do_get_dialog_list(instance);
     do_update_contact_list(instance);
     telegram_flush (conn->tg);
     conn->timer = purple_timeout_add (5000, queries_timerfunc, conn);
}

/**
 * A proxy connection was created by purple
 *
 * Use the connection to create a new mtproto-connection and create a handle,
 * with additional info for libpurple associated with the new connection
 */
void tgprpl_login_on_connected(gpointer *data, gint fd, const gchar *error_message)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_login_on_connected()\n");
    struct proxy_request *req = (struct proxy_request*)data;
    struct telegram *tg = req->tg;

    if (fd == -1) {
        failure("purple_proxy_connect failed: %s\n", error_message);
        telegram_destroy(tg);
        return;
    }

    mtproto_handle *conn = talloc(sizeof (mtproto_handle));
    conn->fd = fd;
    conn->wh = purple_input_add(fd, PURPLE_INPUT_WRITE, tgprpl_output_cb, conn);
    conn->rh = purple_input_add(fd, PURPLE_INPUT_READ, tgprpl_input_cb, conn);
    conn->mtp = telegram_add_proxy(tg, req, fd, conn);
}

void telegram_on_error (struct telegram *tg, const char *err)
{
     debug ("telegram_on_error()\n");
     telegram_conn *conn = tg->extra;
    
    purple_connection_error_reason(conn->gc, PURPLE_CONNECTION_ERROR_OTHER_ERROR,
           err);
}

void on_update_user_name (struct telegram *tg, peer_t *user)
{
    debug("on_update_user_name(id=%d, type=%d)\n", user->id.id, user->id.type);
    // Update user name
}

void on_update_user_photo (struct telegram *tg, peer_t *user)
{
     debug("on_update_user_photo(id=%d, type=%d)\n", user->id.id, user->id.type);
     // Update user photo
}

void on_update_user_registered (struct telegram *tg, peer_t *user)
{
     debug("on_update_user_name(id=%d, type=%d)\n", user->id.id, user->id.type);
     // Notify about a new user
}

void on_update_chat_participants (struct telegram *tg, peer_t *chat)
{
     debug("on_update_chat_participants(chat.id=%d)\n", chat->id.id);
     // Refresh chat participants
}

void on_update_chat_add_participant (struct telegram *tg, peer_t *chat, peer_id_t user, peer_id_t inviter)
{
    debug("on_update_chat_add_participant(chat.id=%d)\n", chat->id.id);
    // Add chat participant
}

void on_update_chat_del_participant (struct telegram *tg, peer_t *chat, peer_id_t user, void *_ UU)
{
    debug("on_update_chat_del_participant(chat.id=%d)\n", chat->id.id);
    // Remove chat participant
}

void on_update_chat_user_typing (struct telegram *tg, peer_t *chat, peer_t *user, void *_ UU)
{
    debug("on_update_chat_user_typing(chat.id=%d, user.id=%d)\n", chat->id.id, user->id.id);
    // Set or unset user in chat typing
}

void on_update_auth_new (struct telegram *tg, char *location)
{
    debug("un_update_auth_new(location=%s)\n", location);
    // Info: new device authenticated for this phone number
}

struct telegram_config tgconf = {
    NULL,
    tgprpl_has_output, // on output
    telegram_on_proxy_request,
    telegram_on_proxy_close,
    telegram_on_phone_registration,
    telegram_on_client_registration,
    telegram_on_ready,
    telegram_on_error,

    // user
    peer_allocated_handler,
    on_new_user_status,
    on_user_typing,
    on_update_user_name,
    on_update_user_photo,
    on_update_user_registered,
    
    // chat
    on_update_chat_participants,
    on_update_chat_add_participant,
    on_update_chat_del_participant,
    on_update_chat_user_typing,

    // misc
    on_update_auth_new,
    message_allocated_handler,
    download_finished_handler,
    user_info_received_handler,
    on_chat_joined
};


/**
 * This must be implemented.
 */
static void tgprpl_login(PurpleAccount * acct)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_login()\n");
    PurpleConnection *gc = purple_account_get_connection(acct);
    char const *username = purple_account_get_username(acct);
    
    // create a new instance of telegram
    struct telegram *tg = telegram_new (username, &tgconf); 
    telegram_restore_session(tg);
   
    // create handle to store additional info for libpurple in
    // the new telegram instance
    telegram_conn *conn = g_new0(telegram_conn, 1);
    conn->tg = tg;
    conn->gc = gc;
    conn->pa = acct;
    conn->new_messages = g_queue_new();

    conn->joining_chats = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
    purple_connection_set_protocol_data(gc, conn);

    tg->extra = conn;
    purple_connection_set_state (conn->gc, PURPLE_CONNECTING);
    telegram_connect (tg);
}

/**
 * This must be implemented.
 */
static void tgprpl_close(PurpleConnection * gc)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_close()\n");
    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    purple_timeout_remove(conn->timer);
    telegram_destroy(conn->tg);
}

static int chat_add_message(struct telegram *tg, struct message *M) 
{
      telegram_conn *conn = tg->extra;
      
      if (chat_show (conn->gc, M->to_id.id)) {
          // chat initialies, add message now
          if (M->from_id.id == tg->our_id) {
              serv_got_chat_in(conn->gc, get_peer_id(M->to_id), "You", 
                PURPLE_MESSAGE_RECV, M->message, M->date);
          } else {
              peer_t *fromPeer = user_chat_get (tg->bl, M->from_id);
              char *alias = malloc(BUDDYNAME_MAX_LENGTH);
              user_get_alias(fromPeer, alias, BUDDYNAME_MAX_LENGTH);
              serv_got_chat_in(conn->gc, get_peer_id(M->to_id), alias, 
                PURPLE_MESSAGE_RECV, M->message, M->date);
              g_free(alias);
          }
          return 1;
      } else {
          // add message once the chat was initialised
          g_queue_push_tail (conn->new_messages, M);
          return 0;
      }
}

void message_allocated_handler(struct telegram *tg, struct message *M)
{
    debug ("message_allocated_handler\n");
    telegram_conn *conn = tg->extra;
    PurpleConnection *gc = conn->gc;

    if (M->service || (M->flags & (FLAG_MESSAGE_EMPTY | FLAG_DELETED))) {
       // TODO: handle those messages properly, currently adding them
       // causes a segfault for an unknown reason
       debug ("service message, skipping...\n");
       return;
    }

    int id = get_peer_id(M->from_id);
    peer_id_t to_id = M->to_id;
    char *from = g_strdup_printf("%d", id);
    char *to = g_strdup_printf("%d", to_id.id);
    switch (to_id.type) {
        case PEER_CHAT:
            debug ("PEER_CHAT\n");
            chat_add_message(tg, M);
        break;

        case PEER_USER:
            debug ("PEER_USER\n");
            if (M->from_id.id == tg->our_id) {
                serv_got_im(gc, to, M->message, PURPLE_MESSAGE_SEND, M->date);
            } else {
                serv_got_im(gc, from, M->message, PURPLE_MESSAGE_RECV, M->date);
            }
        break;

        case PEER_ENCR_CHAT:
        break;

        case PEER_GEO_CHAT:
        break;
    }
    g_free(from);
    conn->updated = 1;
}

void on_new_user_status(struct telegram *tg, void *peer)
{
    telegram_conn *conn = tg->extra;
    peer_t *p = peer;
    char *who = g_strdup_printf("%d", get_peer_id(p->user.id));
    PurpleAccount *account = purple_connection_get_account(conn->gc);
    if (p->user.status.online == 1) 
        purple_prpl_got_user_status(account, who, "available", "message", "", NULL);
    else
        purple_prpl_got_user_status(account, who, "mobile", "message", "", NULL);
    g_free(who);
}

void on_user_typing(struct telegram *tg, void *peer)
{
    telegram_conn *conn = tg->extra;
    peer_t *p = peer;

    char *who = g_strdup_printf("%d", get_peer_id(p->user.id));
    serv_got_typing(conn->gc, who, 2, PURPLE_TYPING);
    g_free(who);
}

/*
 * Search chats in hash table
 *
 * TODO: There has to be an easier way to do this
 */
static PurpleChat *blist_find_chat_by_hasht_cond(PurpleConnection *gc, int (*fn)(GHashTable *hasht, void *data), void *data)
{
    PurpleAccount *account = purple_connection_get_account(gc);
    PurpleBlistNode *node = purple_blist_get_root();
    GHashTable *hasht;
    while (node) {
        if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
            PurpleChat *ch = PURPLE_CHAT(node);
            if (purple_chat_get_account(ch) == account) {
                hasht = purple_chat_get_components(ch);
                if (fn(hasht, data))
                    return ch;
            }
        }
        node = purple_blist_node_next(node, 0);
    }
    return NULL;
}
static int hasht_cmp_id(GHashTable *hasht, void *data)
{
    return !strcmp(g_hash_table_lookup(hasht, "id"), *((char **)data));
}
static PurpleChat *blist_find_chat_by_id(PurpleConnection *gc, const char *id)
{
    return blist_find_chat_by_hasht_cond(gc, hasht_cmp_id, &id);
}

static char *peer_get_peer_id_as_string(peer_t *user)
{
    return g_strdup_printf("%d", get_peer_id(user->id));
}

void peer_allocated_handler(struct telegram *tg, void *usr)
{
    telegram_conn *conn = tg->extra;
    PurpleConnection *gc = conn->gc;
    PurpleAccount *pa = conn->pa;

    peer_t *user = usr;
    gchar *name = peer_get_peer_id_as_string(user); //g_strdup_printf("%d", get_peer_id(user->id));
    debug("Allocated peer: %s\n", name);
    switch (user->id.type) {
        case PEER_USER: {
            debug("Peer type: user.\n");
            // TODO: this should probably be freed again somwhere
            char *alias = malloc(BUDDYNAME_MAX_LENGTH);
            if (user_get_alias(user, alias, BUDDYNAME_MAX_LENGTH) < 0) {
                purple_debug_info(PLUGIN_ID, "Buddyalias of (%d) too long, not adding to buddy list.\n", 
                    get_peer_id(user->id));
                return;
            }
            PurpleBuddy *buddy = purple_find_buddy(pa, name);
            if (!buddy) { 
                char *actual = user->id.id == tg->our_id ? "You" : alias;
                purple_debug_info(PLUGIN_ID, "Adding %s to buddy list\n", name);
                purple_debug_info(PLUGIN_ID, "Alias %s\n", actual);
                buddy = purple_buddy_new(pa, name, actual);
                purple_blist_add_buddy(buddy, NULL, tggroup, NULL);
                do_get_user_info(conn->tg, user->id, 0);
            }
            purple_buddy_set_protocol_data(buddy, (gpointer)&user->id);
            
            PurpleAccount *account = purple_connection_get_account(gc);
            if (user->user.status.online == 1)
                purple_prpl_got_user_status(account, name, "available", "message", "", NULL);
            else
                purple_prpl_got_user_status(account, name, "mobile", "message", "", NULL);
            
            g_free(alias);
            g_free(name);
        }
        break;
        case PEER_CHAT: {
            debug("Peer type: chat.\n");
            PurpleChat *ch = blist_find_chat_by_id(gc, name);
            if (!ch) {
                gchar *admin = g_strdup_printf("%d", user->chat.admin_id);
                GHashTable *htable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
                g_hash_table_insert(htable, g_strdup("subject"), user->chat.title);
                g_hash_table_insert(htable, g_strdup("id"), name);
                g_hash_table_insert(htable, g_strdup("owner"), admin);
                debug("Adding chat to blist: %s (%s, %s)\n", user->chat.title, name, admin);
                ch = purple_chat_new(pa, user->chat.title, htable);
                purple_blist_add_chat(ch, NULL, NULL);
            }
            
            GHashTable *gh = purple_chat_get_components(ch);
            //char const *id = g_hash_table_lookup(gh, "id");
            char const *owner = g_hash_table_lookup(gh, "owner");
    
            PurpleConversation *conv = purple_find_chat(gc, atoi(name));

            purple_conv_chat_clear_users(purple_conversation_get_chat_data(conv));
            if (conv) {
                struct chat_user *usr = user->chat.user_list;
                int size = user->chat.user_list_size;
                int i;
                for (i = 0; i < size; i++) {
                    struct chat_user *cu = (usr + i);
                    // TODO: Inviter ID
                    // peer_id_t u = MK_USER (cu->user_id);
                    // peer_t *uchat = user_chat_get(u);
                    const char *cuname = g_strdup_printf("%d", cu->user_id);
                    debug("Adding user %s to chat %s\n", cuname, name);
                    purple_conv_chat_add_user(purple_conversation_get_chat_data(conv), cuname, "", 
                        PURPLE_CBFLAGS_NONE | (!strcmp(owner, cuname) ? PURPLE_CBFLAGS_FOUNDER : 0), 0);
                }
            }
        }
        break;
        case PEER_GEO_CHAT:
            debug("Peer type: geo-chat.\n");
        break;
        case PEER_ENCR_CHAT:
            debug("Peer type: encrypted chat.\n");
        break;
        case PEER_UNKNOWN:
            debug("Peer type: unknown.\n");
        break;
    }
}

PurpleNotifyUserInfo *create_user_notify_info(struct tgl_user *usr)
{
    PurpleNotifyUserInfo *info = purple_notify_user_info_new();
    purple_notify_user_info_add_pair(info, "First name", usr->first_name);
    purple_notify_user_info_add_pair(info, "Last name", usr->last_name);
    purple_notify_user_info_add_pair(info, "Phone", usr->phone);
    purple_notify_user_info_add_pair(info, "Status", usr->status.online == 1 ? "Online" : "Offline");
    return info;
}

void user_info_received_handler(struct telegram *tg, struct tgl_user *usr, int show_info)
{
    debug("Get user info. \n %d", show_info);
    char *who = g_strdup_printf("%d", usr->id.id);
    if (usr->photo.sizes_num == 0 && show_info)
    {
        telegram_conn *conn = tg->extra;
        PurpleNotifyUserInfo *info = create_user_notify_info(usr);
        purple_notify_userinfo(conn->gc, who, info, NULL, NULL);
    } else {
        struct download_desc *dld = talloc(sizeof(struct download_desc));
        dld->data = usr;
        dld->type = show_info == 1 ? 1 : 2;
        do_load_photo(tg, &usr->photo, 0, dld);
    }
    g_free(who);
}


void download_finished_handler(struct telegram *tg, struct download *D)
{
    debug("download_finished_handler %s type %d\n", D->name, D->type);
    //TODO: We need a type for user-photos!
    if(D->type == 0)
    {
        struct download_desc *dl_desc = D->extra;
        struct tgl_user *usr = dl_desc->data;
        gchar *data = NULL;
        size_t len;
        GError *err = NULL;
        g_file_get_contents(D->name, &data, &len, &err);
        int imgStoreId = purple_imgstore_add_with_id(g_memdup(data, len), len, NULL);
        debug("Imagestore id: %d\n", imgStoreId);
        //Create user info
        char *who = g_strdup_printf("%d", usr->id.id);
        telegram_conn *conn = tg->extra;
        if(dl_desc->type == 1)
        {
            PurpleNotifyUserInfo *info = create_user_notify_info(usr);
            char *profile_image = profile_image = g_strdup_printf("<br><img id=\"%u\">", imgStoreId);
            purple_notify_user_info_add_pair(info, "Profile image", profile_image);
            purple_notify_userinfo(conn->gc, who, info, NULL, NULL);
            g_free(profile_image);
        }
        purple_buddy_icons_set_for_user(conn->pa, who, g_memdup(data, len), len, NULL);
        g_free(who);
    }
}
/**
 * This PRPL function should return a positive value on success.
 * If the message is too big to be sent, return -E2BIG.  If
 * the account is not connected, return -ENOTCONN.  If the
 * PRPL is unable to send the message for another reason, return
 * some other negative value.  You can use one of the valid
 * errno values, or just big something.  If the message should
 * not be echoed to the conversation window, return 0.
 */
static int tgprpl_send_im(PurpleConnection * gc, const char *who, const char *message, PurpleMessageFlags flags)
{
    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    PurpleAccount *pa = conn->pa;

    purple_debug_info (PLUGIN_ID, "tgprpl_send_im()\n");
    PurpleBuddy *b = purple_find_buddy (pa, who);
    peer_id_t *peer = purple_buddy_get_protocol_data (b);
    do_send_message (conn->tg, *peer, message, strlen(message));
    telegram_flush (conn->tg);
    return 1;
}

/**
 * Send a message to a chat.
 * This PRPL function should return a positive value on success.
 * If the message is too big to be sent, return -E2BIG.  If
 * the account is not connected, return -ENOTCONN.  If the
 * PRPL is unable to send the message for another reason, return
 * some other negative value.  You can use one of the valid
 * errno values, or just big something.
 *
 * @param id      The id of the chat to send the message to.
 * @param message The message to send to the chat.
 * @param flags   A bitwise OR of #PurpleMessageFlags representing
 *                message flags.
 * @return       A positive number or 0 in case of success,
 *                a negative error number in case of failure.
 */
static int tgprpl_send_chat(PurpleConnection * gc, int id, const char *message, PurpleMessageFlags flags)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_send_chat()\n");
    telegram_conn *conn = purple_connection_get_protocol_data (gc);
    //PurpleConversation *convo = purple_find_chat(gc, id);
    do_send_message (conn->tg, MK_CHAT(id), message, strlen(message));

    char *who = g_strdup_printf("%d", id);
    serv_got_chat_in(gc, id, "You", PURPLE_MESSAGE_RECV, message, time(NULL));
    g_free(who);
    return 1;
}

/**
 * Add a buddy to a group on the server.
 *
 * This PRPL function may be called in situations in which the buddy is
 * already in the specified group. If the protocol supports
 * authorization and the user is not already authorized to see the
 * status of \a buddy, \a add_buddy should request authorization.
 *
 * @deprecated Since 2.8.0, add_buddy_with_invite is preferred.
 * @see add_buddy_with_invite
 */
static void tgprpl_add_buddy(PurpleConnection * gc, PurpleBuddy * buddy, PurpleGroup * group)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_add_buddy()\n");
}

static void tgprpl_add_buddies(PurpleConnection * gc, GList * buddies, GList * groups)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_add_buddies()\n");
}

static void tgprpl_remove_buddy(PurpleConnection * gc, PurpleBuddy * buddy, PurpleGroup * group)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_remove_buddy()\n");
}

static void tgprpl_remove_buddies(PurpleConnection * gc, GList * buddies, GList * groups)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_remove_buddies()\n");

}

static void tgprpl_convo_closed(PurpleConnection * gc, const char *who)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_convo_closed()\n");

}

static void tgprpl_add_deny(PurpleConnection * gc, const char *name)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_add_deny()\n");

}

static void tgprpl_rem_deny(PurpleConnection * gc, const char *name)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_rem_deny()\n");

}

/**
 * @return If this protocol requires the PURPLE_TYPING message to
 *         be sent repeatedly to signify that the user is still
 *         typing, then the PRPL should return the number of
 *         seconds to wait before sending a subsequent notification.
 *         Otherwise the PRPL should return 0.
 */
static unsigned int tgprpl_send_typing(PurpleConnection * gc, const char *who, PurpleTypingState typing)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_send_typing()\n");
    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    PurpleBuddy *b = purple_find_buddy(conn->pa, who);
    if (b) {
        peer_id_t *peer = purple_buddy_get_protocol_data(b);
        if (peer) {
            do_update_typing (conn->tg, *peer);
        }
    }
    return 0;
}

/**
 * Set the buddy icon for the given connection to @a img.  The prpl
 * does NOT own a reference to @a img; if it needs one, it must
 * #purple_imgstore_ref(@a img) itself.
 */
static void tgprpl_set_buddy_icon(PurpleConnection * gc, PurpleStoredImage * img)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_set_buddy_icon()\n");

}

/**
 * File transfer callback
 */
static gboolean tgprpl_can_receive_file(PurpleConnection * gc, const char *who)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_can_receive_file()\n");
    return 0;
}

/**
 *  Checks whether offline messages to @a buddy are supported.

 *  @return @c 1 if @a buddy can be sent messages while they are
 *          offline, or @c 0 if not.
 */
static gboolean tgprpl_offline_message(const PurpleBuddy * buddy)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_offline_message()\n");
    return 0;
}

/**
 * Returns a list of #PurpleStatusType which exist for this account;
 * this must be implemented, and must add at least the offline and
 * online states.
 */
static GList *tgprpl_status_types(PurpleAccount * acct)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_status_types()\n");
    GList *types = NULL;
    PurpleStatusType *type;
    type = purple_status_type_new_with_attrs(PURPLE_STATUS_AVAILABLE, NULL, NULL,
        1, 1, 0, "message", "Message", purple_value_new(PURPLE_TYPE_STRING), NULL);
    types = g_list_prepend(types, type);
    
    type = purple_status_type_new_with_attrs(PURPLE_STATUS_MOBILE, NULL, NULL, 1,
        1, 0, "message", "Message", purple_value_new(PURPLE_TYPE_STRING), NULL);
    types = g_list_prepend(types, type);

    type = purple_status_type_new(PURPLE_STATUS_OFFLINE, NULL, NULL, 1);
    types = g_list_append(types, type);

    return g_list_reverse(types);
}

static void tgprpl_set_status(PurpleAccount * acct, PurpleStatus * status)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_set_status()\n");
}

/**
 * Should arrange for purple_notify_userinfo() to be called with
 * @a who's user info.
 */
static void tgprpl_get_info(PurpleConnection * gc, const char *username)
{
    
    purple_debug_info(PLUGIN_ID, "tgprpl_get_info()\n");
    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    peer_id_t u = MK_USER(atoi(username));
    do_get_user_info(conn->tg, u, 1);
    purple_debug_info(PLUGIN_ID, "tgprpl_get_info ready()\n");
                //fetch_alloc_user_full(tg->connection);
            //fetch_user_full(tg->connection, user);

}

/**
 * change a buddy's group on a server list/roster
 */
static void tgprpl_group_buddy(PurpleConnection * gc, const char *who, const char *old_group, const char *new_group)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_group_buddy()\n");

}

/**
 * rename a group on a server list/roster
 */
static void tgprpl_rename_group(PurpleConnection * gc, const char *old_name, PurpleGroup * group, GList * moved_buddies)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_rename_group()\n");

}

/**
 * Returns a list of #proto_chat_entry structs, which represent
 * information required by the PRPL to join a chat. libpurple will
 * call join_chat along with the information filled by the user.
 *
 * @return A list of #proto_chat_entry structs
 */
static GList *tgprpl_chat_join_info(PurpleConnection * gc)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_chat_join_info()\n");
    struct proto_chat_entry *pce;

    pce = g_new0(struct proto_chat_entry, 1);
    pce->label = "_Subject:";
    pce->identifier = "subject";
    pce->required = TRUE;
    return g_list_append(NULL, pce);
}

/**
 * Returns a hashtable which maps #proto_chat_entry struct identifiers
 * to default options as strings based on chat_name. The resulting
 * hashtable should be created with g_hash_table_new_full(g_str_hash,
 * g_str_equal, NULL, g_free);. Use #get_chat_name if you instead need
 * to extract a chat name from a hashtable.
 *
 * @param chat_name The chat name to be turned into components
 * @return Hashtable containing the information extracted from chat_name
 */
static GHashTable *tgprpl_chat_info_defaults(PurpleConnection * gc, const char *chat_name)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_chat_info_defaults()\n");
    return NULL;
}

/**
 * Called when the user requests joining a chat. Should arrange for
 * #serv_got_joined_chat to be called.
 *
 * @param components A hashtable containing information required to
 *                   join the chat as described by the entries returned
 *                   by #chat_info. It may also be called when accepting
 *                   an invitation, in which case this matches the
 *                   data parameter passed to #serv_got_chat_invite.
 */
static void tgprpl_chat_join(PurpleConnection * gc, GHashTable * data)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_chat_join()\n");

    telegram_conn *conn = purple_connection_get_protocol_data(gc);
    const char *groupname = g_hash_table_lookup(data, "subject");

    char *id = g_hash_table_lookup(data, "id");
    if (!id) { 
        debug ("Got no chat id, aborting...\n");
        return;
    }
    if (!purple_find_chat(gc, atoi(id))) {
        debug ("chat now known\n");
        char *subject, *owner, *part;
        do_get_chat_info (conn->tg, MK_CHAT(atoi(id)));
        telegram_flush (conn->tg);
    } else {
        debug ("chat already known\n");
        serv_got_joined_chat(conn->gc, atoi(id), groupname);
    }
}

void on_chat_joined (struct telegram *instance, peer_id_t chatid)
{
    debug ("on_chat_joined(%d)\n", chatid.id);
    telegram_conn *conn = instance->extra;

    peer_t *peer = user_chat_get (instance->bl, chatid);
    if (!peer) {
        warning ("WARNING: chat with given id %d is not existing.\n", chatid.id);
        return;
    }
    if (!peer->id.type == PEER_CHAT) {
        warning ("WARNING: peer with given id %d and type %d is not a chat.\n", peer->id.id, peer->id.type);
        return;
    } 
    PurpleConversation *conv = serv_got_joined_chat(conn->gc, chatid.id, peer->chat.title);
    int cnt = peer->chat.user_list_size;
    struct chat_user *curr = peer->chat.user_list;
    int i;
    for (i = 0; i < cnt; i++) {
        peer_id_t part_id = MK_USER((curr + i)->user_id);
        char *name = g_strdup_printf ("%d", part_id.id);
        int flags = PURPLE_CBFLAGS_NONE | ((peer->chat.admin_id == part_id.id) ? PURPLE_CBFLAGS_FOUNDER : 0);
        debug ("purple_conv_chat_add_user (..., name=%s, ..., flags=%d)", name, flags);
        purple_conv_chat_add_user(
            purple_conversation_get_chat_data(conv), 
            name, 
            "", 
            flags, 
            0
        );
    }
    
    debug ("g_queue_pop_head()\n");
    struct message *M = 0;
    while ((M = g_queue_pop_head (conn->new_messages))) {
        debug ("adding msg-id\n");
        int id = get_peer_id(M->from_id);
        if (!chat_add_message(instance, M)) {
            // chat still not working?
            warning ("WARNING, chat %d still not existing... \n", chatid.id);
            break;
        }
    }

    gchar *name = g_strdup_printf ("%d", chatid.id);
    g_hash_table_remove (conn->joining_chats, name);
    g_free (name);
}

/**
 * Invite a user to join a chat.
 *
 * @param id      The id of the chat to invite the user to.
 * @param message A message displayed to the user when the invitation
 *                is received.
 * @param who     The name of the user to send the invation to.
 */
static void tgprpl_chat_invite(PurpleConnection * gc, int id, const char *message, const char *name) { purple_debug_info(PLUGIN_ID, "tgprpl_chat_invite()\n"); } 
/**
 * Returns a chat name based on the information in components. Use
 * #chat_info_defaults if you instead need to generate a hashtable
 * from a chat name.
 *
 * @param components A hashtable containing information about the chat.
 */
static char *tgprpl_get_chat_name(GHashTable * data)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_get_chat_name()\n");
    return g_strdup(g_hash_table_lookup(data, "subject"));
}

/**
 * File transfer callback.
 */
static PurpleXfer *tgprpl_new_xfer(PurpleConnection * gc, const char *who)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_new_xfer()\n");
    return (PurpleXfer *)NULL;
}

/**
 * File transfer callback.
 */
static void tgprpl_send_file(PurpleConnection * gc, const char *who, const char *file)
{
    purple_debug_info(PLUGIN_ID, "tgprpl_send_file()\n");

}

// SEE prpl.h
static PurplePluginProtocolInfo prpl_info = {
    OPT_PROTO_NO_PASSWORD,                    /* options */
    NULL,                                          /* user_splits, initialized in tgprpl_init() */
    NULL,                                          /* protocol_options, initialized in tgprpl_init() */
    {                                         /* icon_spec, a PurpleBuddyIconSpec */
        "png",                                   /* format */
        1,                                          /* min_width */
        1,                                          /* min_height */
        512,                                      /* max_width */
        512,                                      /* max_height */
        64000,                                   /* max_filesize */
        PURPLE_ICON_SCALE_SEND,                   /* scale_rules */
    },
    tgprpl_list_icon,
    NULL,
    NULL,
    tgprpl_tooltip_text,
    tgprpl_status_types,
    NULL,                                     /* blist_node_menu */
    tgprpl_chat_join_info,
    tgprpl_chat_info_defaults,                /* chat_info_defaults */
    tgprpl_login,                             /* login */
    tgprpl_close,                                /* close */
    tgprpl_send_im,                             /* send_im */
    NULL,                                     /* set_info */
    tgprpl_send_typing,                         /* send_typing */
    tgprpl_get_info,                            /* get_info */
    tgprpl_set_status,                         /* set_status */
    NULL,                                     /* set_idle */
    NULL,                                     /* change_passwd */
    tgprpl_add_buddy,                            /* add_buddy */
    tgprpl_add_buddies,                         /* add_buddies */
    tgprpl_remove_buddy,                         /* remove_buddy */
    tgprpl_remove_buddies,                      /* remove_buddies */
    NULL,                                     /* add_permit */
    tgprpl_add_deny,                            /* add_deny */
    NULL,                                     /* rem_permit */
    tgprpl_rem_deny,                            /* rem_deny */
    NULL,                                     /* set_permit_deny */
    tgprpl_chat_join,    /* join_chat */
    NULL,                                     /* reject_chat */
    tgprpl_get_chat_name,                      /* get_chat_name */
    tgprpl_chat_invite,                         /* chat_invite */
    NULL,                                     /* chat_leave */
    NULL,                                     /* chat_whisper */
    tgprpl_send_chat,                            /* chat_send */
    NULL,                                     /* keepalive */
    NULL,                                     /* register_user */
    NULL,                                     /* get_cb_info */
    NULL,                                     /* get_cb_away */
    NULL,                                     /* alias_buddy */
    tgprpl_group_buddy,                         /* group_buddy */
    tgprpl_rename_group,                         /* rename_group */
    NULL,                                     /* buddy_free */
    tgprpl_convo_closed,                         /* convo_closed */
    purple_normalize_nocase,                   /* normalize */
    tgprpl_set_buddy_icon,                      /* set_buddy_icon */
    NULL,                                     /* remove_group */
    NULL,                                     /* get_cb_real_name */
    NULL,                                     /* set_chat_topic */
    NULL,                                     /* find_blist_chat */
    NULL,                                     /* roomlist_get_list */
    NULL,                                     /* roomlist_cancel */
    NULL,                                     /* roomlist_expand_category */
    tgprpl_can_receive_file,                   /* can_receive_file */
    tgprpl_send_file,                            /* send_file */
    tgprpl_new_xfer,                            /* new_xfer */
    tgprpl_offline_message,                      /* offline_message */
    NULL,                                     /* whiteboard_prpl_ops */
    NULL,                                     /* send_raw */
    NULL,                                     /* roomlist_room_serialize */
    NULL,                                     /* unregister_user */
    NULL,                                     /* send_attention */
    NULL,                                     /* get_attention_types */
    sizeof(PurplePluginProtocolInfo),          /* struct_size */
    NULL,                                     /* get_account_text_table */
    NULL,                                     /* initiate_media */
    NULL,                                     /* get_media_caps */
    NULL,                                     /* get_moods */
    NULL,                                     /* set_public_alias */
    NULL,                                     /* get_public_alias */
    NULL,                                     /* add_buddy_with_invite */
    NULL                                          /* add_buddies_with_invite */
};

static void tgprpl_init(PurplePlugin *plugin)
{
    const char *dir = CONFIG_DIR;
    if (!tgconf.base_config_path) {
        struct passwd *pw = getpwuid(getuid());
        int len = strlen (dir) + strlen (pw->pw_dir) + 2;    
        tgconf.base_config_path = talloc (len);
        tsnprintf (tgconf.base_config_path, len, "%s/%s", pw->pw_dir, dir);
        debug ("base configuration path: %s", tgconf.base_config_path);
    }

    PurpleAccountOption *option;
    GList *verification_values = NULL;
    
    // Extra Options
 #define ADD_VALUE(list, desc, v) { \
     PurpleKeyValuePair *kvp = g_new0(PurpleKeyValuePair, 1); \
     kvp->key = g_strdup((desc)); \
     kvp->value = g_strdup((v)); \
     list = g_list_prepend(list, kvp); \
 }
    ADD_VALUE(verification_values, "Phone", TELEGRAM_AUTH_MODE_PHONE);
    ADD_VALUE(verification_values, "SMS", TELEGRAM_AUTH_MODE_SMS);

    option = purple_account_option_list_new("Verification type", "verification_type", verification_values);
    prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);

    _telegram_protocol = plugin;
}

static GList *tgprpl_actions(PurplePlugin * plugin, gpointer context)
{
    // return possible actions (See Libpurple doc)
    return (GList *)NULL;
}

static PurplePluginInfo plugin_info = {
    PURPLE_PLUGIN_MAGIC,
    PURPLE_MAJOR_VERSION,
    PURPLE_MINOR_VERSION,
    PURPLE_PLUGIN_PROTOCOL,
    NULL,
    0,
    NULL,
    PURPLE_PRIORITY_DEFAULT,
    PLUGIN_ID,
    "Telegram",
    TG_VERSION,
    "Telegram",
    TG_DESCRIPTION,
    TG_AUTHOR,
    "https://github.com/majn/telegram-purple",
    NULL,           // on load
    NULL,           // on unload
    NULL,           // on destroy
    NULL,           // ui specific struct
    &prpl_info,     // plugin info struct
    NULL,           // prefs info
    tgprpl_actions, // actions
    NULL,           // reserved
    NULL,           // reserved
    NULL,           // reserved
    NULL            // reserved
};


PURPLE_INIT_PLUGIN(telegram, tgprpl_init, plugin_info)