/*
 * transmission-remote-gtk - A GTK RPC client to Transmission
 * Copyright (C) 2011  Alan Fitton

 * 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 02110-1301 USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdlib.h>

#include <curl/curl.h>
#include <curl/easy.h>

#include <glib/gi18n.h>
#include <glib-object.h>
#include <gtk/gtk.h>
#include <json-glib/json-glib.h>
#ifdef HAVE_LIBUNIQUE
#include <unique/unique.h>
#elif WIN32
#include <windows.h>
#endif

#include "trg-main-window.h"
#include "trg-client.h"
#include "util.h"

/* The file with the main() function. It converts arguments into a NULL terminated
 * array, with relative paths converted to absolute paths.
 *
 * Much of the code here is to optionally handle passing torrent files/URLs to
 * a first instance. UNIX can use libunique (should alternatively use
 * GApplication for GNOME3). Windows uses the mailslot feature in the
 * native Win32 API, so there is no dependency on dbus etc.
 */

#define TRG_LIBUNIQUE_DOMAIN "uk.org.eth0.trg"
#define TRG_MAILSLOT_NAME "\\\\.\\mailslot\\TransmissionRemoteGTK"      //Name given to the Mailslot
#define MAILSLOT_BUFFER_SIZE 1024*32

#ifdef HAVE_LIBUNIQUE

enum {
    COMMAND_0,
    COMMAND_ADD
};

static UniqueResponse
message_received_cb(UniqueApp * app G_GNUC_UNUSED,
                    gint command,
                    UniqueMessageData * message,
                    guint time_, gpointer user_data)
{
    TrgMainWindow *win;
    UniqueResponse res;
    gchar **uris;

    win = TRG_MAIN_WINDOW(user_data);

    switch (command) {
    case UNIQUE_ACTIVATE:
        gtk_window_set_screen(GTK_WINDOW(user_data),
                              unique_message_data_get_screen(message));
        gtk_window_present_with_time(GTK_WINDOW(user_data), time_);
        res = UNIQUE_RESPONSE_OK;
        break;
    case COMMAND_ADD:
        uris = unique_message_data_get_uris(message);
        res =
            trg_add_from_filename(win,
                                  uris) ? UNIQUE_RESPONSE_OK :
            UNIQUE_RESPONSE_FAIL;
        break;
    default:
        res = UNIQUE_RESPONSE_OK;
        break;
    }

    return res;
}

#elif WIN32

struct trg_mailslot_recv_args {
    TrgMainWindow *win;
    gchar **uris;
    gboolean present;
};

/* to be queued into the glib main loop with g_idle_add() */

static gboolean mailslot_recv_args(gpointer data)
{
    struct trg_mailslot_recv_args *args =
        (struct trg_mailslot_recv_args *) data;

    if (args->present) {
        gtk_window_deiconify(GTK_WINDOW(args->win));
        gtk_window_present(GTK_WINDOW(args->win));
    }

    if (args->uris)
        trg_add_from_filename(args->win, args->uris);

    g_free(args);

    return FALSE;
}

static gpointer mailslot_recv_thread(gpointer data)
{
    TrgMainWindow *win = TRG_MAIN_WINDOW(data);
    JsonParser *parser;
    char szBuffer[MAILSLOT_BUFFER_SIZE];
    HANDLE hMailslot;
    DWORD cbBytes;
    BOOL bResult;

    hMailslot = CreateMailslot(TRG_MAILSLOT_NAME,       // mailslot name
                               MAILSLOT_BUFFER_SIZE,    // input buffer size
                               MAILSLOT_WAIT_FOREVER,   // no timeout
                               NULL);   // default security attribute

    if (INVALID_HANDLE_VALUE == hMailslot) {
        g_error("\nError occurred while creating the mailslot: %d",
                GetLastError());
        return NULL;            //Error
    }

    while (1) {
        bResult = ReadFile(hMailslot,   // handle to mailslot
                           szBuffer,    // buffer to receive data
                           sizeof(szBuffer),    // size of buffer
                           &cbBytes,    // number of bytes read
                           NULL);       // not overlapped I/O

        if ((!bResult) || (0 == cbBytes)) {
            g_error("Mailslot error from client: %d", GetLastError());
            break;
        }

        parser = json_parser_new();

        if (json_parser_load_from_data(parser, szBuffer, cbBytes, NULL)) {
            JsonNode *node = json_parser_get_root(parser);
            JsonObject *obj = json_node_get_object(node);
            struct trg_mailslot_recv_args *args =
                g_new0(struct trg_mailslot_recv_args, 1);

            args->present = json_object_has_member(obj, "present")
                && json_object_get_boolean_member(obj, "present");
            args->win = win;

            if (json_object_has_member(obj, "args")) {
                JsonArray *array =
                    json_object_get_array_member(obj, "args");
                GList *arrayList = json_array_get_elements(array);

                if (arrayList) {
                    guint arrayLength = g_list_length(arrayList);
                    guint i = 0;
                    GList *li;

                    args->uris = g_new0(gchar *, arrayLength + 1);

                    for (li = arrayList; li; li = g_list_next(li)) {
                        const gchar *liStr =
                            json_node_get_string((JsonNode *) li->data);
                        args->uris[i++] = g_strdup(liStr);
                    }

                    g_list_free(arrayList);
                }
            }

            json_node_free(node);

            g_idle_add(mailslot_recv_args, args);
        }

        g_object_unref(parser);
    }

    CloseHandle(hMailslot);
    return NULL;                //Success
}

static int mailslot_send_message(HANDLE h, gchar ** args)
{
    DWORD cbBytes;
    JsonNode *node = json_node_new(JSON_NODE_OBJECT);
    JsonObject *obj = json_object_new();
    JsonArray *array = json_array_new();
    JsonGenerator *generator;
    gchar *msg;
    int i;

    if (args) {
        for (i = 0; args[i]; i++)
            json_array_add_string_element(array, args[i]);

        json_object_set_array_member(obj, "args", array);

        g_strfreev(args);
    } else {
        json_object_set_boolean_member(obj, "present", TRUE);
    }

    json_node_take_object(node, obj);

    generator = json_generator_new();
    json_generator_set_root(generator, node);
    msg = json_generator_to_data(generator, NULL);

    json_node_free(node);
    g_object_unref(generator);

    WriteFile(h,                // handle to mailslot
              msg,              // buffer to write from
              strlen(msg) + 1,  // number of bytes to write, include the NULL
              &cbBytes,         // number of bytes written
              NULL);

    CloseHandle(h);
    g_free(msg);

    return 0;
}

#endif

static gboolean is_minimised_arg(gchar * arg)
{
    return !g_strcmp0(arg, "-m")
        || !g_strcmp0(arg, "--minimized")
        || !g_strcmp0(arg, "/m");
}

static gboolean should_be_minimised(int argc, char *argv[])
{
    int i;
    for (i = 1; i < argc; i++)
        if (is_minimised_arg(argv[i]))
            return TRUE;

    return FALSE;
}

static gchar **convert_args(int argc, char *argv[])
{
    gchar *cwd = g_get_current_dir();
    gchar **files = NULL;

    if (argc > 1) {
        GSList *list = NULL;
        int i;

        for (i = 1; i < argc; i++) {
            if (is_minimised_arg(argv[i])) {
                continue;
            } else if (!is_url(argv[i]) && !is_magnet(argv[i])
                       && g_file_test(argv[i], G_FILE_TEST_IS_REGULAR)
                       && !g_path_is_absolute(argv[i])) {
                list = g_slist_append(list,
                                      g_build_path(G_DIR_SEPARATOR_S, cwd,
                                                   argv[i], NULL));
            } else {
                list = g_slist_append(list, g_strdup(argv[i]));
            }
        }

        if (list) {
            GSList *li;
            files = g_new0(gchar *, g_slist_length(list) + 1);
            i = 0;
            for (li = list; li; li = g_slist_next(li)) {
                files[i++] = li->data;
            }
            g_slist_free(list);
        }
    }

    g_free(cwd);

    return files;
}

int main(int argc, char *argv[])
{
    int returnValue = EXIT_SUCCESS;
    TrgMainWindow *window;
    TrgClient *client;
    gchar **args = convert_args(argc, argv);
    gboolean withUnique;
#ifdef HAVE_LIBUNIQUE
    UniqueApp *app = NULL;
#endif
#ifdef WIN32
    gchar *localedir, *moddir;
    HANDLE hMailSlot;
#endif
#ifdef TRG_MEMPROFILE
    GMemVTable gmvt = { malloc, realloc, free, calloc, malloc, realloc };
    g_mem_set_vtable(&gmvt);
    g_mem_set_vtable(glib_mem_profiler_table);
    g_mem_profile();
#endif

    g_type_init();
    g_thread_init(NULL);
    gtk_init(&argc, &argv);

    g_set_application_name(PACKAGE_NAME);
#ifdef WIN32
    moddir = g_win32_get_package_installation_directory_of_module(NULL);
    localedir = g_build_path(G_DIR_SEPARATOR_S, moddir, "share", "locale",
                             NULL);
    g_free(moddir);
    bindtextdomain(GETTEXT_PACKAGE, localedir);
    g_free(localedir);
#else
    bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
#endif
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);

    withUnique = (g_getenv("TRG_NOUNIQUE") == NULL);

#ifdef HAVE_LIBUNIQUE
    if (withUnique)
        app = unique_app_new_with_commands(TRG_LIBUNIQUE_DOMAIN, NULL,
                                           "add", COMMAND_ADD, NULL);

    if (withUnique && unique_app_is_running(app)) {
        UniqueCommand command;
        UniqueResponse response;
        UniqueMessageData *message;

        if (args) {
            command = COMMAND_ADD;
            message = unique_message_data_new();
            unique_message_data_set_uris(message, args);
            g_strfreev(args);
        } else {
            command = UNIQUE_ACTIVATE;
            message = NULL;
        }

        response = unique_app_send_message(app, command, message);
        unique_message_data_free(message);

        if (response != UNIQUE_RESPONSE_OK)
            returnValue = EXIT_FAILURE;
    } else {
#elif WIN32
    hMailSlot = CreateFile(TRG_MAILSLOT_NAME,   // mailslot name
                           GENERIC_WRITE,       // mailslot write only
                           FILE_SHARE_READ,     // required for mailslots
                           NULL,        // default security attributes
                           OPEN_EXISTING,       // opens existing mailslot
                           FILE_ATTRIBUTE_NORMAL,       // normal attributes
                           NULL);       // no template file

    if (INVALID_HANDLE_VALUE != hMailSlot) {
        returnValue = mailslot_send_message(hMailSlot, args);
    } else {
#endif
        client = trg_client_new();

        curl_global_init(CURL_GLOBAL_ALL);

        window =
            trg_main_window_new(client, should_be_minimised(argc, argv));

#ifdef HAVE_LIBUNIQUE
        if (withUnique) {
            g_signal_connect(app, "message-received",
                             G_CALLBACK(message_received_cb), window);
        }
#elif WIN32
        g_thread_create(mailslot_recv_thread, window, FALSE, NULL);
#endif

        auto_connect_if_required(window, args);
        gtk_main();

        curl_global_cleanup();
#ifdef HAVE_LIBUNIQUE
    }

    if (withUnique)
        g_object_unref(app);
#elif WIN32
    }
#endif

    return returnValue;
}