#include "FuzzingValidators.h"
#include "FuzzingDefs.h"

#include <Data/DataSeries.h>
#include <Variable/Variable.h>

#include <QTest>

#include <functional>

Q_LOGGING_CATEGORY(LOG_FuzzingValidators, "FuzzingValidators")

namespace {

// ////////////// //
// DATA VALIDATOR //
// ////////////// //

/// Singleton used to validate data of a variable
class DataValidatorHelper {
public:
    /// @return the single instance of the helper
    static DataValidatorHelper &instance();
    virtual ~DataValidatorHelper() noexcept = default;

    virtual void validate(const VariableState &variableState) const = 0;
};

/**
 * Default implementation of @sa DataValidatorHelper
 */
class DefaultDataValidatorHelper : public DataValidatorHelper {
public:
    void validate(const VariableState &variableState) const override
    {
        Q_UNUSED(variableState);
        qCWarning(LOG_FuzzingValidators()).noquote() << "Checking variable's data... WARN: no data "
                                                        "verification is available for this server";
    }
};

/// Data resolution in local server's files
const auto LOCALHOST_SERVER_RESOLUTION = 4;
/// Reference value used to generate the data on the local server (a value is the number of seconds
/// between the data date and this reference date)
const auto LOCALHOST_REFERENCE_VALUE
    = DateUtils::secondsSinceEpoch(QDateTime{QDate{2000, 1, 1}, QTime{}, Qt::UTC});

/**
 * Implementation of @sa DataValidatorHelper for the local AMDA server
 */
class LocalhostServerDataValidatorHelper : public DataValidatorHelper {
public:
    void validate(const VariableState &variableState) const override
    {
        // Don't check data for null variable
        if (!variableState.m_Variable || variableState.m_Range == INVALID_RANGE) {
            return;
        }

        auto message = "Checking variable's data...";
        auto toDateString = [](double value) { return DateUtils::dateTime(value).toString(); };

        // Checks that data are defined
        auto variableDataSeries = variableState.m_Variable->dataSeries();
        if (variableDataSeries == nullptr && variableState.m_Range != INVALID_RANGE) {
            qCInfo(LOG_FuzzingValidators()).noquote()
                << message << "FAIL: the variable has no data while a range is defined";
            QFAIL("");
        }

        auto dataIts = variableDataSeries->xAxisRange(variableState.m_Range.m_TStart,
                                                      variableState.m_Range.m_TEnd);

        // Checks that the data are well defined in the range:
        // - there is at least one data
        // - the data are consistent (no data holes)
        if (std::distance(dataIts.first, dataIts.second) == 0) {
            qCInfo(LOG_FuzzingValidators()).noquote()
                << message << "FAIL: the variable has no data";
            QFAIL("");
        }

        auto firstXAxisData = dataIts.first->x();
        auto lastXAxisData = (dataIts.second - 1)->x();

        if (std::abs(firstXAxisData - variableState.m_Range.m_TStart) > LOCALHOST_SERVER_RESOLUTION
            || std::abs(lastXAxisData - variableState.m_Range.m_TEnd)
                   > LOCALHOST_SERVER_RESOLUTION) {
            qCInfo(LOG_FuzzingValidators()).noquote()
                << message << "FAIL: the data in the defined range are inconsistent (data hole "
                              "found at the beginning or the end)";
            QFAIL("");
        }

        auto dataHoleIt = std::adjacent_find(
            dataIts.first, dataIts.second, [](const auto &it1, const auto &it2) {
                /// @todo: validate resolution
                return std::abs(it1.x() - it2.x()) > 2 * (LOCALHOST_SERVER_RESOLUTION - 1);
            });

        if (dataHoleIt != dataIts.second) {
            qCInfo(LOG_FuzzingValidators()).noquote()
                << message << "FAIL: the data in the defined range are inconsistent (data hole "
                              "found between times "
                << toDateString(dataHoleIt->x()) << "and " << toDateString((dataHoleIt + 1)->x())
                << ")";
            QFAIL("");
        }

        // Checks values
        auto dataIndex = 0;
        for (auto dataIt = dataIts.first; dataIt != dataIts.second; ++dataIt, ++dataIndex) {
            auto xAxisData = dataIt->x();
            auto valuesData = dataIt->values();
            for (auto valueIndex = 0, valueEnd = valuesData.size(); valueIndex < valueEnd;
                 ++valueIndex) {
                auto value = valuesData.at(valueIndex);
                auto expectedValue = xAxisData + valueIndex * LOCALHOST_SERVER_RESOLUTION
                                     - LOCALHOST_REFERENCE_VALUE;

                if (value != expectedValue) {
                    qCInfo(LOG_FuzzingValidators()).noquote()
                        << message << "FAIL: incorrect value data at time"
                        << toDateString(xAxisData) << ", index" << valueIndex << "(found:" << value
                        << ", expected:" << expectedValue << ")";
                    QFAIL("");
                }
            }
        }

        // At this step validation is OK
        qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
    }
};

/// Creates the @sa DataValidatorHelper according to the server passed in parameter
std::unique_ptr<DataValidatorHelper> createDataValidatorInstance(const QString &server)
{
    if (server == QString{"localhost"}) {
        return std::make_unique<LocalhostServerDataValidatorHelper>();
    }
    else {
        return std::make_unique<DefaultDataValidatorHelper>();
    }
}

DataValidatorHelper &DataValidatorHelper::instance()
{
    // Creates instance depending on the SCIQLOP_AMDA_SERVER value at compile time
    static auto instance = createDataValidatorInstance(SCIQLOP_AMDA_SERVER);
    return *instance;
}

// /////////////// //
// RANGE VALIDATOR //
// /////////////// //

/**
 * Checks that a range of a variable matches the expected range passed as a parameter
 * @param variable the variable for which to check the range
 * @param expectedRange the expected range
 * @param getVariableRangeFun the function to retrieve the range from the variable
 * @remarks if the variable is null, checks that the expected range is the invalid range
 */
void validateRange(std::shared_ptr<Variable> variable, const SqpRange &expectedRange,
                   std::function<SqpRange(const Variable &)> getVariableRangeFun)
{
    auto compare = [](const auto &range, const auto &expectedRange, const auto &message) {
        if (range == expectedRange) {
            qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
        }
        else {
            qCInfo(LOG_FuzzingValidators()).noquote()
                << message << "FAIL (current range:" << range
                << ", expected range:" << expectedRange << ")";
            QFAIL("");
        }
    };

    if (variable) {
        compare(getVariableRangeFun(*variable), expectedRange, "Checking variable's range...");
    }
    else {
        compare(INVALID_RANGE, expectedRange, "Checking that there is no range set...");
    }
}

/**
 * Default implementation of @sa IFuzzingValidator. This validator takes as parameter of its
 * construction a function of validation which is called in the validate() method
 */
class FuzzingValidator : public IFuzzingValidator {
public:
    /// Signature of a validation function
    using ValidationFunction = std::function<void(const VariableState &variableState)>;

    explicit FuzzingValidator(ValidationFunction fun) : m_Fun(std::move(fun)) {}

    void validate(const VariableState &variableState) const override { m_Fun(variableState); }

private:
    ValidationFunction m_Fun;
};

} // namespace

std::unique_ptr<IFuzzingValidator> FuzzingValidatorFactory::create(FuzzingValidatorType type)
{
    switch (type) {
        case FuzzingValidatorType::DATA:
            return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                DataValidatorHelper::instance().validate(variableState);
            });
        case FuzzingValidatorType::RANGE:
            return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                auto getVariableRange = [](const Variable &variable) { return variable.range(); };
                validateRange(variableState.m_Variable, variableState.m_Range, getVariableRange);
            });
        default:
            // Default case returns invalid validator
            break;
    }

    // Invalid validator
    return std::make_unique<FuzzingValidator>(
        [](const VariableState &) { QFAIL("Invalid validator"); });
}