#pragma once

// Delusions of generality, but it's really just for Klammertext commands.

#include <map>
#include <set>
#include <ranges>
#include <algorithm>
#include <iostream>
#include <regex>

inline std::map<std::string, std::string> regex_symbols {
    {"'text'",      R"((^[^-](?:\s|.)*))" },
    {"'word'",      R"((([^\s]+)))" },
    {"'list'", R"((^[^-]?(?:\s|.)*))" },
//    {"int",       R"((\d))" },
//    {"ints",      R"((\d[ \d]*))" },
    {"'verbosity'", R"(([01234]))" },
//    {"targets",   R"((html|tex|pdf|txt))" },
    //{"'katom_display'", R"((none ?|all ?|type ?|index ?|ignored ?|replaced ?)*)" },
    {"'katom_display'", R"(( *|none|all|type|index|ignored|replaced)*)" },
};

inline std::map<std::string, std::string> regex_desc {
    {"'verbosity'", "Verbosity during processing (0,1,2,3,4); default is 0." }
};

std::regex make_regex(const std::string& key);

class Arg
{
public:
    std::string symbol();
    void make_regex(const std::string& key);

    std::string m_type {};
    std::string m_name {};
    std::string m_pattern {};
    std::string m_rgx_symbol {};
    std::regex  m_rgx {};
    std::string m_default_value {};
    std::string m_parameter {};
    std::string m_syntax {};
    std::string m_desc {};
    std::string m_value {};
};

std::ostream& operator<<(std::ostream& os, const Arg& arg);

class Argv
{
public:
    static std::string delimiter;
    void flag(const std::string& name, const std::string& desc);
    // A positional argument.  `required` false makes it OPTIONAL: the command
    // may be run without it, and its value is then empty.  kdiag uses that for
    // its input text, so that "kdiag --machine" can show the Machine's initial
    // state -- a question about the machine, not about any document.
    void req(const std::string& name, const std::string& desc,
             const std::string& regex_pattern="'text'", bool required = true);
    void opt(const std::string& name, const std::string& desc="", const std::string& parameter="", const std::string& default_value="", const std::string& regex_pattern="text");
    // A variadic option: --name collects every following word up to the
    // next -/-- token (zero or more).  get(name) returns the words
    // space-joined; given(name) distinguishes "--name with no words"
    // from an absent --name.  Used for subcommand-style interfaces
    // (kdesc --font install <dir>).
    // A variadic option: the words after the flag, up to the next one.
    // `parameter` is shown in the usage line as "[<parameter>]" -- an option
    // whose words are a free argument (a search phrase) should name it, so
    // the usage says what may follow; a subcommand-style option (--font,
    // --coverage) leaves it empty and documents its words in its own help.
    void var(const std::string& name, const std::string& desc,
             const std::string& parameter = "");

    void update_width(Arg arg);

    void check_flags_and_options(const std::string& command, std::vector<std::string>& words);
    void parse_flags(std::vector<std::string>& words, std::map<std::string, std::string>& named_args);
    void parse_optional(std::vector<std::string>& words, std::map<std::string, std::string>& named_args);
    void parse_vars(std::vector<std::string>& words, std::map<std::string, std::string>& named_args);

    // True when the named variadic option appeared on the command line
    // (even with no following words).
    bool given(const std::string& name) { return m_given.contains(name); };

    void parse_positional(
        const std::string& command, // std::vector<std::string> words,
        std::string pos_args, std::map<std::string, std::string>& named_args);

    std::map<std::string, std::string> classify_arguments(int argc, char* argv[], bool full_parse=true);
    void check_required(
        const std::vector<std::string>& req_args, const std::string& command_name);
    void check_flags(const std::map<std::string, std::string>& arg_map, const std::string& command_name);

    void parse(int argc, char* argv[], bool full_parse=true);
    std::string get(const std::string& name, bool missing_is_error=true);

    bool as_bool(const std::string& name);
    int as_int(const std::string& name);
    int as_integer_range(const std::string& name, int low, int high);
    int as_verbosity(const std::string& name);
    std::string as_string(const std::string& name);
    std::vector<std::string> as_vector(const std::string& name);
    std::pair<std::string, std::vector<std::string>> as_input(const std::string& name, bool allow_empty=false);

    void usage_line(Arg arg);
    void usage(const std::string& command_name);
    // The default is stderr: the three commands call this under "-v 1", and
    // logging never shares stdout with the command's result (a ktext document
    // may be piped).  argv_test passes std::cout, because there the parsed
    // arguments ARE the result.
    void describe(std::ostream& os = std::cerr);
//    void describe(Argv original);

    bool is_flag(const std::string& name) const {
        return std::ranges::count(m_flag_names, name) > 0;
    }

    bool is_opt(const std::string& name) const {
        return std::ranges::count(m_opt_names, name) > 0;
    }

    std::string m_command {};
    std::map<std::string, Arg> m_args {};
    std::vector<std::string> m_names {};
    std::vector<std::string> m_req_names {};
    std::vector<std::string> m_flag_names {};
    std::vector<std::string> m_opt_names {};
    std::vector<std::string> m_var_names {};
    std::set<std::string> m_given {};
    std::vector<std::string> m_hyphen_markers {};
    // Original argv word boundaries for multi-word arguments (the single
    // positional list and variadic --name options).  as_vector() returns
    // these, so a shell-quoted filename containing spaces stays one
    // element; the space-joined m_value remains only for get()/describe().
    std::map<std::string, std::vector<std::string>> m_vectors {};
    long unsigned int m_syntax_size = 0;
};