/*
  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_new_problem.h"
#include "abrt_problems2_entry.h"

typedef struct
{
    AbrtP2Service *p2tnp_service;
    GVariant *p2tnp_problem_info;
    uid_t p2tnp_caller_uid;
    GUnixFDList *p2tnp_fd_list;
    AbrtP2Object *p2tnp_obj;        ///<< AbrtProblems2Entry
    bool p2tnp_wait_before_notify;
} AbrtP2TaskNewProblemPrivate;

struct _AbrtP2TaskNewProblem
{
    AbrtP2Task parent_instance;
    AbrtP2TaskNewProblemPrivate *pv;
};

static AbrtP2TaskCode abrt_p2_task_new_problem_run(AbrtP2Task *task,
            GError **error);

G_DEFINE_TYPE_WITH_PRIVATE(AbrtP2TaskNewProblem, abrt_p2_task_new_problem, ABRT_TYPE_P2_TASK)

static void abrt_p2_task_new_problem_finalize(GObject *gobject)
{
    AbrtP2TaskNewProblemPrivate *pv = abrt_p2_task_new_problem_get_instance_private(ABRT_P2_TASK_NEW_PROBLEM(gobject));
    g_variant_unref(pv->p2tnp_problem_info);

    if (pv->p2tnp_fd_list)
        g_object_unref(pv->p2tnp_fd_list);

    G_OBJECT_CLASS(abrt_p2_task_new_problem_parent_class)->finalize(gobject);
}

static void abrt_p2_task_remove_temporary_entry(AbrtP2TaskNewProblem *task,
            GError **error)
{
    if (task->pv->p2tnp_obj == NULL)
        return;

    AbrtP2Entry *entry = abrt_p2_object_get_node(task->pv->p2tnp_obj);

    log_debug("Task '%p': Removing temporary entry: %s",
              task,
              abrt_p2_entry_problem_id(entry));

    abrt_p2_entry_delete(entry,
                         /* act as super user to allow us to delete the temporary dir */0,
                         error);

    abrt_p2_object_destroy(task->pv->p2tnp_obj);

    task->pv->p2tnp_obj = NULL;
}

static void abrt_p2_task_new_problem_cancel(AbrtP2Task *task,
            GError **error)
{
    abrt_p2_task_remove_temporary_entry(ABRT_P2_TASK_NEW_PROBLEM(task), error);
}

static void abrt_p2_task_new_problem_class_init(AbrtP2TaskNewProblemClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS(klass);
    object_class->finalize = abrt_p2_task_new_problem_finalize;

    AbrtP2TaskClass *task_class = ABRT_P2_TASK_CLASS(klass);
    task_class->run = abrt_p2_task_new_problem_run;
    task_class->cancel = abrt_p2_task_new_problem_cancel;
}

static void abrt_p2_task_new_problem_init(AbrtP2TaskNewProblem *self)
{
    self->pv = abrt_p2_task_new_problem_get_instance_private(self);
}

AbrtP2TaskNewProblem *abrt_p2_task_new_problem_new(AbrtP2Service *service,
            GVariant *problem_info,uid_t caller_uid,
            GUnixFDList *fd_list)
{
    AbrtP2TaskNewProblem *task = g_object_new(TYPE_ABRT_P2_TASK_NEW_PROBLEM, NULL);

    task->pv->p2tnp_service = service;
    task->pv->p2tnp_problem_info = problem_info;
    task->pv->p2tnp_caller_uid = caller_uid;
    task->pv->p2tnp_fd_list = fd_list;
    task->pv->p2tnp_wait_before_notify = false;

    return task;
}

void abrt_p2_task_new_problem_wait_before_notify(AbrtP2TaskNewProblem *task,
            bool value)
{
    task->pv->p2tnp_wait_before_notify = value;
}

static AbrtP2Object *abrt_p2_task_new_problem_create_directory_task(AbrtP2TaskNewProblem *task,
            GError **error)
{
    int r = abrt_p2_service_user_can_create_new_problem(task->pv->p2tnp_service, task->pv->p2tnp_caller_uid);
    if (r == 0)
    {
        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
                    "Too many problems have been recently created");

        return NULL;
    }
    if (r == -E2BIG)
    {
        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
                    "No more problems can be created");

        return NULL;
    }
    if (r < 0)
    {
        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
                    "Failed to check NewProblem limits");

        return NULL;
    }

    char *problem_id = abrt_p2_service_save_problem(task->pv->p2tnp_service,
                                                    task->pv->p2tnp_problem_info,
                                                    task->pv->p2tnp_fd_list,
                                                    task->pv->p2tnp_caller_uid, error);
    if (*error != NULL)
        return NULL;

    AbrtP2Entry *entry = abrt_p2_entry_new_with_state(problem_id,
                                                      ABRT_P2_ENTRY_STATE_NEW);

    AbrtP2Object *obj = abrt_p2_service_register_entry(task->pv->p2tnp_service,
                                                       entry,
                                                       error);

    if (*error != NULL)
        return NULL;

    return obj;
}

static int abrt_p2_task_new_problem_notify_directory_task(AbrtP2TaskNewProblem *task,
            char **new_path, GError **error)
{
    AbrtP2Entry *entry = abrt_p2_object_get_node(task->pv->p2tnp_obj);

    char *message = NULL;
    const char *problem_id = abrt_p2_entry_problem_id(entry);
    int r = notify_new_path_with_response(problem_id, &message);
    if (r < 0)
    {
        log_debug("Task '%p': Failed to communicate with the problems daemon",
                  task);

        GError *local_error = NULL;
        abrt_p2_entry_delete(entry,
                             /* allow us to delete the temporary dir */0,
                             &local_error);

        if (local_error != NULL)
        {
            error_msg("Can't remove temporary problem directory: %s",
                      local_error->message);

            g_error_free(local_error);
        }

        abrt_p2_object_destroy(task->pv->p2tnp_obj);
        task->pv->p2tnp_obj = NULL;

        g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
                    "Failed to notify the new problem directory");

        return r;
    }

    gint32 code;
    log_debug("Task '%p': New path processed: %d", task, r);
    if (r == 303)
    {
        /* 303 - the daemon found a local duplicate problem */

        abrt_p2_object_destroy(task->pv->p2tnp_obj);
        task->pv->p2tnp_obj = NULL;

        AbrtP2Object *obj = abrt_p2_service_get_entry_for_problem(task->pv->p2tnp_service,
                                                                  message,
                                                                  ABRT_P2_SERVICE_ENTRY_LOOKUP_NOFLAGS,
                                                                  error);
        if (obj == NULL)
        {
            error_msg("Problem Entry for directory '%s' does not exist", message);
            free(message);
            return ABRT_P2_TASK_CODE_ERROR;
        }

        *new_path = xstrdup(abrt_p2_object_path(obj));
        code = ABRT_P2_TASK_NEW_PROBLEM_DUPLICATE;

        log_debug("Task '%p': New occurrence of '%s'",
                  task,
                  *new_path);

        /* TODO: what about to teach the service to understand task's signals? */
        abrt_p2_service_notify_entry_object(task->pv->p2tnp_service,
                                            obj,
                                            error);
    }
    else if (r == 410)
    {
        /* 410 - the problem was refused by the daemon */
        log_debug("Task '%p': Problem dropped", task);

        abrt_p2_object_destroy(task->pv->p2tnp_obj);
        task->pv->p2tnp_obj = NULL;

        code = ABRT_P2_TASK_NEW_PROBLEM_DROPPED;
    }
    else if (r == 200)
    {
        /* 200 - the problem was accepted */
        *new_path = xstrdup(abrt_p2_object_path(task->pv->p2tnp_obj));

        code = ABRT_P2_TASK_NEW_PROBLEM_ACCEPTED;

        abrt_p2_entry_set_state(entry, ABRT_P2_ENTRY_STATE_COMPLETE);

        log_debug("Task '%p': New problem '%s'", task, *new_path);

        /* TODO: what about to teach the service to understand task's signals? */
        abrt_p2_service_notify_entry_object(task->pv->p2tnp_service,
                                            task->pv->p2tnp_obj,
                                            error);
    }
    else
    {
        log_debug("Task '%p': Problem was invalid", task);

        abrt_p2_entry_delete(entry,
                             /* allow us to delete the temporary dir */0,
                             error);

        abrt_p2_object_destroy(task->pv->p2tnp_obj);
        task->pv->p2tnp_obj = NULL;

        code = ABRT_P2_TASK_NEW_PROBLEM_INVALID_DATA;
    }

    free(message);
    return code;
}

static AbrtP2TaskCode abrt_p2_task_new_problem_run(AbrtP2Task *task, GError **error)
{
    AbrtP2TaskNewProblem *np = ABRT_P2_TASK_NEW_PROBLEM(task);

    /* Create the temporary entry. If you ask the question how it is possible
     * that the object already exist, then the answer is that if user requested
     * to stop the task after creation of the object. */
    if (np->pv->p2tnp_obj == NULL)
    {
        AbrtP2Object *obj = abrt_p2_task_new_problem_create_directory_task(np, error);
        if (obj == NULL)
            return ABRT_P2_TASK_CODE_ERROR;

        const char *temporary_entry_path = abrt_p2_object_path(obj);
        GVariant *detail_path = g_variant_new_string(temporary_entry_path);
        abrt_p2_task_add_detail(task, "NewProblem.TemporaryEntry", detail_path);

        log_debug("Created temporary entry '%s' for task '%p'",
                  temporary_entry_path,
                  task);

        np->pv->p2tnp_obj = obj;

        if (abrt_p2_task_is_cancelled(task))
            return ABRT_P2_TASK_CODE_CANCELLED;

        if (np->pv->p2tnp_wait_before_notify)
        {
            /* Stop the task to allow users to modify the temporary object */
            log_debug("Stopping NewProblem task '%p'", task);

            return ABRT_P2_TASK_CODE_STOP;
        }
    }

    char *new_path = NULL;
    gint32 code = abrt_p2_task_new_problem_notify_directory_task(np,
                                                                 &new_path,
                                                                 error);
    if (code < 0)
        return ABRT_P2_TASK_CODE_ERROR;

    GVariantDict response;
    g_variant_dict_init(&response, NULL);

    if (new_path != NULL)
    {
        g_variant_dict_insert(&response,
                              "NewProblem.Entry",
                              "s",
                              new_path);
        free(new_path);
    }

    log_debug("NewProblem task '%p' has successfully finished", task);

    abrt_p2_task_set_response(task,
                              g_variant_dict_end(&response));

    return ABRT_P2_TASK_CODE_DONE + code;
}