cli_context.h

/*
 * Copyright 2025 Dominik Czekai
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
#include <any>
#include <functional>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_set>
 
#ifdef CHAIN_CLI_VERBOSE
#include <iostream>
#endif
 
#include "logging/logger.h"
#include "context_exception.h"
 
namespace cli
{
 
class CliContext
{
public:
    explicit CliContext(std::unique_ptr<std::unordered_map<std::string, std::any>> posArgs,
                        std::unique_ptr<std::unordered_map<std::string, std::any>> optArgs,
                        std::unique_ptr<std::unordered_set<std::string>> flagArgs,
                        cli::logging::AbstractLogger &logger)
        : logger(logger), positionalArgs(std::move(posArgs)), optionArgs(std::move(optArgs)),
          flagArgs(std::move(flagArgs))
    {
    }
 
    // Non-copyable
    CliContext(const CliContext &) = delete;
    CliContext &operator=(const CliContext &) = delete;
 
    bool isArgPresent(const std::string &argName) const;
 
    bool isOptionArgPresent(const std::string &argName) const;
 
    bool isPositionalArgPresent(const std::string &argName) const;
 
    bool isFlagPresent(const std::string &argName) const;
 
    template <typename T> T getPositionalArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting positional argument '" << argName << "' as type " << typeid(T).name() << "\n";
#endif
        return getAnyCast<T>(argName, *positionalArgs);
    }
 
    template <typename T> void getPositionalArg(const std::string &argName, T &out) const
    {
        out = getAnyCast<T>(argName, *positionalArgs);
    }
 
    template <typename T> T getOptionArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting option argument '" << argName << "' as type " << typeid(T).name() << "\n";
#endif
        return getAnyCast<T>(argName, *optionArgs);
    }
 
    template <typename T> void getOptionArg(const std::string &argName, T &out) const
    {
        out = getAnyCast<T>(argName, *optionArgs);
    }
 
    template <typename T> std::vector<T> getRepeatableOptionArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting repeatable option argument '" << argName << "' as vector of type " << typeid(T).name() << "\n";
#endif
        auto it = optionArgs->find(argName);
        if (it == optionArgs->end())
            throw MissingArgumentException(argName, *optionArgs);
 
        try
        {
            auto anyVec = getAnyCast<std::vector<std::any>>(argName, *optionArgs);
            std::vector<T> result;
            result.reserve(anyVec.size());
            for (const auto &elem : anyVec)
            {
                result.push_back(std::any_cast<T>(elem));
            }
 
            return result;
        }
        catch (const std::bad_any_cast &)
        {
            throw InvalidArgumentTypeException(argName, typeid(std::vector<T>), it->second.type());
        }
    }
 
    template <typename T>
    std::vector<T> getRepeatablePositionalArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting repeatable positional argument '" << argName << "' as vector of type " << typeid(T).name() << "\n";
#endif
        auto it = positionalArgs->find(argName);
        if (it == positionalArgs->end())
            throw MissingArgumentException(argName, *positionalArgs);
 
        try
        {
            auto anyVec = getAnyCast<std::vector<std::any>>(argName, *positionalArgs);
            std::vector<T> result;
            result.reserve(anyVec.size());
            for (const auto &elem : anyVec)
            {
                result.push_back(std::any_cast<T>(elem));
            }
 
            return result;
        }
        catch (const std::bad_any_cast &)
        {
            throw InvalidArgumentTypeException(argName, typeid(std::vector<T>), it->second.type());
        }
    }
 
    template <typename T> T getArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting any argument '" << argName << "' as type " << typeid(T).name() << "\n";
#endif
        if (isPositionalArgPresent(argName))
        {
            return getAnyCast<T>(argName, *positionalArgs);
        }
        else if (isOptionArgPresent(argName))
        {
            return getAnyCast<T>(argName, *optionArgs);
        }
        else
        {
            throw MissingArgumentException(argName, *positionalArgs);
        }
    }
 
    template <typename T> auto getRepeatableArg(const std::string &argName) const
    {
#ifdef CHAIN_CLI_VERBOSE
        std::cout << "Getting repeatable argument '" << argName << "' as vector of type " << typeid(T).name() << "\n";
#endif
        if (isPositionalArgPresent(argName))
        {
            return getRepeatablePositionalArg<T>(argName);
        }
        else if (isOptionArgPresent(argName))
        {
            return getRepeatableOptionArg<T>(argName);
        }
        else
        {
            throw MissingArgumentException(argName, *positionalArgs);
        }
    }
 
    logging::AbstractLogger &Logger() const
    {
        return logger;
    }
 
private:
    cli::logging::AbstractLogger &logger;
    std::unique_ptr<std::unordered_map<std::string, std::any>> positionalArgs;
    std::unique_ptr<std::unordered_map<std::string, std::any>> optionArgs;
    std::unique_ptr<std::unordered_set<std::string>> flagArgs;
 
    template <typename T>
    static T getAnyCast(const std::string &name, std::unordered_map<std::string, std::any> &dict)
    {
        try
        {
            auto it = dict.find(name);
            if (it == dict.end())
            {
                throw MissingArgumentException(name, dict);
            }
            return std::any_cast<T>(it->second);
        }
        catch (const std::bad_any_cast &)
        {
            throw InvalidArgumentTypeException(name, typeid(T), dict.at(name).type());
        }
    }
};
 
} // namespace cli