/*
    Copyright (C) 2011  ABRT Team
    Copyright (C) 2011  RedHat inc.

    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 <json.h>
#include <rpm/rpmts.h>
#include <rpm/rpmcli.h>
#include <rpm/rpmdb.h>
#include <rpm/rpmpgp.h>

#include <libreport/internal_libreport.h>
#include <libreport/libreport_curl.h>
#include <libreport/client.h>

#include "libabrt.h"

//699198,705037,705036

/* bodhi returns json structure

{
 "rows_per_page": 20,
    "total": 1,
    "chrome": true,
    "display_user": true,
    "pages": 1,
    "updates": [
       {
        "close_bugs": true,
        "old_updateid": "FEDORA-2015-13720",
        "pushed": true,
        "require_testcases": false,
        "critpath": false,
        "date_approved": null,
        "stable_karma": null,
        "date_pushed": "2015-08-19 04:49:00",
        "requirements": null,
        "severity": "unspecified",
        "title": "hwloc-1.11.0-3.fc22",
        "suggest": "unspecified",
        "require_bugs": false,
        "comments": [
           {
            "bug_feedback": [],
            "user_id": 91,
            "text": "This update has been submitted for testing by jhladky. ",
            "testcase_feedback": [],
            "karma_critpath": 0,
            "update": 21885,
            "update_id": 21885,
            "karma": 0,
            "anonymous": false,
            "timestamp": "2015-08-18 13:38:35",
            "id": 166016,
            "user": {"stacks": [],
                "name": "bodhi",
                "avatar": "https://apps.fedoraproject.org/img/icons/bodhi-24.png"}
           },
           {
           ...
           }
        ],
        "updateid": "FEDORA-2015-13720",
        "cves": [],
        "type": "bugfix",
        "status": "testing",
        "date_submitted": "2015-08-18 13:37:26",
        "unstable_karma": null,
        "submitter": "jhladky",
        "user":
           {
            "stacks": [],
            "buildroot_overrides": [],
            "name": "jhladky",
            "avatar": "https://seccdn.libravatar.org/avatar/b838b78fcf707a13cdaeb1c846d514e614d617cbf2c106718e71cb397607f59b?s=24&d=retro"
           },
        "locked": false,
        "builds": [{"override": null,
            "nvr": "hwloc-1.11.0-3.fc22"}],
        "date_modified": null,
        "test_cases": [],
        "notes": "Fix for BZ1253977",
        "request": null,
        "bugs": [
           {
            "bug_id": 1253977,
            "security": false,
            "feedback": [],
            "parent": false,
            "title": "conflict between hwloc-libs-1.11.0-1.fc22.i686 and hwloc-libs-1.11.0-1.fc22.x86_64"
           }
        ],
        "alias": "FEDORA-2015-13720",
        "karma": 0,
        "release":
           {
            "dist_tag": "f22",
            "name": "F22",
            "testing_tag": "f22-updates-testing",
            "pending_stable_tag": "f22-updates-pending",
            "long_name": "Fedora 22",
            "state": "current",
            "version": "22",
            "override_tag": "f22-override",
            "branch": "f22",
            "id_prefix": "FEDORA",
            "pending_testing_tag": "f22-updates-testing-pending",
            "stable_tag": "f22-updates",
            "candidate_tag": "f22-updates-candidate"
           }
       }
    ],
    "display_request": true,
    "page": 1
}
*/

static const char *bodhi_url = "https://bodhi.fedoraproject.org/updates";

struct bodhi {
    char *nvr;
#if 0
    char *date_pushed;
    char *status;
    char *dist_tag;

    GList *bz_ids;
#endif
};

enum {
    BODHI_READ_STR,
    BODHI_READ_INT,
    BODHI_READ_JSON_OBJ,
};

static void free_bodhi_item(struct bodhi *b)
{
    if (!b)
        return;

    free(b->nvr);

#if 0
    list_free_with_free(b->bz_ids);
    free(b->date_pushed);
    free(b->status);
    free(b->dist_tag);
#endif

    free(b);
}

static void bodhi_read_value(json_object *json, const char *item_name,
                             void *value, int flags)
{
    json_object *j = NULL;
    if (!json_object_object_get_ex(json, item_name, &j))
    {
        error_msg("'%s' section is not available", item_name);
        return;
    }

    switch (flags) {
    case BODHI_READ_INT:
        *(int *) value = json_object_get_int(j);
        break;
    case BODHI_READ_STR:
        *(char **) value = (char *) strtrimch(xstrdup(json_object_to_json_string(j)), '"');
        break;
    case BODHI_READ_JSON_OBJ:
        *(json_object **) value = (json_object *) j;
        break;
    };
}

#if 0
static void print_bodhi(struct bodhi *b)
{
    for (GList *l = b->nvr; l; l = l->next)
        printf("'%s' ", (char *)l->data);

    for (GList *l = b->name; l; l = l->next)
        printf("'%s' ", (char *)l->data);

    if (b->date_pushed)
        printf(" '%s'", b->date_pushed);

    if (b->status)
        printf(" '%s'", b->status);

    if (b->dist_tag)
        printf(" '%s'", b->dist_tag);

    printf(" %i", b->karma);


/*
    for (GList *li = b->bz_ids; li; li = li->next)
        printf(" %i", *(int*) li->data);
*/
    puts("");
}
#endif

/* bodhi returns following json structure in case of error
{
   "status": "error",
   "errors":
              [
                {
                   "location": "querystring",
                   "name": "releases",
                   "description": "Invalid releases specified: Rawhide"
                }
              ]
}
*/
static void bodhi_print_errors_from_json(json_object *json)
{

    json_object *errors_array = NULL;
    bodhi_read_value(json, "errors", &errors_array, BODHI_READ_JSON_OBJ);
    if (!errors_array)
    {
        error_msg("Error: unable to read 'errors' array from json");
        return;
    }

    int errors_len = json_object_array_length(errors_array);
    for (int i = 0; i < errors_len; ++i)
    {
        json_object *error = json_object_array_get_idx(errors_array, i);
        if (!error)
        {
            error_msg("Error: unable to get 'error[%d]'", i);
            json_object_put(errors_array);
            return;
        }

        char *desc_item = NULL;
        bodhi_read_value(error, "description", &desc_item, BODHI_READ_STR);
        if (!desc_item)
        {
            error_msg("Error: unable to get 'description' from 'error[%d]'", i);
            continue;
        }

        error_msg("Error: %s", desc_item);
        json_object_put(error);
        free(desc_item);
    }

    json_object_put(errors_array);
    return;
}

/**
 * Parses only name from nvr
 * nvr is RPM packages naming convention format: name-version-release
 *
 * for example: meanwhile3.34.3-3.34-3.fc666
 *              ^name           ^ver.^release
 */
static int parse_nvr_name(const char *nvr, char **name)
{
    const int len = strlen(nvr);
    if (len <= 0)
        return EINVAL;
    const char *c = nvr + len - 1;
    /* skip release */
    for (; *c != '-'; --c)
    {
        if (c <= nvr)
            return EINVAL;
    }
    --c;
    /* skip version */
    for (; *c != '-'; --c)
    {
        if (c <= nvr)
            return EINVAL;
    }
    if (c <= nvr)
        return EINVAL;

    *name = xstrndup(nvr, (c - nvr));

    return 0;
}

static GHashTable *bodhi_parse_json(json_object *json, const char *release)
{

    int num_items = 0;
    bodhi_read_value(json, "total", &num_items, BODHI_READ_INT);
    if (num_items <= 0)
        return NULL;

    json_object *updates = NULL;
    bodhi_read_value(json, "updates", &updates, BODHI_READ_JSON_OBJ);
    if (!updates)
        return NULL;

    int updates_len = json_object_array_length(updates);

    GHashTable *bodhi_table = g_hash_table_new_full(g_str_hash, g_str_equal, free,
                                                    (GDestroyNotify) free_bodhi_item);
    for (int i = 0; i < updates_len; ++i)
    {
        json_object *updates_item = json_object_array_get_idx(updates, i);

        /* some of item are null */
        if (!updates_item)
            continue;

        json_object *builds_item = NULL;
        bodhi_read_value(updates_item, "builds", &builds_item, BODHI_READ_JSON_OBJ);
        if (!builds_item) /* broken json */
            continue;

        int karma, unstable_karma;
        bodhi_read_value(updates_item, "karma", &karma, BODHI_READ_INT);
        bodhi_read_value(updates_item, "unstable_karma", &unstable_karma, BODHI_READ_INT);
        if (karma <= unstable_karma)
            continue;

        struct bodhi *b = NULL;
        int builds_len = json_object_array_length(builds_item);
        for (int k = 0; k < builds_len; ++k)
        {
            b = xzalloc(sizeof(struct bodhi));

            char *name = NULL;
            json_object *build = json_object_array_get_idx(builds_item, k);

            bodhi_read_value(build, "nvr", &b->nvr, BODHI_READ_STR);

            if (parse_nvr_name(b->nvr, &name))
                error_msg_and_die("failed to parse package name from nvr: '%s'", b->nvr);

            log_info("Found package: %s\n", name);

            struct bodhi *bodhi_tbl_item = g_hash_table_lookup(bodhi_table, name);
            if (bodhi_tbl_item && rpmvercmp(bodhi_tbl_item->nvr, b->nvr) > 0)
            {
                free_bodhi_item(b);
                continue;
            }
            g_hash_table_replace(bodhi_table, name, b);
        }

#if 0
        bodhi_read_value(updates_item, "date_pushed", &b->date_pushed, BODHI_READ_STR);
        bodhi_read_value(updates_item, "status", &b->status, BODHI_READ_STR);

        json_object *release_item = NULL;
        bodhi_read_value(updates_item, "release", &release_item, BODHI_READ_JSON_OBJ);
        if (release_item)
            bodhi_read_value(release_item, "dist_tag", &b->dist_tag, BODHI_READ_STR);

        json_object *bugs = NULL;
        bodhi_read_value(updates_item, "bugs", &release_item, BODHI_READ_JSON_OBJ);
        if (bugs)
        {
            for (int j = 0; j < json_object_array_length(bugs); ++j)
            {
                int *bz_id = xmalloc(sizeof(int));
                json_object *bug_item = json_object_array_get_idx(bugs, j);
                bodhi_read_value(bug_item, "bz_id", bz_id, BODHI_READ_INT);
                b->bz_ids = g_list_append(b->bz_ids, bz_id);
            }
        }
#endif
    }

    return bodhi_table;
}

static GHashTable *bodhi_query_list(const char *query, const char *release)
{
    char *bodhi_url_bugs = xasprintf("%s/?%s", bodhi_url, query);

    post_state_t *post_state = new_post_state(POST_WANT_BODY
                                              | POST_WANT_SSL_VERIFY
                                              | POST_WANT_ERROR_MSG);

    const char *headers[] = {
        "Accept: application/json",
        NULL
    };

    get(post_state, bodhi_url_bugs, "application/x-www-form-urlencoded",
                     headers);

    if (post_state->http_resp_code != 200 && post_state->http_resp_code != 400)
    {
        char *errmsg = post_state->curl_error_msg;
        if (errmsg && errmsg[0])
            error_msg_and_die("%s '%s'", errmsg, bodhi_url_bugs);
    }
    free(bodhi_url_bugs);

//    log_warning("%s", post_state->body);

    json_object *json = json_tokener_parse(post_state->body);
    if (json == NULL)
        error_msg_and_die("fatal: unable parse response from bodhi server");

    /* we must check the http_resp_code because only error responses contain
     * 'status' item. 'bodhi_read_value' function prints an error message in
     * the case it did not found the item */
    if (post_state->http_resp_code != 200)
    {
        char *status_item = NULL;
        bodhi_read_value(json, "status", &status_item, BODHI_READ_STR);
        if (status_item != NULL && strcmp(status_item, "error") == 0)
        {
            free(status_item);
            bodhi_print_errors_from_json(json);
            json_object_put(json);
            xfunc_die(); // error_msg are printed in bodhi_print_errors_from_json
        }
    }

    GHashTable *bodhi_table = bodhi_parse_json(json, release);
    json_object_put(json);
    free_post_state(post_state);

    return bodhi_table;
}

static char *rpm_get_nvr_by_pkg_name(const char *pkg_name)
{
    int status = rpmReadConfigFiles((const char *) NULL, (const char *) NULL);
    if (status)
        error_msg_and_die("error reading RPM rc files");

    char *nvr = NULL;

    rpmts ts = rpmtsCreate();
    rpmdbMatchIterator iter = rpmtsInitIterator(ts, RPMTAG_NAME, pkg_name, 0);
    Header header = rpmdbNextIterator(iter);

    if (!header)
        goto error;

    const char *errmsg = NULL;
    nvr = headerFormat(header, "%{name}-%{version}-%{release}", &errmsg);

    if (!nvr && errmsg)
        error_msg("cannot get nvr. reason: %s", errmsg);

error:
    rpmdbFreeIterator(iter);
    rpmtsFree(ts);

    rpmFreeRpmrc();
    rpmFreeCrypto();
    rpmFreeMacros(NULL);

    return nvr;
}

int main(int argc, char **argv)
{
    abrt_init(argv);
    enum {
        OPT_v = 1 << 0,
        OPT_d = 1 << 1,
        OPT_g = 1 << 2,
        OPT_b = 1 << 3,
        OPT_u = 1 << 4,
        OPT_r = 1 << 5,
    };

    const char *bugs = NULL, *release = NULL, *dump_dir_path = ".";
    /* Keep enum above and order of options below in sync! */
    struct options program_options[] = {
        OPT__VERBOSE(&g_verbose),
        OPT__DUMP_DIR(&dump_dir_path),
        OPT_GROUP(""),
        OPT_STRING('b', "bugs", &bugs, "ID1[,ID2,...]" , _("List of bug ids")),
        OPT_STRING('u', "url", &bodhi_url, "URL", _("Specify a bodhi server url")),
        OPT_OPTSTRING('r', "release", &release, "RELEASE", _("Specify a release")),
        OPT_END()
    };

    const char *program_usage_string = _(
        "& [-v] [-r[RELEASE]] (-b ID1[,ID2,...] | PKG-NAME) [PKG-NAME]... \n"
        "\n"
        "Search for updates on bodhi server"
    );

    unsigned opts =  parse_opts(argc, argv, program_options, program_usage_string);

    if (!bugs && !argv[optind])
        show_usage_and_die(program_usage_string, program_options);

    struct strbuf *query = strbuf_new();
    if (bugs)
        query = strbuf_append_strf(query, "bugs=%s&", bugs);

    if (opts & OPT_r)
    {
        if (release)
        {
            /* There are no bodhi updates for Rawhide */
            if (strcasecmp(release, "rawhide") == 0)
                error_msg_and_die("Release \"%s\" is not supported",release);

            query = strbuf_append_strf(query, "releases=%s&", release);
        }
        else
        {
            struct dump_dir *dd = dd_opendir(dump_dir_path, DD_OPEN_READONLY);
            if (!dd)
                xfunc_die();

            problem_data_t *problem_data = create_problem_data_from_dump_dir(dd);
            dd_close(dd);
            if (!problem_data)
                xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */

            char *product, *version;
            map_string_t *osinfo = new_map_string();
            problem_data_get_osinfo(problem_data, osinfo);
            parse_osinfo_for_rhts(osinfo, &product, &version);

            /* There are no bodhi updates for Rawhide */
            bool rawhide = strcasecmp(version, "rawhide") == 0;
            if (!rawhide)
                query = strbuf_append_strf(query, "releases=f%s&", version);

            free(product);
            free(version);
            free_map_string(osinfo);

            if (rawhide)
            {
                strbuf_free(query);
                error_msg_and_die("Release \"Rawhide\" is not supported");
            }
        }
    }

    if (argv[optind])
    {
        char *escaped = g_uri_escape_string(argv[optind], NULL, 0);
        query = strbuf_append_strf(query, "packages=%s&", escaped);
        free(escaped);
    }

    if (query->buf[query->len - 1] == '&')
        query->buf[query->len - 1] = '\0';

    log_warning(_("Searching for updates"));
    GHashTable *update_hash_tbl = bodhi_query_list(query->buf, release);
    strbuf_free(query);

    if (!update_hash_tbl || !g_hash_table_size(update_hash_tbl))
    {
        log_warning(_("No updates for this package found"));
        /*if (update_hash_tbl) g_hash_table_unref(update_hash_tbl);*/
        return 0;
    }

    GHashTableIter iter;
    char *name;
    struct bodhi *b;
    struct strbuf *q = strbuf_new();
    g_hash_table_iter_init(&iter, update_hash_tbl);
    while (g_hash_table_iter_next(&iter, (void **) &name, (void **) &b))
    {
        char *installed_pkg_nvr = rpm_get_nvr_by_pkg_name(name);
        if (installed_pkg_nvr && rpmvercmp(installed_pkg_nvr, b->nvr) >= 0)
        {
            log_info("Update %s is older or same as local version %s, skipping", b->nvr, installed_pkg_nvr);
            free(installed_pkg_nvr);
            continue;
        }
        free(installed_pkg_nvr);

        strbuf_append_strf(q, " %s", b->nvr);
    }

    /*g_hash_table_unref(update_hash_tbl);*/

    if (!q->len)
    {
        /*strbuf_free(q);*/
        log_warning(_("Local version of the package is newer than available updates"));
        return 0;
    }

    /* Message is split into text and command in order to make
     * translator's job easier
     */

    /* We suggest the command which is most likely to exist on user's system,
     * and which is familiar to the largest population of users.
     * There are other tools (pkcon et al) which might be somewhat more
     * convenient (for example, they might be usable from non-root), but they
     * might be not present on the system, may evolve or be superseded,
     * as it did happen to yum.
     */

    map_string_t *settings = new_map_string();
    load_abrt_plugin_conf_file("CCpp.conf", settings);

    const char *value;
    strbuf_prepend_str(q, " update --enablerepo=fedora --enablerepo=updates --enablerepo=updates-testing");
    value = get_map_string_item_or_NULL(settings, "PackageManager");
    if (value)
        strbuf_prepend_str(q, value);
    else
        strbuf_prepend_str(q, DEFAULT_PACKAGE_MANAGER);
    free_map_string(settings);

    char *msg = xasprintf(_("An update exists which might fix your problem. "
                "You can install it by running: %s. "
                "Do you want to continue with reporting the bug?"),
                q->buf
    );
    /*strbuf_free(q);*/

    return ask_yes_no(msg) ? 0 : EXIT_STOP_EVENT_RUN;
}
