#include "python_providers.h"
#include <Data/DataProviderParameters.h>
#include <Data/DateTimeRange.h>
#include <Data/IDataProvider.h>
#include <Data/ScalarTimeSerie.h>
#include <Data/SpectrogramTimeSerie.h>
#include <Data/TimeSeriesUtils.h>
#include <Data/VectorTimeSerie.h>
#include <DataSource/DataSourceController.h>
#include <DataSource/DataSourceItem.h>
#include <DataSource/DataSourceItemAction.h>
#include <QDir>
#include <QStandardPaths>
#include <QStringList>
#include <SqpApplication.h>
#include <TimeSeries.h>
#include <functional>
#include <iostream>


const auto DATA_SOURCE_NAME = QStringLiteral("PythonProviders");

class PythonProvider : public IDataProvider
{
public:
    explicit PythonProvider(PythonInterpreter::provider_funct_t f) : _pythonFunction { f } {}

    PythonProvider(const PythonProvider& other) : _pythonFunction { other._pythonFunction } {}

    std::shared_ptr<IDataProvider> clone() const override
    {
        return std::make_shared<PythonProvider>(*this);
    }
    virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override
    {
        auto product = parameters.m_Data.value("PRODUCT", "").toString().toStdString();
        auto range = parameters.m_Range;
        std::vector<std::tuple<std::string, std::string>> metadata;
        std::transform(parameters.m_Data.constKeyValueBegin(), parameters.m_Data.constKeyValueEnd(),
            std::back_inserter(metadata), [](const auto& item) {
                return std::tuple<std::string, std::string> { item.first.toStdString(),
                    item.second.toString().toStdString() };
            });
        auto result = _pythonFunction(metadata, range.m_TStart, range.m_TEnd);
        return TimeSeriesUtils::copy(result);
    }

private:
    PythonInterpreter::provider_funct_t _pythonFunction;
};


void PythonProviders::initialize()
{
    _interpreter.add_register_callback(
        [this](const std::vector<PythonInterpreter::product_t>& product_list,
            PythonInterpreter::provider_funct_t f) { this->register_product(product_list, f); });

    for (const auto& path : QStandardPaths::standardLocations(QStandardPaths::AppLocalDataLocation))
    {
        auto dir = QDir(path + "/python");
        if (dir.exists())
        {
            for (const auto& entry :
                dir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot, QDir::Name))
            {
                if (entry.isFile() && entry.suffix() == "py")
                {
                    _interpreter.eval(entry.absoluteFilePath().toStdString());
                }
            }
        }
    }
    _interpreter.release();
}

PythonProviders::~PythonProviders() {}

std::unique_ptr<DataSourceItem> make_folder_item(const QString& name)
{
    return std::make_unique<DataSourceItem>(DataSourceItemType::NODE, name);
}

template <typename T>
DataSourceItem* make_path_items(
    const T& path_list_begin, const T& path_list_end, DataSourceItem* root)
{
    std::for_each(path_list_begin, path_list_end, [&root](const auto& folder_name) mutable {
        auto folder_ptr = root->findItem(folder_name);
        if (folder_ptr == nullptr)
        {
            auto folder = make_folder_item(folder_name);
            folder_ptr = folder.get();
            root->appendChild(std::move(folder));
        }
        root = folder_ptr;
    });
    return root;
}

std::unique_ptr<DataSourceItem> make_product_item(
    const QVariantHash& metaData, const QUuid& dataSourceUid)
{
    auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, metaData);

    // Adds plugin name to product metadata
    result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
    result->setData(DataSourceItem::ID_DATA_KEY, metaData.value(DataSourceItem::NAME_DATA_KEY));

    auto productName = metaData.value(DataSourceItem::NAME_DATA_KEY).toString();

    // Add action to load product from DataSourceController
    result->addAction(
        std::make_unique<DataSourceItemAction>(QObject::tr("Load %1 product").arg(productName),
            [productName, dataSourceUid](DataSourceItem& item) {
                if (auto app = sqpApp)
                {
                    app->dataSourceController().loadProductItem(dataSourceUid, item);
                }
            }));

    return result;
}

void PythonProviders::register_product(
    const std::vector<PythonInterpreter::product_t>& product_list,
    PythonInterpreter::provider_funct_t f)
{
    auto& dataSourceController = sqpApp->dataSourceController();
    QString test = DATA_SOURCE_NAME + QUuid::createUuid().toString();
    auto id = dataSourceController.registerDataSource(test);
    auto root = make_folder_item(test);
    std::for_each(std::cbegin(product_list), std::cend(product_list),
        [id, f, root = root.get()](const auto& product) {
            const auto& path = std::get<0>(product);
            auto path_list = QString::fromStdString(path).split('/');
            auto name = *(std::cend(path_list) - 1);
            auto path_item
                = make_path_items(std::cbegin(path_list), std::cend(path_list) - 1, root);
            QVariantHash metaData { { DataSourceItem::NAME_DATA_KEY, name } };
            std::for_each(std::cbegin(std::get<2>(product)), std::cend(std::get<2>(product)),
                [&metaData](const auto& mdata) {
                    metaData[QString::fromStdString(mdata.first)]
                        = QString::fromStdString(mdata.second);
                });
            path_item->appendChild(make_product_item(metaData, id));
        });
    dataSourceController.setDataSourceItem(id, std::move(root));
    dataSourceController.setDataProvider(id, std::make_unique<PythonProvider>(f));
}