#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);
};
}