/**
 * Copyright (c) 2019, Timothy Stack
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * * Neither the name of Timothy Stack nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef LNAV_HELP_TEXT_HH
#define LNAV_HELP_TEXT_HH

#include <array>
#include <map>
#include <string>
#include <vector>

#include "base/intern_string.hh"

enum class help_context_t {
    HC_NONE,
    HC_PARAMETER,
    HC_RESULT,
    HC_COMMAND,
    HC_SQL_COMMAND,
    HC_SQL_KEYWORD,
    HC_SQL_INFIX,
    HC_SQL_FUNCTION,
    HC_SQL_TABLE_VALUED_FUNCTION,
    HC_PRQL_TRANSFORM,
    HC_PRQL_FUNCTION,
};

enum class help_function_type_t {
    HFT_REGULAR,
    HFT_AGGREGATE,
};

enum class help_nargs_t {
    HN_REQUIRED,
    HN_OPTIONAL,
    HN_ZERO_OR_MORE,
    HN_ONE_OR_MORE,
};

enum class help_parameter_format_t {
    HPF_NONE,
    HPF_STRING,
    HPF_TEXT,
    HPF_MULTILINE_TEXT,
    HPF_REGEX,
    HPF_SQL,
    HPF_SQL_EXPR,
    HPF_INTEGER,
    HPF_NUMBER,
    HPF_ADJUSTED_TIME,
    HPF_LOCATION,
    HPF_FILENAME,
    HPF_LOCAL_FILENAME,
    HPF_LOADED_FILE,
    HPF_FORMAT_FIELD,
    HPF_NUMERIC_FIELD,
    HPF_DIRECTORY,
    HPF_TIME_FILTER_POINT,
    HPF_ALL_FILTERS,
    HPF_ENABLED_FILTERS,
    HPF_DISABLED_FILTERS,
    HPF_HIGHLIGHTS,
    HPF_TIMEZONE,
    HPF_FILE_WITH_ZONE,
    HPF_CONFIG_PATH,
    HPF_CONFIG_VALUE,
    HPF_TAG,
    HPF_LINE_TAG,
    HPF_LOGLINE_TABLE,
    HPF_SEARCH_TABLE,
    HPF_VISIBLE_FILES,
    HPF_HIDDEN_FILES,
};

struct help_example {
    enum class language {
        undefined,
        prql,
    };

    const char* he_description{nullptr};
    const char* he_cmd{nullptr};
    language he_language{language::undefined};
};

struct help_text {
    help_context_t ht_context{help_context_t::HC_NONE};
    const char* ht_name{nullptr};
    const char* ht_summary{nullptr};
    const char* ht_flag_name{nullptr};
    const char* ht_group_start{nullptr};
    const char* ht_group_end{nullptr};
    const char* ht_description{nullptr};
    std::vector<help_text> ht_parameters;
    std::vector<help_text> ht_results;
    std::vector<help_example> ht_example;
    help_nargs_t ht_nargs{help_nargs_t::HN_REQUIRED};
    help_parameter_format_t ht_format{help_parameter_format_t::HPF_STRING};
    std::vector<string_fragment> ht_enum_values;
    std::vector<const char*> ht_tags;
    std::vector<const char*> ht_opposites;
    help_function_type_t ht_function_type{help_function_type_t::HFT_REGULAR};
    std::vector<const char*> ht_prql_path;
    const char* ht_default_value{nullptr};
    void* ht_impl{nullptr};

    help_text() = default;

    help_text(const char* name, const char* summary = nullptr) noexcept
        : ht_name(name), ht_summary(summary)
    {
        if (name[0] == ':') {
            this->ht_context = help_context_t::HC_COMMAND;
            this->ht_name = &name[1];
        }
    }

    help_text& command() noexcept
    {
        this->ht_context = help_context_t::HC_COMMAND;
        return *this;
    }

    help_text& sql_function() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_FUNCTION;
        return *this;
    }

    help_text& sql_agg_function() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_FUNCTION;
        this->ht_function_type = help_function_type_t::HFT_AGGREGATE;
        return *this;
    }

    help_text& sql_table_valued_function() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_TABLE_VALUED_FUNCTION;
        return *this;
    }

    help_text& sql_command() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_COMMAND;
        return *this;
    }

    help_text& sql_keyword() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_KEYWORD;
        return *this;
    }

    help_text& sql_infix() noexcept
    {
        this->ht_context = help_context_t::HC_SQL_INFIX;
        return *this;
    }

    help_text& prql_transform() noexcept
    {
        this->ht_context = help_context_t::HC_PRQL_TRANSFORM;
        return *this;
    }

    help_text& prql_function() noexcept
    {
        this->ht_context = help_context_t::HC_PRQL_FUNCTION;
        return *this;
    }

    help_text& with_summary(const char* summary) noexcept
    {
        this->ht_summary = summary;
        return *this;
    }

    help_text& with_flag_name(const char* flag) noexcept
    {
        this->ht_flag_name = flag;
        return *this;
    }

    help_text& with_grouping(const char* group_start,
                             const char* group_end) noexcept
    {
        this->ht_group_start = group_start;
        this->ht_group_end = group_end;
        return *this;
    }

    help_text& with_parameters(
        const std::initializer_list<help_text>& params) noexcept;

    help_text& with_parameter(const help_text& ht) noexcept;

    help_text& with_result(const help_text& ht) noexcept;

    help_text& with_examples(
        const std::initializer_list<help_example>& examples) noexcept;

    help_text& with_example(const help_example& example) noexcept;

    help_text& with_default_value(const char* defval)
    {
        this->ht_default_value = defval;
        return *this;
    }

    bool is_flag() const
    {
        return this->ht_nargs == help_nargs_t::HN_OPTIONAL
            && this->ht_format == help_parameter_format_t::HPF_NONE;
    }

    bool is_enum() const { return !this->ht_enum_values.empty(); }

    help_text& flag() noexcept
    {
        this->ht_nargs = help_nargs_t::HN_OPTIONAL;
        this->ht_format = help_parameter_format_t::HPF_NONE;
        return *this;
    }

    help_text& optional() noexcept
    {
        this->ht_nargs = help_nargs_t::HN_OPTIONAL;
        return *this;
    }

    help_text& zero_or_more() noexcept
    {
        this->ht_nargs = help_nargs_t::HN_ZERO_OR_MORE;
        return *this;
    }

    help_text& one_or_more() noexcept
    {
        this->ht_nargs = help_nargs_t::HN_ONE_OR_MORE;
        return *this;
    }

    help_text& with_format(help_parameter_format_t format) noexcept
    {
        this->ht_format = format;
        return *this;
    }

    bool is_trailing_arg() const;

    help_text& with_enum_values(
        const std::initializer_list<string_fragment>& enum_values) noexcept;

    template<std::size_t N>
    help_text& with_enum_values(
        const std::array<string_fragment, N>& enum_values) noexcept
    {
        this->ht_enum_values.reserve(N);
        for (const auto& val : enum_values) {
            this->ht_enum_values.emplace_back(val);
        }

        return *this;
    }

    help_text& with_enum_values(const std::vector<string_fragment>& ev)
    {
        this->ht_enum_values = ev;
        return *this;
    }

    help_text& with_tags(
        const std::initializer_list<const char*>& tags) noexcept;

    help_text& with_opposites(
        const std::initializer_list<const char*>& opps) noexcept;

    help_text& with_prql_path(
        const std::initializer_list<const char*>& prql) noexcept;

    template<typename F>
    help_text& with_impl(F impl)
    {
        this->ht_impl = (void*) impl;
        return *this;
    }

    void index_tags();

    static std::multimap<std::string, help_text*>& tag_map();
};

#endif
