asdsadasd

#include "messenger_purple.h"

#include "purple.h"

#include <glib.h>

#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>

#define CUSTOM_USER_DIRECTORY  "/dev/null"
#define CUSTOM_PLUGIN_PATH     ""
#define PLUGIN_SAVE_PREF       "/purple/sailfish/plugins/saved"
#define UI_ID                  "sailfish"

/**
 * The following eventloop functions are used in both pidgin and purple-text. If your
 * application uses glib mainloop, you can safely use this verbatim.
 */
#define PURPLE_GLIB_READ_COND  (G_IO_IN | G_IO_HUP | G_IO_ERR)
#define PURPLE_GLIB_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL)

typedef struct _PurpleGLibIOClosure {
    PurpleInputFunction function;
    guint result;
    gpointer data;
} PurpleGLibIOClosure;

typedef struct
{
    PurpleAccountRequestType type;
    PurpleAccount *account;
    void *ui_handle;
    char *user;
    gpointer userdata;
    PurpleAccountRequestAuthorizationCb auth_cb;
    PurpleAccountRequestAuthorizationCb deny_cb;
    guint ref;
} PurpleAccountRequestInfo;

static void purple_glib_io_destroy(gpointer data)
{
    g_free(data);
}

static gboolean purple_glib_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
{
    PurpleGLibIOClosure *closure = (PurpleGLibIOClosure*)data;
    PurpleInputCondition purple_cond = (PurpleInputCondition)0;

    if (condition & PURPLE_GLIB_READ_COND)
        purple_cond |= PURPLE_INPUT_READ;
    if (condition & PURPLE_GLIB_WRITE_COND)
        purple_cond |= PURPLE_INPUT_WRITE;

    closure->function(closure->data, g_io_channel_unix_get_fd(source),
              purple_cond);

    return TRUE;
}

static guint glib_input_add(gint fd, PurpleInputCondition condition, PurpleInputFunction function,
                               gpointer data)
{
    PurpleGLibIOClosure *closure = g_new0(PurpleGLibIOClosure, 1);
    GIOChannel *channel;
    GIOCondition cond = 0;

    closure->function = function;
    closure->data = data;

    if (condition & PURPLE_INPUT_READ)
        cond |= PURPLE_GLIB_READ_COND;
    if (condition & PURPLE_INPUT_WRITE)
        cond |= PURPLE_GLIB_WRITE_COND;

    channel = g_io_channel_unix_new(fd);
    closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
                          purple_glib_io_invoke, closure, purple_glib_io_destroy);

    g_io_channel_unref(channel);
    return closure->result;
}

static PurpleEventLoopUiOps glib_eventloops =
{
    g_timeout_add,
    g_source_remove,
    glib_input_add,
    g_source_remove,
    NULL,
#if GLIB_CHECK_VERSION(2,14,0)
    g_timeout_add_seconds,
#else
    NULL,
#endif

    /* padding */
    NULL,
    NULL,
    NULL
};
/*** End of the eventloop functions. ***/

static void network_disconnected(void)
{

    printf("This machine has been disconnected from the internet\n");

}

static void report_disconnect_reason(PurpleConnection *gc, PurpleConnectionError reason, const char *text)
{

    PurpleAccount *account = purple_connection_get_account(gc);
    printf("Connection disconnected: \"%s\" (%s)\n  >Error: %d\n  >Reason: %s\n", purple_account_get_username(account),
purple_account_get_protocol_id(account), reason, text);

}

static PurpleConnectionUiOps connection_uiops =
{
    NULL,                      /* connect_progress         */
    NULL,                      /* connected                */
    NULL,                      /* disconnected             */
    NULL,                      /* notice                   */
    NULL,                      /* report_disconnect        */
    NULL,                      /* network_connected        */
    network_disconnected,      /* network_disconnected     */
    report_disconnect_reason,  /* report_disconnect_reason */
    NULL,
    NULL,
    NULL
};

static void ui_init(void)
{
    /**
     * This should initialize the UI components for all the modules.
     */

    purple_connections_set_ui_ops(&connection_uiops);

}

static PurpleCoreUiOps core_uiops =
{
    NULL,
    NULL,
    ui_init,
    NULL,

    /* padding */
    NULL,
    NULL,
    NULL,
    NULL
};

static void init_libpurple(void)
{
    /* Set a custom user directory (optional) */
    //purple_util_set_user_dir(CUSTOM_USER_DIRECTORY);

    /* We do not want any debugging for now to keep the noise to a minimum. */
    purple_debug_set_enabled(FALSE);

    /* Set the core-uiops, which is used to
     * 	- initialize the ui specific preferences.
     * 	- initialize the debug ui.
     * 	- initialize the ui components for all the modules.
     * 	- uninitialize the ui components for all the modules when the core terminates.
     */
    purple_core_set_ui_ops(&core_uiops);

    /* Set the uiops for the eventloop. If your client is glib-based, you can safely
     * copy this verbatim. */
    purple_eventloop_set_ui_ops(&glib_eventloops);

    /* Set path to search for plugins. The core (libpurple) takes care of loading the
     * core-plugins, which includes the protocol-plugins. So it is not essential to add
     * any path here, but it might be desired, especially for ui-specific plugins. */
    purple_plugins_add_search_path(CUSTOM_PLUGIN_PATH);

    /* Now that all the essential stuff has been set, let's try to init the core. It's
     * necessary to provide a non-NULL name for the current ui to the core. This name
     * is used by stuff that depends on this ui, for example the ui-specific plugins. */
    if (!purple_core_init(UI_ID)) {
        /* Initializing the core failed. Terminate. */
        fprintf(stderr,
                "libpurple initialization failed. Dumping core.\n"
                "Please report this!\n");
        abort();
    }

    /* Create and load the buddylist. */
    purple_set_blist(purple_blist_new());
    purple_blist_load();

    /* Load the preferences. */
    purple_prefs_load();

    /* Load the desired plugins. The client should save the list of loaded plugins in
     * the preferences using purple_plugins_save_loaded(PLUGIN_SAVE_PREF) */
    purple_plugins_load_saved(PLUGIN_SAVE_PREF);

    /* Load the pounces. */
    purple_pounces_load();
}

/**************************************************************************
 * Account subsystem signal callbacks
 **************************************************************************/
static void
account_connecting_cb(PurpleAccount *account, void *data)
{
    printf("account-connecting (%s)\n",
                    purple_account_get_username(account));
}

static void
account_setting_info_cb(PurpleAccount *account, const char *info, void *data)
{
    printf("account-setting-info (%s, %s)\n",
                    purple_account_get_username(account), info);
}

static void
account_set_info_cb(PurpleAccount *account, const char *info, void *data)
{
    printf("account-set-info (%s, %s)\n",
                    purple_account_get_username(account), info);
}

static void
account_status_changed(PurpleAccount *account, PurpleStatus *old, PurpleStatus *new, gpointer data)
{
    printf("account-status-changed (%s, %s, %s)\n",
                    purple_account_get_username(account),
                    purple_status_get_name(old),
                    purple_status_get_name(new));
}

static void
account_alias_changed(PurpleAccount *account, const char *old, gpointer data)
{
    printf("account-alias-changed (%s, %s, %s)\n",
                    purple_account_get_username(account),
                    old, purple_account_get_alias(account));
}

static int
account_authorization_requested_cb(PurpleAccount *account, const char *user, gpointer data)
{
    printf("account-authorization-requested (%s, %s)\n",
            purple_account_get_username(account), user);
    return 0;
}

static void
account_authorization_granted_cb(PurpleAccount *account, const char *user, gpointer data)
{
    printf("account-authorization-granted (%s, %s)\n",
            purple_account_get_username(account), user);
}

static void
account_authorization_denied_cb(PurpleAccount *account, const char *user, gpointer data)
{
    printf("account-authorization-denied (%s, %s)\n",
            purple_account_get_username(account), user);
}

/**************************************************************************
 * Buddy Icons signal callbacks
 **************************************************************************/
static void
buddy_icon_changed_cb(PurpleBuddy *buddy)
{
//     printf("buddy icon changed (%s)\n",
//                    purple_buddy_icon_get_full_path(purple_buddy_get_icon(buddy)));
     emit_avatar(purple_buddy_get_name(buddy),purple_account_get_username(purple_buddy_get_account(buddy)),  purple_buddy_icon_get_full_path(purple_buddy_get_icon(buddy)));

}

/**************************************************************************
 * Buddy List subsystem signal callbacks
 **************************************************************************/
//static void
//buddy_status_changed_cb(PurpleBuddy *buddy, PurpleStatus *old_status,
//                        PurpleStatus *status, void *data)
//{
//    printf("buddy-status-changed (%s %s to %s)\n",
//                      purple_buddy_get_name(buddy),
//                      purple_status_get_id(old_status),
//                      purple_status_get_id(status));
//}

static void
buddy_idle_changed_cb(PurpleBuddy *buddy, gboolean old_idle, gboolean idle,
                      void *data)
{
    printf("buddy-idle-changed (%s %s)\n",
                      purple_buddy_get_name(buddy),
                      old_idle ? "unidled" : "idled");
}

static void
buddy_status_changed_cb(PurpleBuddy *buddy, void *data)
{
//    printf("buddy-status-changed (%d)\n",
//           strcmp(purple_status_get_id(purple_presence_get_active_status(purple_buddy_get_presence(buddy))),"available") == 0 ? 1 : 0);
    emit_status_changed(purple_buddy_get_name(buddy),purple_account_get_username(purple_buddy_get_account(buddy)),strcmp(purple_status_get_id(purple_presence_get_active_status(purple_buddy_get_presence(buddy))),"available") == 0 ? 1 : 0);

}

//static void
//buddy_signed_on_cb(PurpleBuddy *buddy, void *data)
//{
//    printf("buddy-signed-on (%s)\n",
//           purple_status_get_name(purple_presence_get_active_status(purple_buddy_get_presence(buddy))));
//}

//static void
//buddy_signed_off_cb(PurpleBuddy *buddy, void *data)
//{
//    printf("buddy-signed-off (%s)\n",
//                      purple_status_get_name(purple_presence_get_active_status(purple_buddy_get_presence(buddy))));
//}

static void
blist_node_added_cb(PurpleBlistNode *bnode, void *data)
{
    const char *name;
    if (PURPLE_BLIST_NODE_IS_GROUP(bnode))
        name = purple_group_get_name(PURPLE_GROUP(bnode));
    else if (PURPLE_BLIST_NODE_IS_CONTACT(bnode))
        /* Close enough */
        name = purple_contact_get_alias(PURPLE_CONTACT(bnode));
    else if (PURPLE_BLIST_NODE_IS_BUDDY(bnode))
        name = purple_buddy_get_name(PURPLE_BUDDY(bnode));
    else
        name = "(unknown)";

    printf("blist_node_added_cb (%s)\n",
                      name ? name : "(null)");

}

static void
blist_node_removed_cb(PurpleBlistNode *bnode, void *data)
{
    const char *name;
    if (PURPLE_BLIST_NODE_IS_GROUP(bnode))
        name = purple_group_get_name(PURPLE_GROUP(bnode));
    else if (PURPLE_BLIST_NODE_IS_CONTACT(bnode))
        /* Close enough */
        name = purple_contact_get_alias(PURPLE_CONTACT(bnode));
    else if (PURPLE_BLIST_NODE_IS_BUDDY(bnode))
        name = purple_buddy_get_name(PURPLE_BUDDY(bnode));
    else
        name = "(unknown)";

    printf("blist_node_removed_cb (%s)\n",
                      name ? name : "(null)");
}

void display(gpointer key, gpointer value, gpointer userdata)
{
    printf("display %d", value);
}

static void
blist_node_aliased(PurpleBlistNode *node, const char *old_alias)
{
    PurpleContact *p = (PurpleContact *)node;
    PurpleBuddy *b = (PurpleBuddy *)node;
    PurpleChat *c = (PurpleChat *)node;
    PurpleGroup *g = (PurpleGroup *)node;

    if (PURPLE_BLIST_NODE_IS_CONTACT(node)) {
         printf("blist-node-aliased (Contact: %s, %s)\n",
                          purple_contact_get_alias(p), old_alias);
    } else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) {
//         printf("blist-node-aliased (Buddy: %s, %s, %d)\n",
//                          purple_buddy_get_name(b), (const char*) purple_buddy_get_account(b), g_hash_table_size(purple_buddy_get_account(b)->settings));
        emit_add(purple_buddy_get_alias(b),purple_buddy_get_name(b),purple_account_get_username(purple_buddy_get_account(b)), 0);
    } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
         printf("blist-node-aliased (Chat: %s, %s)\n",
                          c->alias, old_alias);
    } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) {
         printf("blist-node-aliased (Group: %s, %s)\n",
                          purple_group_get_name(g), old_alias);
    } else {
         printf("blist-node-aliased (UNKNOWN: %d, %s)\n",
                          purple_blist_node_get_type(node), old_alias);
    }
}

static void
blist_node_extended_menu_cb(PurpleBlistNode *node, void *data)
{
    PurpleContact *p = (PurpleContact *)node;
    PurpleBuddy *b = (PurpleBuddy *)node;
    PurpleChat *c = (PurpleChat *)node;
    PurpleGroup *g = (PurpleGroup *)node;

    if (PURPLE_BLIST_NODE_IS_CONTACT(node)) {
        printf("blist-node-extended-menu (Contact: %s)\n",
                          purple_contact_get_alias(p));
    } else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) {
        printf("blist-node-extended-menu (Buddy: %s)\n",
                          purple_buddy_get_name(b));
    } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
        printf("blist-node-extended-menu (Chat: %s)\n",
                          purple_chat_get_name(c));
    } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) {
        printf("blist-node-extended-menu (Group: %s)\n",
                          purple_group_get_name(g));
    } else {
        printf("blist-node-extended-menu (UNKNOWN: %d)\n",
                          purple_blist_node_get_type(node));
    }
}


/**************************************************************************
 * Connection subsystem signal callbacks
 **************************************************************************/
static void
signing_on_cb(PurpleConnection *gc, void *data)
{
    printf("signing-on (%s)\n",
                    purple_account_get_username(purple_connection_get_account(gc)));
}

static void
signed_on_cb(PurpleConnection *gc, void *data)
{
    printf("signed-on (%s)\n",
                    purple_account_get_username(purple_connection_get_account(gc)));
}

static void
signing_off_cb(PurpleConnection *gc, void *data)
{
    printf("signing-off (%s)\n",
                    purple_account_get_username(purple_connection_get_account(gc)));
}

static void
signed_off_cb(PurpleConnection *gc, void *data)
{
    printf("signed-off (%s)\n",
                    purple_account_get_username(purple_connection_get_account(gc)));
}

static void
connection_error_cb(PurpleConnection *gc,
                    PurpleConnectionError err,
                    const gchar *desc,
                    void *data)
{
    const gchar *username =
        purple_account_get_username(purple_connection_get_account(gc));
    printf("connection-error (%s, %u, %s)\n",
        username, err, desc);
}

/**************************************************************************
 * Conversation subsystem signal callbacks
 **************************************************************************/
static gboolean
writing_im_msg_cb(PurpleAccount *account, const char *who, char **buffer,
                PurpleConversation *conv, PurpleMessageFlags flags, void *data)
{
    printf("writing-im-msg (%s, %s, %s)\n",
                    purple_account_get_username(account), purple_conversation_get_name(conv), *buffer);

    return FALSE;

}

static void
wrote_im_msg_cb(PurpleAccount *account, const char *who, const char *buffer,
                PurpleConversation *conv, PurpleMessageFlags flags, void *data)
{
//    printf("wrote-im-msg (%s, %s, %s, %d, %s, %d)\n",
//                    purple_account_get_username(account), purple_conversation_get_title(conv), buffer, flags, who, conv->type);
    if(flags == PURPLE_MESSAGE_RECV)
        reciveMessage(who,purple_account_get_username(account),purple_conversation_get_title(conv), buffer, purple_conversation_message_get_timestamp(purple_conversation_get_message_history(conv)->data),0);
    else if(flags == PURPLE_MESSAGE_SEND)
        sendMessage(purple_conversation_get_name(conv),purple_account_get_username(account),"Me", buffer, purple_conversation_message_get_timestamp(purple_conversation_get_message_history(conv)->data),0);
//    printf("buddy icon changed (%s)\n",
//                   purple_buddy_icon_get_full_path(purple_buddy_get_icon(purple_find_buddy(purple_conversation_get_account(conv),who))));
}

static void
sending_im_msg_cb(PurpleAccount *account, char *recipient, char **buffer, void *data)
{
    printf("sending-im-msg (%s, %s, %s)\n",
                    purple_account_get_username(account), recipient, *buffer);

}

static void
sent_im_msg_cb(PurpleAccount *account, const char *recipient, const char *buffer, void *data)
{
    printf("sent-im-msg (%s, %s, %s)\n",
                    purple_account_get_username(account), recipient, buffer);
}

static gboolean
receiving_im_msg_cb(PurpleAccount *account, char **sender, char **buffer,
                    PurpleConversation *conv, PurpleMessageFlags *flags, void *data)
{
    printf("receiving-im-msg (%s, %s, %s, %s, %d)\n",
                    purple_account_get_username(account), *sender, *buffer,
                    (conv != NULL) ? purple_conversation_get_name(conv) : "(null)", *flags);

    return FALSE;
}

static void
received_im_msg_cb(PurpleAccount *account, char *sender, char *buffer,
                   PurpleConversation *conv, PurpleMessageFlags flags, void *data)
{
    printf("received-im-msg (%s, %s, %s, %s, %d)\n",
                    purple_account_get_username(account), sender, buffer,
                    (conv != NULL) ? purple_conversation_get_name(conv) : "(null)", flags);
}

static gboolean
writing_chat_msg_cb(PurpleAccount *account, const char *who, char **buffer,
                PurpleConversation *conv, PurpleMessageFlags flags, void *data)
{
    printf("writing-chat-msg (%s, %s)\n",
                    purple_conversation_get_name(conv), *buffer);

    return FALSE;
}

static void
wrote_chat_msg_cb(PurpleAccount *account, const char *who, const char *buffer,
                PurpleConversation *conv, PurpleMessageFlags flags, void *data)
{
    printf("wrote-chat-msg (%s, %s, %d)\n",
                    purple_conversation_get_title(conv), buffer, flags);
    if(flags == PURPLE_MESSAGE_RECV)
        reciveMessage((const char*[]){purple_conversation_get_name(conv), who},purple_account_get_username(account), purple_buddy_get_alias(purple_find_buddy(purple_conversation_get_account(conv),who)), buffer, purple_conversation_message_get_timestamp(purple_conversation_get_message_history(conv)->data),0);
    else if(flags == PURPLE_MESSAGE_SEND)
        sendMessage((const char*[]){purple_conversation_get_name(conv)},purple_account_get_username(account),"Me", buffer, purple_conversation_message_get_timestamp(purple_conversation_get_message_history(conv)->data),0);
}

static gboolean
sending_chat_msg_cb(PurpleAccount *account, char **buffer, int id, void *data)
{
    printf("sending-chat-msg (%s, %s, %d)\n",
                    purple_account_get_username(account), *buffer, id);

    return FALSE;
}

static void
sent_chat_msg_cb(PurpleAccount *account, const char *buffer, int id, void *data)
{
    printf("sent-chat-msg (%s, %s, %d)\n",
                    purple_account_get_username(account), buffer, id);
}

static gboolean
receiving_chat_msg_cb(PurpleAccount *account, char **sender, char **buffer,
                     PurpleConversation *chat, PurpleMessageFlags *flags, void *data)
{
    printf(
                    "receiving-chat-msg (%s, %s, %s, %s, %d)\n",
                    purple_account_get_username(account), *sender, *buffer,
                    purple_conversation_get_title(chat), *flags);

    return FALSE;
}

static void
received_chat_msg_cb(PurpleAccount *account, char *sender, char *buffer,
                     PurpleConversation *chat, PurpleMessageFlags flags, void *data)
{
    printf(
                    "received-chat-msg (%s, %s, %s, %s, %d)\n",
                    purple_account_get_username(account), sender, buffer,
                    purple_conversation_get_name(chat), flags);
}

static void
conversation_created_cb(PurpleConversation *conv, void *data)
{
    printf("conversation-created (%s)\n",
                    purple_conversation_get_name(conv));
}

static void
deleting_conversation_cb(PurpleConversation *conv, void *data)
{
    printf("deleting-conversation (%s)\n",
                    purple_conversation_get_name(conv));
}

static void
buddy_typing_cb(PurpleAccount *account, const char *name, void *data)
{
    printf("buddy-typing (%s, %s)\n",
                    purple_account_get_username(account), name);
}

static void
buddy_typing_stopped_cb(PurpleAccount *account, const char *name, void *data)
{
    printf("buddy-typing-stopped (%s, %s)\n",
                    purple_account_get_username(account), name);
}

static gboolean
chat_buddy_joining_cb(PurpleConversation *conv, const char *user,
                      PurpleConvChatBuddyFlags flags, void *data)
{
    printf("chat-buddy-joining (%s, %s, %d)\n",
                    purple_conversation_get_name(conv), user, flags);

    return FALSE;
}

static void
chat_buddy_joined_cb(PurpleConversation *conv, const char *user,
                     PurpleConvChatBuddyFlags flags, gboolean new_arrival, void *data)
{
    printf("chat-buddy-joined (%s, %s, %d, %d)\n",
                    purple_conversation_get_name(conv), user, flags, new_arrival);
}

static void
chat_buddy_flags_cb(PurpleConversation *conv, const char *user,
                    PurpleConvChatBuddyFlags oldflags, PurpleConvChatBuddyFlags newflags, void *data)
{
    printf("chat-buddy-flags (%s, %s, %d, %d)\n",
                    purple_conversation_get_name(conv), user, oldflags, newflags);
}

static gboolean
chat_buddy_leaving_cb(PurpleConversation *conv, const char *user,
                      const char *reason, void *data)
{
    printf("chat-buddy-leaving (%s, %s, %s)\n",
                    purple_conversation_get_name(conv), user, reason);

    return FALSE;
}

static void
chat_buddy_left_cb(PurpleConversation *conv, const char *user,
                   const char *reason, void *data)
{
    printf("chat-buddy-left (%s, %s, %s)\n",
                    purple_conversation_get_name(conv), user, reason);
}

static void
chat_inviting_user_cb(PurpleConversation *conv, const char *name,
                      char **reason, void *data)
{
    printf("chat-inviting-user (%s, %s, %s)\n",
                    purple_conversation_get_name(conv), name, *reason);
}

static void
chat_invited_user_cb(PurpleConversation *conv, const char *name,
                      const char *reason, void *data)
{
    printf("chat-invited-user (%s, %s, %s)\n",
                    purple_conversation_get_name(conv), name, reason);
}

static gint
chat_invited_cb(PurpleAccount *account, const char *inviter,
                const char *room_name, const char *message,
                const GHashTable *components, void *data)
{
    printf("chat-invited (%s, %s, %s, %s)\n",
                    purple_account_get_username(account), inviter,
                    room_name, message);

    return 0;
}

static void
chat_joined_cb(PurpleConversation *conv, void *data)
{
    printf("chat-joined (%s)\n",
                    purple_conversation_get_title(conv));
}

static void
chat_left_cb(PurpleConversation *conv, void *data)
{
    printf("chat-left (%s)\n",
                    purple_conversation_get_name(conv));
}

static void
chat_topic_changed_cb(PurpleConversation *conv, const char *who,
                      const char *topic, void *data)
{
    printf(
                    "chat-topic-changed (%s topic changed to: \"%s\" by %s)\n",
                    purple_conversation_get_name(conv), topic,
                    (who) ? who : "unknown");
    purple_conversation_set_title(conv, topic);
    emit_add(purple_conversation_get_title(conv),purple_conversation_get_name(conv), purple_account_get_username(purple_conversation_get_account(conv)), 1);
}

static void connect_to_signals(void)
{

    void *core_handle     = purple_get_core();
    void *blist_handle    = purple_blist_get_handle();
    void *conn_handle     = purple_connections_get_handle();
    void *conv_handle     = purple_conversations_get_handle();
    void *accounts_handle = purple_accounts_get_handle();
    static int handle;


    purple_signal_connect(accounts_handle, "account-connecting",
                        &handle, PURPLE_CALLBACK(account_connecting_cb), NULL);
    purple_signal_connect(accounts_handle, "account-setting-info",
                        &handle, PURPLE_CALLBACK(account_setting_info_cb), NULL);
    purple_signal_connect(accounts_handle, "account-set-info",
                        &handle, PURPLE_CALLBACK(account_set_info_cb), NULL);
    purple_signal_connect(accounts_handle, "account-status-changed",
                        &handle, PURPLE_CALLBACK(account_status_changed), NULL);
    purple_signal_connect(accounts_handle, "account-alias-changed",
                        &handle, PURPLE_CALLBACK(account_alias_changed), NULL);
    purple_signal_connect(accounts_handle, "account-authorization-requested",
                        &handle, PURPLE_CALLBACK(account_authorization_requested_cb), NULL);
    purple_signal_connect(accounts_handle, "account-authorization-denied",
                        &handle, PURPLE_CALLBACK(account_authorization_denied_cb), NULL);
    purple_signal_connect(accounts_handle, "account-authorization-granted",
                        &handle, PURPLE_CALLBACK(account_authorization_granted_cb), NULL);

    /* Buddy List subsystem signals */
//    purple_signal_connect(blist_handle, "buddy-status-changed",
//                        &handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
//    purple_signal_connect(blist_handle, "buddy-idle-changed",
//                        &handle, PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
    purple_signal_connect(blist_handle, "buddy-signed-on",
                        &handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
    purple_signal_connect(blist_handle, "buddy-signed-off",
                        &handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
//    purple_signal_connect(blist_handle, "blist-node-added",
//                        &handle, PURPLE_CALLBACK(blist_node_added_cb), NULL);
//    purple_signal_connect(blist_handle, "blist-node-removed",
//                        &handle, PURPLE_CALLBACK(blist_node_removed_cb), NULL);
    purple_signal_connect(blist_handle, "buddy-icon-changed",
                        &handle, PURPLE_CALLBACK(buddy_icon_changed_cb), NULL);
    purple_signal_connect(blist_handle, "blist-node-aliased",
                        &handle, PURPLE_CALLBACK(blist_node_aliased), NULL);
//    purple_signal_connect(blist_handle, "blist-node-extended-menu",
//                        &handle, PURPLE_CALLBACK(blist_node_extended_menu_cb), NULL);

    /* Connection subsystem signals */
    purple_signal_connect(conn_handle, "signing-on",
                        &handle, PURPLE_CALLBACK(signing_on_cb), NULL);
    purple_signal_connect(conn_handle, "signed-on",
                        &handle, PURPLE_CALLBACK(signed_on_cb), NULL);
    purple_signal_connect(conn_handle, "signing-off",
                        &handle, PURPLE_CALLBACK(signing_off_cb), NULL);
    purple_signal_connect(conn_handle, "signed-off",
                        &handle, PURPLE_CALLBACK(signed_off_cb), NULL);
    purple_signal_connect(conn_handle, "connection-error",
                        &handle, PURPLE_CALLBACK(connection_error_cb), NULL);

    /* Conversations subsystem signals */
    purple_signal_connect(conv_handle, "writing-im-msg",
                        &handle, PURPLE_CALLBACK(writing_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "wrote-im-msg",
                        &handle, PURPLE_CALLBACK(wrote_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "sending-im-msg",
                        &handle, PURPLE_CALLBACK(sending_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "sent-im-msg",
                        &handle, PURPLE_CALLBACK(sent_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "receiving-im-msg",
                        &handle, PURPLE_CALLBACK(receiving_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "received-im-msg",
                        &handle, PURPLE_CALLBACK(received_im_msg_cb), NULL);
    purple_signal_connect(conv_handle, "writing-chat-msg",
                        &handle, PURPLE_CALLBACK(writing_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "wrote-chat-msg",
                        &handle, PURPLE_CALLBACK(wrote_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "sending-chat-msg",
                        &handle, PURPLE_CALLBACK(sending_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "sent-chat-msg",
                        &handle, PURPLE_CALLBACK(sent_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "receiving-chat-msg",
                        &handle, PURPLE_CALLBACK(receiving_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "received-chat-msg",
                        &handle, PURPLE_CALLBACK(received_chat_msg_cb), NULL);
    purple_signal_connect(conv_handle, "conversation-created",
                        &handle, PURPLE_CALLBACK(conversation_created_cb), NULL);
    purple_signal_connect(conv_handle, "deleting-conversation",
                        &handle, PURPLE_CALLBACK(deleting_conversation_cb), NULL);
//    purple_signal_connect(conv_handle, "buddy-typing",
//                        &handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
//    purple_signal_connect(conv_handle, "buddy-typing-stopped",
//                        &handle, PURPLE_CALLBACK(buddy_typing_stopped_cb), NULL);
    purple_signal_connect(conv_handle, "chat-buddy-joining",
                        &handle, PURPLE_CALLBACK(chat_buddy_joining_cb), NULL);
    purple_signal_connect(conv_handle, "chat-buddy-joined",
                        &handle, PURPLE_CALLBACK(chat_buddy_joined_cb), NULL);
    purple_signal_connect(conv_handle, "chat-buddy-flags",
                        &handle, PURPLE_CALLBACK(chat_buddy_flags_cb), NULL);
    purple_signal_connect(conv_handle, "chat-buddy-leaving",
                        &handle, PURPLE_CALLBACK(chat_buddy_leaving_cb), NULL);
    purple_signal_connect(conv_handle, "chat-buddy-left",
                        &handle, PURPLE_CALLBACK(chat_buddy_left_cb), NULL);
    purple_signal_connect(conv_handle, "chat-inviting-user",
                        &handle, PURPLE_CALLBACK(chat_inviting_user_cb), NULL);
    purple_signal_connect(conv_handle, "chat-invited-user",
                        &handle, PURPLE_CALLBACK(chat_invited_user_cb), NULL);
    purple_signal_connect(conv_handle, "chat-invited",
                        &handle, PURPLE_CALLBACK(chat_invited_cb), NULL);
    purple_signal_connect(conv_handle, "chat-joined",
                        &handle, PURPLE_CALLBACK(chat_joined_cb), NULL);
    purple_signal_connect(conv_handle, "chat-left",
                        &handle, PURPLE_CALLBACK(chat_left_cb), NULL);
    purple_signal_connect(conv_handle, "chat-topic-changed",
                        &handle, PURPLE_CALLBACK(chat_topic_changed_cb), NULL);

}

void writeMessage(const char* message, const char* fbid, const char* fba, int isChat) {
    if(!isChat) {
//        printf("im %d\n", isChat);
        PurpleConversation* conversation = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, fbid, purple_accounts_find(fba, "prpl-facebook"));
        if(conversation != NULL)
            purple_conv_im_send(PURPLE_CONV_IM(conversation), message);
        else {
            conversation = purple_conversation_new(PURPLE_CONV_TYPE_IM, purple_accounts_find(fba, "prpl-facebook"), fbid);
            purple_conv_im_send(PURPLE_CONV_IM(conversation), message);
        }
    } else {
//        printf("chat %d\n", isChat);
        PurpleConversation* conversation = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, fbid, purple_accounts_find(fba, "prpl-facebook"));
        if(conversation != NULL)
            purple_conv_chat_send(PURPLE_CONV_CHAT(conversation), message);
        else {
            conversation = purple_conversation_new(PURPLE_CONV_TYPE_CHAT, purple_accounts_find(fba, "prpl-facebook"), fbid);
            purple_conv_chat_send(PURPLE_CONV_CHAT(conversation), message);
        }
    }
}

void loadHistory(const char *fbid, const char *fba, int isChat) {
    if(!isChat) {
        PurpleConversation* conversation = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, fbid, purple_accounts_find(fba, "prpl-facebook"));//purple_blist_find_chat(purple_accounts_find(fba, "prpl-facebook"), fbid);
        if(conversation != NULL) {
            GList *l = g_list_last(purple_conversation_get_message_history(conversation));
            for (l; l != NULL; l = l->prev) {
                if(purple_conversation_message_get_flags(l->data) == PURPLE_MESSAGE_RECV)
                    reciveMessage(purple_conversation_get_name(conversation), purple_account_get_username(purple_conversation_get_account(conversation)), purple_buddy_get_alias(purple_find_buddy(purple_conversation_get_account(conversation),purple_conversation_message_get_sender(l->data))), purple_conversation_message_get_message(l->data), purple_conversation_message_get_timestamp(l->data),1);
                else if(purple_conversation_message_get_flags(l->data) == PURPLE_MESSAGE_SEND)
                    sendMessage(purple_conversation_get_name(conversation), purple_account_get_username(purple_conversation_get_account(conversation)), "Me", purple_conversation_message_get_message(l->data), purple_conversation_message_get_timestamp(l->data),1);
            }
        }
    } else {
        PurpleConversation* conversation = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, fbid, purple_accounts_find(fba, "prpl-facebook"));//purple_blist_find_chat(purple_accounts_find(fba, "prpl-facebook"), fbid);
        if(conversation != NULL) {
            GList *l = g_list_last(purple_conversation_get_message_history(conversation));
            for (l; l != NULL; l = l->prev) {
                if(purple_conversation_message_get_flags(l->data) == PURPLE_MESSAGE_RECV)
                    reciveMessage(purple_conversation_get_name(conversation), purple_account_get_username(purple_conversation_get_account(conversation)), purple_buddy_get_alias(purple_find_buddy(purple_conversation_get_account(conversation),purple_conversation_message_get_sender(l->data))), purple_conversation_message_get_message(l->data), purple_conversation_message_get_timestamp(l->data), 1);
                else if(purple_conversation_message_get_flags(l->data) == PURPLE_MESSAGE_SEND)
                    sendMessage(purple_conversation_get_name(conversation), purple_account_get_username(purple_conversation_get_account(conversation)), "Me", purple_conversation_message_get_message(l->data), purple_conversation_message_get_timestamp(l->data), 1);
            }
        }
    }
}

void login(const char* login, const char* password) {
    PurpleAccount *account = purple_account_new(login, "prpl-facebook"); //this could be prpl-aim, prpl-yahoo, prpl-msn, prpl-icq, etc.
    purple_account_set_password(account, password);
    purple_account_set_remember_password(account, TRUE);
    purple_accounts_add(account);
    purple_account_set_enabled(account, UI_ID, TRUE);
}

void enableAllAccounts() {
    GList *l = purple_accounts_get_all();
    for (l; l != NULL; l = l->next) {
        purple_account_set_enabled(l->data, UI_ID, TRUE);
    }
}

void* start( void* arg ) {
    signal(SIGCHLD, SIG_IGN);

    GMainLoop *loop = g_main_loop_new(NULL, FALSE);

    init_libpurple();

    printf("libpurple initialized. Running version %s.\n", purple_core_get_version()); //I like to see the version number

    connect_to_signals();

    enableAllAccounts();

    g_main_loop_run(loop);
}