/*
    Copyright (C) 2015  ABRT team
    Copyright (C) 2015  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 "global_configuration.h"
#include "internal_libreport.h"

#define OPT_NAME_SCRUBBED_VARIABLES "ScrubbedENVVariables"
#define OPT_NAME_EXCLUDED_ELEMENTS "AlwaysExcludedElements"

static const char *const s_recognized_options[] = {
    OPT_NAME_SCRUBBED_VARIABLES,
    OPT_NAME_EXCLUDED_ELEMENTS,
    NULL,
};

static map_string_t *s_global_settings;

bool load_global_configuration(void)
{
    static const char *dirs[] = {
        CONF_DIR,
        NULL,
        NULL,
    };

    static int dir_flags[] = {
        CONF_DIR_FLAG_NONE,
        CONF_DIR_FLAG_OPTIONAL,
        -1,
    };

    if (dirs[1] == NULL)
        dirs[1] = get_user_conf_base_dir();

    return load_global_configuration_from_dirs(dirs, dir_flags);
}

bool load_global_configuration_from_dirs(const char *dirs[], int dir_flags[])
{
    if (s_global_settings == NULL)
    {
        s_global_settings = new_map_string();

        bool ret = load_conf_file_from_dirs_ext("libreport.conf", dirs, dir_flags, s_global_settings,
                                               /*don't skip without value*/ false);
        if (!ret)
        {
            error_msg("Failed to load libreport global configuration");
            free_global_configuration();
            return false;
        }

        map_string_iter_t iter;
        init_map_string_iter(&iter, s_global_settings);
        const char *key, *value;
        while(next_map_string_iter(&iter, &key, &value))
        {
            /* Die to avoid security leaks in case where someone made a typo in a option name */
            if (!is_in_string_list(key, s_recognized_options))
            {
                error_msg("libreport global configuration contains unrecognized option : '%s'", key);
                free_global_configuration();
                return false;
            }
        }
    }
    else
        log_notice("libreport global configuration already loaded");

    return true;
}

void free_global_configuration(void)
{
    if (s_global_settings != NULL)
    {
        free_map_string(s_global_settings);
        s_global_settings = NULL;
    }
}

static void assert_global_configuration_initialized(void)
{
    if (NULL == s_global_settings)
    {
        error_msg("libreport global configuration is not initialized");
        abort();
    }
}

#define get_helper(type, getter, name) \
    ({ \
    assert_global_configuration_initialized(); \
    type opt; \
    if (getter(s_global_settings, name, &opt)) \
        /* Die to avoid security leaks in case where someone made a error */ \
        error_msg_and_die("libreport global settings contains invalid data: '"name"'"); \
    opt;\
    })

string_vector_ptr_t get_global_always_excluded_elements(void)
{
    assert_global_configuration_initialized();

    char *env_exclude = getenv("EXCLUDE_FROM_REPORT");
    const char *gc_exclude = get_map_string_item_or_NULL(s_global_settings, OPT_NAME_EXCLUDED_ELEMENTS);

    if (env_exclude != NULL && gc_exclude == NULL)
        return string_vector_new_from_string(env_exclude);

    if (env_exclude == NULL && gc_exclude != NULL)
        return string_vector_new_from_string(gc_exclude);

    if (env_exclude == NULL && gc_exclude == NULL)
        return string_vector_new_from_string(NULL);

    char *joined_exclude = xasprintf("%s, %s", env_exclude, gc_exclude);
    string_vector_ptr_t ret = string_vector_new_from_string(joined_exclude);
    free(joined_exclude);

    return ret;
}

bool get_global_create_private_ticket(void)
{
    assert_global_configuration_initialized();

    char *env_create_private = getenv(CREATE_PRIVATE_TICKET);

    if (env_create_private == NULL)
        return false;

    return string_to_bool(env_create_private);
}

void set_global_create_private_ticket(bool enabled, int flags/*unused - persistent*/)
{
    assert_global_configuration_initialized();

    if (enabled)
        xsetenv(CREATE_PRIVATE_TICKET, "1");
    else
        safe_unsetenv(CREATE_PRIVATE_TICKET);
}

bool get_global_stop_on_not_reportable(void)
{
    assert_global_configuration_initialized();

    char *env_create_private = getenv(STOP_ON_NOT_REPORTABLE);

    if (env_create_private == NULL)
        return true;

    return string_to_bool(env_create_private);
}

void set_global_stop_on_not_reportable(bool enabled, int flags/*unused - persistent*/)
{
    assert_global_configuration_initialized();

    if (enabled)
        xsetenv(STOP_ON_NOT_REPORTABLE, "1");
    else
        xsetenv(STOP_ON_NOT_REPORTABLE, "0");
}