#pragma once

#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <unordered_map>

#include "ast/ast_component.hpp"
#include "util/input.hpp"

#include "cmd/args/arg_generic.hpp"
#include "cmd/args/arg_input.hpp"
#include "cmd/args/arg_manager.hpp"

namespace fsh {

    class ArgFactory {
      public:
        using FlagNode  = std::optional<std::string>&;
        using ArgNodes  = std::vector<std::shared_ptr<CommandArgumentNode> >;
        using BuildFunc = std::shared_ptr<_Argument> (*)(void);

        struct ArgRule {
            BuildFunc build;
            bool      mandatory;
            bool      extends;
        };

        struct FlagRule {
            BuildFunc build;
            bool      specialinput; //Not implemented
            bool      capturing;
            bool      extends; //Not implemented
        };

        void add_input_rule() {
            has_input = true;
            pos_arg_rules.push_back({ &_Argument::create<ArgInput>, false, false });
        }

        template <typename T>
        void add_rule(bool mandatory, bool extends = false) {
            pos_arg_rules.push_back({ &_Argument::create<Argument<T> >, mandatory, extends });
        }

        template <typename T = bool>
        void add_rule(const std::string name, bool capturing = false) {
            flag_rules[name] = { _Argument::create<Argument<T> >, false, capturing, false };
        }

        void parse(ArgManager& manager, ArgNodes& vec, FlagNode flag);

        bool ghas_input() { return has_input; }

      private:
        std::vector<ArgRule>                      pos_arg_rules;
        std::unordered_map<std::string, FlagRule> flag_rules;
        bool                                      has_input = false;

        void                       parse_flag(ArgManager& manager, FlagNode flag);
        std::shared_ptr<_Argument> build_arg(BuildFunc build_func, const std::string& str);
        std::shared_ptr<_Argument> build_arg(BuildFunc build_func, std::shared_ptr<CommandArgumentNode> cmd_arg);
    };
}