/*

  Copyright (C) 2015  ABRT team

  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

*/

#include "abrt_problems2_task.h"

enum {

    SN_STATUS_CHANGED,

    SN_LAST_SIGNAL

} SignalNumber;

static guint s_signals[SN_LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE_WITH_PRIVATE(AbrtP2Task, abrt_p2_task, G_TYPE_OBJECT)

static void abrt_p2_task_finalize(GObject *gobject)

{

    AbrtP2TaskPrivate *pv = abrt_p2_task_get_instance_private(ABRT_P2_TASK(gobject));

    g_variant_unref(pv->p2t_details);

    if (pv->p2t_results != NULL)

        g_variant_unref(pv->p2t_results);

}

static void abrt_p2_task_class_init(AbrtP2TaskClass *klass)

{

    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    object_class->finalize = abrt_p2_task_finalize;

    s_signals[SN_STATUS_CHANGED] = g_signal_new ("status-changed",

                                                 G_TYPE_FROM_CLASS (klass),

                                                 G_SIGNAL_RUN_LAST,

                                                 G_STRUCT_OFFSET(AbrtP2TaskClass, status_changed),

                                                 /*accumulator*/NULL, /*accu_data*/NULL,

                                                 g_cclosure_marshal_VOID__INT,

                                                 G_TYPE_NONE,

                                                 /*n_params*/1,

                                                 G_TYPE_INT);

}

#define ABRT_P2_TASK_ABSTRACT_FUNCTION_CALL(ret, method, task, ...) \

    do { if (ABRT_P2_TASK_GET_CLASS(task)->method == NULL) { \

            error_msg("Undefined Task abstract function "#method); \

            abort(); \

         }\

         ret = ABRT_P2_TASK_GET_CLASS(task)->method(task, __VA_ARGS__); } while(0)

#define ABRT_P2_TASK_VIRTUAL_FUNCTION_CALL(method, task, ...) \

    do { if (ABRT_P2_TASK_GET_CLASS(task)->method != NULL) \

            ABRT_P2_TASK_GET_CLASS(task)->method(task, __VA_ARGS__); } while(0)

#define ABRT_P2_TASK_VIRTUAL_CANCEL(task, error) \

    ABRT_P2_TASK_VIRTUAL_FUNCTION_CALL(cancel, task, error)

#define ABRT_P2_TASK_VIRTUAL_FINISH(task, error) \

    ABRT_P2_TASK_VIRTUAL_FUNCTION_CALL(finish, task, error)

#define ABRT_P2_TASK_VIRTUAL_START(task, options, error) \

    ABRT_P2_TASK_VIRTUAL_FUNCTION_CALL(start, task, options, error)

static void abrt_p2_task_init(AbrtP2Task *self)

{

    self->pv = abrt_p2_task_get_instance_private(self);

    self->pv->p2t_details = g_variant_new("a{sv}", NULL);

}

static void abrt_p2_task_change_status(AbrtP2Task *task,

            AbrtP2TaskStatus status)

{

    if (task->pv->p2t_status == status)

        return;

    task->pv->p2t_status = status;

    g_signal_emit(task,

                  s_signals[SN_STATUS_CHANGED],

                  0,

                  status);

}

AbrtP2TaskStatus abrt_p2_task_status(AbrtP2Task *task)

{

    return task->pv->p2t_status;

}

GVariant *abrt_p2_task_details(AbrtP2Task *task)

{

    return g_variant_ref(task->pv->p2t_details);

}

void abrt_p2_task_add_detail(AbrtP2Task *task,

            const char *key,

            GVariant *value)

{

    GVariantDict dict;

    g_variant_dict_init(&dict, task->pv->p2t_details);

    g_variant_dict_insert(&dict, key, "v", value);

    if (task->pv->p2t_details)

        g_variant_unref(task->pv->p2t_details);

    task->pv->p2t_details = g_variant_dict_end(&dict);

}

void abrt_p2_task_set_response(AbrtP2Task *task,

            GVariant *response)

{

    if (task->pv->p2t_results != NULL)

        log_warning("Task already has response assigned");

    task->pv->p2t_results = response;

}

bool abrt_p2_task_is_cancelled(AbrtP2Task *task)

{

    return (task->pv->p2t_cancellable

              && g_cancellable_is_cancelled(task->pv->p2t_cancellable))

           || task->pv->p2t_status == ABRT_P2_TASK_STATUS_CANCELED;

}

void abrt_p2_task_cancel(AbrtP2Task *task,

            GError **error)

{

    if (abrt_p2_task_is_cancelled(task))

        return;

    if (task->pv->p2t_status == ABRT_P2_TASK_STATUS_RUNNING)

        g_cancellable_cancel(task->pv->p2t_cancellable);

    else if (task->pv->p2t_status == ABRT_P2_TASK_STATUS_STOPPED)

    {

        ABRT_P2_TASK_VIRTUAL_CANCEL(task, error);

        if (*error == NULL)

            abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_CANCELED);

    }

    else

        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,

                    "Task is not in the state that allows cancelling");

}

void abrt_p2_task_finish(AbrtP2Task *task,

            GVariant **result,

            gint32 *code,

            GError **error)

{

    if (   task->pv->p2t_status != ABRT_P2_TASK_STATUS_DONE

        && task->pv->p2t_status != ABRT_P2_TASK_STATUS_FAILED)

    {

        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,

                "Cannot finalize undone task");

        return;

    }

    ABRT_P2_TASK_VIRTUAL_FINISH(task, error);

    if (*error != NULL)

        return;

    if (task->pv->p2t_results)

        *result = g_variant_ref(task->pv->p2t_results);

    else

        *result = g_variant_new("a{sv}", NULL);

    *code = task->pv->p2t_code;

}

static void abrt_p2_task_finish_gtask(GObject *source_object,

           GAsyncResult *result,

           gpointer user_data)

{

    AbrtP2Task *task = ABRT_P2_TASK(source_object);

    if (!g_task_is_valid(result, task))

    {

        error_msg("BUG:%s:%s: invalid GTask", __FILE__, __func__);

        return;

    }

    GError *error = NULL;

    const gint32 code = g_task_propagate_int(G_TASK(result), &error);

    if (code == ABRT_P2_TASK_CODE_STOP)

    {

        log_debug("Task stopped");

        abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_STOPPED);

    }

    else if (code >= ABRT_P2_TASK_CODE_DONE)

    {

        log_debug("Task done");

        task->pv->p2t_code = code - ABRT_P2_TASK_CODE_DONE;

        abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_DONE);

    }

    else if (abrt_p2_task_is_cancelled(task))

    {

        if (error != NULL)

        {

            log_debug("Task canceled with error: %s", error->message);

            g_error_free(error);

            error = NULL;

        }

        else

            log_debug("Task canceled");

        ABRT_P2_TASK_VIRTUAL_CANCEL(task, &error);

        abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_CANCELED);

    }

    else

    {

        GVariantDict response;

        g_variant_dict_init(&response, NULL);

        if (error != NULL)

        {

            log_debug("Task failed with error: %s", error->message);

            g_variant_dict_insert(&response,

                                  "Error.Message",

                                  "s",

                                  error->message);

            g_error_free(error);

        }

        else if (code == ABRT_P2_TASK_CODE_ERROR)

        {

            log_debug("Task failed without error message");

            g_variant_dict_insert(&response,

                                  "Error.Message",

                                  "s",

                                  "Task failed");

        }

        else

        {

            error_msg("BUG:%s:%s: unknown Task return code: %d",

                      __FILE__,

                      __func__,

                      code);

            g_variant_dict_insert(&response,

                                  "Error.Message",

                                  "s",

                                  "Internal error: Invalid Task return code");

        }

        abrt_p2_task_set_response(task, g_variant_dict_end(&response));

        abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_FAILED);

    }

    g_object_unref(task->pv->p2t_cancellable);

    task->pv->p2t_cancellable = NULL;

}

static void abrt_p2_task_thread(GTask *task,

            gpointer source_object,

            gpointer task_data,

            GCancellable *cancellable)

{

    AbrtP2Task *stask = source_object;

    GError *error = NULL;

    gint32 code;

    ABRT_P2_TASK_ABSTRACT_FUNCTION_CALL(code, run, stask, &error);

    if (error == NULL)

        g_task_return_int(task, code);

    else

        g_task_return_error(task, error);

}

void abrt_p2_task_start(AbrtP2Task *task,

            GVariant *options,

            GError **error)

{

    if (   task->pv->p2t_status != ABRT_P2_TASK_STATUS_NEW

        && task->pv->p2t_status != ABRT_P2_TASK_STATUS_STOPPED)

    {

        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,

                    "Cannot start task that is not new or stopped");

        return;

    }

    ABRT_P2_TASK_VIRTUAL_START(task, options, error);

    if (*error != NULL)

        return;

    task->pv->p2t_cancellable = g_cancellable_new();

    GTask *gtask = g_task_new(task,

                              task->pv->p2t_cancellable,

                              abrt_p2_task_finish_gtask,

                              NULL);

    g_task_run_in_thread(gtask, abrt_p2_task_thread);

    abrt_p2_task_change_status(task, ABRT_P2_TASK_STATUS_RUNNING);

    g_object_unref(gtask);

}

static void abrt_p2_task_autonomous_cb(AbrtP2Task *task,

            gint32 status,

            gpointer user_data)

{

    switch(status)

    {

        case ABRT_P2_TASK_STATUS_NEW:

            error_msg("Autonomous task has changed status to NEW");

            break;

        case ABRT_P2_TASK_STATUS_RUNNING:

            log_debug("Autonomous task has successfully started");

            break;

        case ABRT_P2_TASK_STATUS_STOPPED:

            {

                error_msg("Autonomous task has been stopped and will be canceled");

                GError *error = NULL;

                abrt_p2_task_cancel(task, &error);

                if (error != NULL)

                {

                    error_msg("Failed to cancel stopped autonomous task: %s",

                               error->message);

                    g_error_free(error);

                    g_object_unref(task);

                }

            }

            break;

        case ABRT_P2_TASK_STATUS_CANCELED:

            log_notice("Autonomous task has been canceled");

            g_object_unref(task);

            break;

        case ABRT_P2_TASK_STATUS_FAILED:

            {

                GVariant *response;

                gint32 code;

                GError *error = NULL;

                abrt_p2_task_finish(task, &response, &code, &error);

                if (error != NULL)

                {

                    error_msg("Failed to finish canceled task: %s", error->message);

                }

                else

                {

                    const char *error_message;

                    g_variant_lookup(response, "Error.Message", "&s", &error_message);

                    error_msg("Autonomous task has failed: %d: %s", code, error_message);

                    g_variant_unref(response);

                }

                g_object_unref(task);

            }

            break;

        case ABRT_P2_TASK_STATUS_DONE:

            log_notice("Autonomous task has been successfully finished");

            g_object_unref(task);

            break;

        default:

            error_msg("BUG: %s: forgotten task state", __func__);

            break;

    }

}

void abrt_p2_task_autonomous_run(AbrtP2Task *task,

        GError **error)

{

    g_signal_connect(task,

                     "status-changed",

                     G_CALLBACK(abrt_p2_task_autonomous_cb),

                     NULL);

    abrt_p2_task_start(task, NULL, error);

}