// Copyright (c) 2016-2017 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/System/Version.hpp>
#if POTHOS_API_VERSION >= 0x00050000
#include <Pothos/Util/BlockDescription.hpp>
#include <Pothos/Plugin.hpp>
#include <Pothos/System.hpp>
#include <Pothos/Proxy.hpp>
#include <Poco/Path.h>
#include <Poco/File.h>
#include <Poco/StringTokenizer.h>
#include <tuple>
#include <map>

/***********************************************************************
 * Recursive traverse for python files
 **********************************************************************/
static std::vector<Poco::Path> getPythonFiles(const Poco::Path &path)
{
    std::vector<Poco::Path> paths;

    const Poco::File file(path);
    if (not file.exists()) return paths;
    else if (file.isFile() and (path.getExtension() == "py"))
    {
        paths.push_back(path);
    }
    else if (file.isDirectory())
    {
        std::vector<std::string> files; file.list(files);
        for (size_t i = 0; i < files.size(); i++)
        {
            auto subpaths = getPythonFiles(Poco::Path(path, files[i]).absolute());
            paths.insert(paths.end(), subpaths.begin(), subpaths.end());
        }
    }

    return paths;
}

/***********************************************************************
 * The loader factory opens a python environment,
 * locates the specified module and class (or function),
 * and invokes it with the specified arguments.
 **********************************************************************/
static Pothos::Object opaquePythonLoaderFactory(
    const std::vector<Poco::Path> &modulePaths,
    const std::string &moduleName,
    const std::string &functionName,
    const Pothos::Object *args,
    const size_t numArgs)
{
    //create python environment
    auto env = Pothos::ProxyEnvironment::make("python");

    //add to the system path
    auto sys = env->findProxy("sys");
    auto sysPath = sys.call("get:path");
    for (const auto &path : modulePaths)
    {
        try
        {
            //throws if the path is not found already
            sysPath.call("index", path.toString());
        }
        catch (...)
        {
            //and so we add our path here
            sysPath.call("append", path.toString());
        }
    }

    //convert arguments into proxy environment
    std::vector<Pothos::Proxy> proxyArgs(numArgs);
    for (size_t i = 0; i < numArgs; i++)
    {
        proxyArgs[i] = env->makeProxy(args[i]);
    }

    //locate the module
    auto mod = env->findProxy(moduleName);

    //call into the factory
    auto block = mod.getHandle()->call(functionName, proxyArgs.data(), proxyArgs.size());
    return Pothos::Object(block);
}

/***********************************************************************
 * register the loader factory for every block factory
 **********************************************************************/
static std::vector<Pothos::PluginPath> PythonLoader(const std::map<std::string, std::string> &config)
{
    std::vector<Pothos::PluginPath> entries;
    std::vector<std::tuple<Pothos::PluginPath, std::string, std::string>> factories;
    const auto tokOptions = Poco::StringTokenizer::TOK_IGNORE_EMPTY | Poco::StringTokenizer::TOK_TRIM;
    const std::string tokSep(" \t");

    //config file path set by caller
    const auto confFilePathIt = config.find("confFilePath");
    if (confFilePathIt == config.end() or confFilePathIt->second.empty())
        throw Pothos::Exception("missing confFilePath");
    const auto rootDir = Poco::Path(confFilePathIt->second).makeParent();

    //doc sources: scan sources unless doc sources are specified
    std::vector<std::string> docSources;
    const auto docSourcesIt = config.find("doc_sources");
    if (docSourcesIt != config.end()) for (const auto &docSource :
        Poco::StringTokenizer(docSourcesIt->second, tokSep, tokOptions))
    {
        const auto absPath = Poco::Path(docSource).makeAbsolute(rootDir);
        docSources.push_back(absPath.toString());
    }

    //otherwise scan all .py files in this directory
    else for (const auto &path : getPythonFiles(rootDir))
    {
        docSources.push_back(path.toString());
    }

    //load the factories: use this when providing no block description
    const auto factoriesIt = config.find("factories");
    if (factoriesIt == config.end()) throw Pothos::Exception("missing factories");
    for (const auto &factoryMarkup :
        Poco::StringTokenizer(factoriesIt->second, tokSep, tokOptions))
    {
        const auto colonPos = factoryMarkup.find(':');
        const auto lastDotPos = factoryMarkup.find_last_of('.');
        if (colonPos == std::string::npos or lastDotPos == std::string::npos or colonPos > lastDotPos)
        {
            throw Pothos::Exception("factory entry not in format /block/path:Module.Function");
        }
        const auto path = Pothos::PluginPath("/blocks", factoryMarkup.substr(0, colonPos));
        const auto module = factoryMarkup.substr(colonPos+1, (lastDotPos-colonPos)-1);
        const auto function = factoryMarkup.substr(lastDotPos+1);
        factories.emplace_back(path, module, function);
    }

    //generate JSON block descriptions
    Pothos::Util::BlockDescriptionParser parser;
    for (const auto &source : docSources) parser.feedFilePath(source);

    //store block paths in handle, and store doc paths
    for (const auto &factory : parser.listFactories())
    {
        const auto pluginPath = Pothos::PluginPath("/blocks/docs", factory);
        Pothos::PluginRegistry::add(pluginPath, parser.getJSONObject(factory));
        entries.push_back(pluginPath);
    }

    //additional module search paths
    std::vector<Poco::Path> modulePaths(1, rootDir);
    const auto pathIt = config.find("path");
    if (pathIt != config.end()) for (const auto &path :
        Poco::StringTokenizer(pathIt->second, tokSep, tokOptions))
    {
        modulePaths.push_back(Poco::Path(path).makeAbsolute(rootDir));
    }

    //register for all factory paths
    for (const auto &factoryTuple : factories)
    {
        const auto &pluginPath = std::get<0>(factoryTuple);
        const auto factory = Pothos::Callable(&opaquePythonLoaderFactory)
            .bind(modulePaths, 0)
            .bind(std::get<1>(factoryTuple), 1)
            .bind(std::get<2>(factoryTuple), 2);
        Pothos::PluginRegistry::addCall(pluginPath, factory);
        entries.push_back(pluginPath);
    }

    return entries;
}

/***********************************************************************
 * loader registration
 **********************************************************************/
pothos_static_block(pothosFrameworkRegisterPythonLoader)
{
    Pothos::PluginRegistry::addCall("/framework/conf_loader/python", &PythonLoader);
}

#endif //POTHOS_API_VERSION >= 0x00050000