/*
    Copyright (C) 2013  ABRT Team
    Copyright (C) 2013  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 "internal_libabrt.h"

#define IGN_COLUMN_DELIMITER ';'
#define IGN_DD_OPEN_FLAGS (DD_OPEN_READONLY | DD_FAIL_QUIETLY_ENOENT | DD_FAIL_QUIETLY_EACCES)
#define IGN_DD_LOAD_TEXT_FLAGS (DD_LOAD_TEXT_RETURN_NULL_ON_FAILURE | DD_FAIL_QUIETLY_ENOENT | DD_FAIL_QUIETLY_EACCES)

struct ignored_problems
{
    char *ign_set_file_path;
};

ignored_problems_t *ignored_problems_new(char *set_file_path)
{
    ignored_problems_t *set = xmalloc(sizeof(*set));
    set->ign_set_file_path = set_file_path;
    return set;
}

void ignored_problems_free(ignored_problems_t *set)
{
    if (!set)
        return;
    free(set->ign_set_file_path);
    free(set);
}

static bool ignored_problems_eq(ignored_problems_t *set,
        const char *problem_id, const char *uuid, const char *duphash,
        const char *line, unsigned line_num)
{
    const char *ignored = line;
    const char *ignored_end = strchrnul(ignored, IGN_COLUMN_DELIMITER);
    size_t sz = ignored_end - ignored;
    if (strncmp(problem_id, ignored, sz) == 0 && problem_id[sz] == '\0')
    {
        log_notice("Ignored id matches '%s'", problem_id);
        return true;
    }

    if (ignored_end[0] == '\0')
    {
        log_notice("No 2nd column (UUID) at line %d in ignored problems file '%s'",
                line_num, set->ign_set_file_path);
        return false;
    }
    ignored = ignored_end + 1;
    ignored_end = strchrnul(ignored, IGN_COLUMN_DELIMITER);
    sz = ignored_end - ignored;
    if (uuid != NULL && strncmp(uuid, ignored, sz) == 0 && uuid[sz] == '\0')
    {
        log_notice("Ignored uuid '%s' matches uuid of problem '%s'", ignored, problem_id);
        return true;
    }

    if (ignored_end[0] == '\0')
    {
        log_notice("No 3rd column (DUPHASH) at line %d in ignored problems file '%s'",
                line_num, set->ign_set_file_path);
        return false;
    }
    ignored = ignored_end + 1;
    ignored_end = strchrnul(ignored, IGN_COLUMN_DELIMITER);
    sz = ignored_end - ignored;
    if (duphash != NULL && strncmp(duphash, ignored, sz) == 0 && duphash[sz] == '\0')
    {
        log_notice("Ignored duphash '%s' matches duphash of problem '%s'", ignored, problem_id);
        return true;
    }

    return false;
}

static bool ignored_problems_file_contains(ignored_problems_t *set,
        const char *problem_id, const char *uuid, const char *duphash,
        FILE **out_fp, const char *mode)
{
    bool found = false;
    FILE *fp = fopen(set->ign_set_file_path, mode);
    if (!fp)
    {
        if (errno != ENOENT)
            pwarn_msg("Can't open ignored problems '%s' in mode '%s'", set->ign_set_file_path, mode);
        goto ret_contains_end;
    }

    unsigned line_num = 0;
    while (!found)
    {
        char *line = xmalloc_fgetline(fp);
        if (!line)
            break;
        ++line_num;
        found = ignored_problems_eq(set, problem_id, uuid, duphash, line, line_num);
        free(line);
    }

 ret_contains_end:
    if (out_fp)
        *out_fp = fp;
    else if (fp)
        fclose(fp);

    return found;
}

static void ignored_problems_add_row(ignored_problems_t *set, const char *problem_id,
        const char *uuid, const char *duphash)
{
    log_notice("Going to add problem '%s' to ignored problems", problem_id);

    FILE *fp;
    if (!ignored_problems_file_contains(set, problem_id, uuid, duphash, &fp, "a+"))
    {
        if (fp)
        {
            /* We can add write error checks here.
             * However, what exactly can we *do* if we detect it?
             */
            fprintf(fp, "%s;%s;%s\n", problem_id, (uuid ? uuid : ""),
                                      (duphash ? duphash : ""));
        }
        else
        {
            /* This is not a fatal problem. We are permissive because we don't want
             * to scare users by strange error messages.
             */
            log_notice("Can't add problem '%s' to ignored problems:"
                      " can't open the list", problem_id);
        }
    }
    else
    {
        log_notice("Won't add problem '%s' to ignored problems:"
                " it is already there", problem_id);
    }

    if (fp)
        fclose(fp);
}

void ignored_problems_add_problem_data(ignored_problems_t *set, problem_data_t *pd)
{
    ignored_problems_add_row(set,
            problem_data_get_content_or_NULL(pd, CD_DUMPDIR),
            problem_data_get_content_or_NULL(pd, FILENAME_UUID),
            problem_data_get_content_or_NULL(pd, FILENAME_DUPHASH)
            );
}

void ignored_problems_add(ignored_problems_t *set, const char *problem_id)
{
    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
    if (!dd)
    {
        /* We do not consider this as an error because the directory can be
         * deleted by other programs. This code expects that dd_opendir()
         * already emitted good explanatory message. This message
         * explains what the previous failure causes.
         */
        VERB1 log_warning("Can't add problem '%s' to ignored problems:"
                " can't open the problem", problem_id);
        return;
    }
    char *uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
    char *duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
    dd_close(dd);

    ignored_problems_add_row(set, problem_id, uuid, duphash);

    free(duphash);
    free(uuid);
}

void ignored_problems_remove_row(ignored_problems_t *set, const char *problem_id,
        const char *uuid, const char *duphash)
{
    INITIALIZE_LIBABRT();

    VERB1 log_warning("Going to remove problem '%s' from ignored problems", problem_id);

    FILE *orig_fp;
    if (!ignored_problems_file_contains(set, problem_id, uuid, duphash, &orig_fp, "r"))
    {
        if (orig_fp)
        {
            log_notice("Won't remove problem '%s' from ignored problems:"
                      " it is already removed", problem_id);
            /* Close orig_fp here because it looks like much simpler than
             * exetendig the set of goto labels at the end of this function */
            fclose(orig_fp);
        }
        else
        {
            /* This is not a fatal problem. We are permissive because we don't want
             * to scare users by strange error messages.
             */
            log_notice("Can't remove problem '%s' from ignored problems:"
                      " can't open the list", problem_id);
        }
        return;
    }

    /* orig_fp must be valid here because if ignored_problems_file_contains()
     * returned TRUE the function ensures that orig_fp is set to a valid FILE*.
     *
     * But the function moved the file position indicator.
     */
    rewind(orig_fp);

    char *new_tempfile_name = xasprintf("%s.XXXXXX", set->ign_set_file_path);
    int new_tempfile_fd = mkstemp(new_tempfile_name);
    if (new_tempfile_fd < 0)
    {
        perror_msg(_("Can't create temporary file '%s'"), set->ign_set_file_path);
        goto ret_close_files;
    }

    unsigned line_num = 0;
    char *line;
    while ((line = xmalloc_fgetline(orig_fp)) != NULL)
    {
        ++line_num;
        if (!ignored_problems_eq(set, problem_id, uuid, duphash, line, line_num))
        {
            ssize_t len = strlen(line);
            line[len] = '\n';
            if (full_write(new_tempfile_fd, line, len + 1) < 0)
            {
                /* Probably out of space */
                line[len] = '\0';
                perror_msg(_("Can't write to '%s'."
                        " Problem '%s' will not be removed from the ignored"
                        " problems '%s'"),
                        new_tempfile_name, problem_id, set->ign_set_file_path);
                free(line);
                goto ret_unlink_new;
            }
        }
        free(line);
    }

    if (rename(new_tempfile_name, set->ign_set_file_path) < 0)
    {
        /* Something nefarious happened */
        perror_msg(_("Can't rename '%s' to '%s'. Failed to remove problem '%s'"),
                set->ign_set_file_path, new_tempfile_name, problem_id);
 ret_unlink_new:
        unlink(new_tempfile_name);
    }

 ret_close_files:
    fclose(orig_fp);
    if (new_tempfile_fd >= 0)
        close(new_tempfile_fd);
    free(new_tempfile_name);

}

void ignored_problems_remove_problem_data(ignored_problems_t *set, problem_data_t *pd)
{
    ignored_problems_remove_row(set,
            problem_data_get_content_or_NULL(pd, CD_DUMPDIR),
            problem_data_get_content_or_NULL(pd, FILENAME_UUID),
            problem_data_get_content_or_NULL(pd, FILENAME_DUPHASH)
            );
}

void ignored_problems_remove(ignored_problems_t *set, const char *problem_id)
{
    char *uuid = NULL;
    char *duphash = NULL;
    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
    if (dd)
    {
        uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
        duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
        dd_close(dd);
    }
    else
    {
        /* We do not consider this as an error because the directory can be
         * deleted by other programs. This code expects that dd_opendir()
         * already emitted good explanatory message. This message
         * explains what the previous failure causes.
         */
        VERB1 error_msg("Can't get UUID/DUPHASH from"
                " '%s' to remove it from the ignored problems:"
                " can't open the problem", problem_id);
    }

    ignored_problems_remove_row(set, problem_id, uuid, duphash);

    free(duphash);
    free(uuid);
}

bool ignored_problems_contains_problem_data(ignored_problems_t *set, problem_data_t *pd)
{
    return ignored_problems_file_contains(set,
            problem_data_get_content_or_NULL(pd, CD_DUMPDIR),
            problem_data_get_content_or_NULL(pd, FILENAME_UUID),
            problem_data_get_content_or_NULL(pd, FILENAME_DUPHASH),
            /* (FILE **) */NULL, "r"
            );
}

bool ignored_problems_contains(ignored_problems_t *set, const char *problem_id)
{
    struct dump_dir *dd = dd_opendir(problem_id, IGN_DD_OPEN_FLAGS);
    if (!dd)
    {
        /* We do not consider this as an error because the directory can be
         * deleted by other programs. This code expects that dd_opendir()
         * already emitted good and explanatory message. This message attempts
         * to explain what the previous failure causes.
         */
        VERB1 error_msg("Can't open '%s'."
                " Won't try to check whether it belongs to ignored problems",
                problem_id);
        return false;
    }
    char *uuid = dd_load_text_ext(dd, FILENAME_UUID, IGN_DD_LOAD_TEXT_FLAGS);
    char *duphash = dd_load_text_ext(dd, FILENAME_DUPHASH, IGN_DD_LOAD_TEXT_FLAGS);
    dd_close(dd);

    log_notice("Going to check if problem '%s' is in ignored problems '%s'",
            problem_id, set->ign_set_file_path);

    bool found = ignored_problems_file_contains(set, problem_id, uuid, duphash,
                    /* (FILE **) */NULL, "r");

    free(duphash);
    free(uuid);

    return found;
}