#pragma once
#include <map>
#include <string>

#include "target.h"
#include "argument_set.h"
#include "katom.h"

class Target_registry
{
public:
    static std::string declare_name;
    static std::string general_name;
    // The pseudo-target of an option set declaration (@@name.o), reserved in
    // the target namespace exactly as "k" is: both declare an interface and
    // document it, and neither produces output for any target.
    static std::string optionset_name;

    Target_registry();

    void add(Target target);
    void add(std::vector<Katom>::iterator begin, std::vector<Katom>::iterator end, std::vector<Katom>& katoms);
    void check_for_previous_definition(const std::string& name, const Locator& loc) const;


    /*
    void add_transforms(std::string target_name, std::string transforms);
    void add_transforms(
        std::string target_name,
        std::vector<std::pair<std::string, std::string>> transforms);
    */


    bool has(const std::string& target_name) const;
    Target get(const std::string& target_name, const Locator& loc) const;
    void transform(const std::string& target_name, std::vector<Katom>& katoms) const;

    std::vector<std::string> user_defined() const;
    std::vector<std::string> applicable() const;

    // `defined_outside`: list only targets declared in a file not in the list.
    // The three pseudo-targets (k, o, *) are built in and always shown -- they
    // are the language's, not any klammerset's.
    std::string describe(int margin=2, bool long_format=false,
                         const strings_t& defined_outside = {}) const;

    //Argtype_registry m_argtypes {};
    std::map<std::string, Target> m_targets {};
    std::vector<std::string> m_names {};
    Parameter_set m_parameters {};


    /*
    std::string m_parameters_spec {"name | desc :after_apply :after_write :includes :escape :resolve | transforms.rest"};
    Parameter_set m_parameters =
        katomize(line_split(m_parameters_spec), Locator().str());
    */


    //Parameter_set m_parameters =
    //    Parameter_set(katomize({"name :desc | transforms.rest"}, "target_registry"));

    /*
    // Targets(Statevar_set& statevars);

    target_ptr check_target_existence(
        std::string name, Locator loc, bool should_exist);
    void add(std::string name, std::string desc, std::string include,
    // Statevar_set& statevars,
             std::string transform,
             std::string before_apply, std::string after_apply, std::string after_write,
             Locator loc);
    target_ptr check_target_name(
        std::string target, bool allow_all, Locator loc);

    std::map<std::string, target_ptr> targets {};
    std::vector<std::string> names {};
    void describe_suffixes();
    void describe();
    */
};
