#pragma once

#include <regex>

#include "deftype.h"
#include "argument_set.h"
#include "option_set_registry.h"
#include "target_registry.h"
#include "locator.h"

class Klammer
{
public:
    Klammer() = default;
    Klammer(const std::string& name)
        : m_name(name)
      {};

    using variable_map_t = std::map<std::string, std::vector<int>>;
    using target_variable_map_t = std::map<std::string, variable_map_t>;
    // <name>[.<target>[,<target>...]] -- the target part is a comma-separated
    // list so that one body can serve several targets (see parse_name).
    static std::regex name_re; // = std::regex(R"((\w+)(?:\.(\w+(?:,\w+)*))?)");

    struct components {
        std::string target;
        katom_t deftype;
        Parameter_set parameters;
        std::vector<Katom> body;
        variable_map_t varmap;
        Locator loc;
    };

    // target-name -> [variable -> index]

    void add_target_definition(
        const std::string& target_name, const Argtype_registry& argtypes,
        Option_set_registry& option_sets,
        std::vector<Katom>::iterator begin, std::vector<Katom>::iterator end);
    void remove_target_definition(const std::string& target_name);

    auto target_defs(const std::vector<std::string>& target_names);
    auto instance_defs();
    void disallow_instances(); //Klammer::components declaration);
    bool copy_to_instances(const Target_registry& targets);
    void copy_components(
        const Parameter_set& parameters, const std::vector<Klammer::components>& cs,
        const Target_registry& targets);
    void check_for_multiple_general_klammers();
    void check_for_declaration_and_definitions();
    void copy_general_klammer_to_undefined(const Target_registry& targets);
    void no_declarations(const Target_registry& targets);
    void one_declaration(const Target_registry& targets, const Klammer::components& declare);
    void many_declarations(const std::vector<Klammer::components>& declares);
    void rationalize(const Target_registry& targets);
    /*
    void add_description(const std::string& desc, Katom definition_type);

    auto user_defs();
    auto klammer_defines_parameters();
    auto klammer_uses_parameters();
    void check_for_target_errors(Target_registry targets);
    bool explicit_parameters_match();
    void copy_components(Klammer::components cs, Target_registry targets);
    */

    std::string signature_text() const;
    std::string description_text() const;
    std::string option_set_text() const;
    std::string describe(int margin=0) const;

    bool has_literal_param() const {
        for (const auto& p : m_parameters.m_positional)
            if (p.m_argtype.m_name == "literal") return true;
        for (const auto& p : m_parameters.m_rest)
            if (p.m_argtype.m_name == "literal") return true;
        return false;
    }
    // True when at least one definition of this klammer came from a file
    // OUTSIDE the given list -- that is, the input defined it rather than a
    // klammerset supplying it.  "At least one" is deliberate: a klammer the
    // input REDEFINES (":::") came originally from the klammerset, and a
    // reader of that input needs to know it was changed.
    bool defined_outside(const strings_t& files) const;
    strings_t get_target_names() const;
    strings_t get_locations();

    // Initial instantiation:
    std::string m_name {};

    // Collection: target, deftype, parameters, body, locator
    std::vector<Klammer::components>  m_defs {};

    // After rationalization:
    Parameter_set m_parameters {};
    std::map<std::string, std::vector<Katom>> m_body {};
    std::string m_desc {};
    std::map<std::string, Locator> m_defloc {}; // target -> Locator
    std::map<std::string, defmode_t> m_defmode {}; // target -> defmode
    target_variable_map_t m_varmap {}; // target -> map: variable -> index
    // target -> true if this target's body came from a general ("*") definition
    // (writer content, subject to target escaping) vs a target-specific one.
    std::map<std::string, bool> m_body_generic {};
    // True when a definition wrote the general target out as ".*" instead of
    // omitting the suffix.  Identical to the engine; to a reader it is the
    // difference between "I did not say" and "I say: every target, whatever
    // they turn out to be".  Only the second is a claim the coverage report
    // can repeat.
    bool m_general_declared { false };
};

std::string klammer_name_from_katom(const std::string& s, const Locator& loc);

// Split "@@<name>[.<target>[,<target>...]]" into the klammer name and the
// targets the definition is for.  Always at least one name: an absent suffix
// is the general target.  A comma list is surface syntax only -- the caller
// registers one definition per target, so nothing downstream of registration
// knows a list was written.
// The third result is true when the general target was written out as "*"
// rather than left off.  Both mean the same to the engine; they mean
// different things to a reader and to the coverage analysis -- see
// Klammer::m_general_declared.
std::tuple<std::string,strings_t,bool>
parse_name(const Target_registry& targets, const Katom& name_katom);

// Split a definition's katoms into its definition separator, parameters,
// body and location.  The target name is needed because the parameter list
// is where option sets are used, and a set may be used only in a ".k"
// declaration; option_sets is not const because a use is recorded on the set.
std::tuple<Katom, Parameter_set, std::vector<Katom>, Locator>
parse_definition_katoms(const std::string& klammer_name, const std::string& target_name,
                        const Argtype_registry& argtypes, Option_set_registry& option_sets,
                        std::vector<Katom>::iterator& begin, std::vector<Katom>::iterator& end);

/*
klammer_definition_args parse_klammer_definition_katoms(
    katom_list& katoms, Argtype_registry& argtypes);

void check_for_undefined_arguments(
    std::string name, Parameters parameters, katom_list body_katoms, Locator loc);
*/
