//
//  EntityEditFilters.cpp
//  libraries/entities/src
//
//  Created by David Kelly on 2/7/2017.
//  Copyright 2017 High Fidelity, Inc.
//  Copyright 2023 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//  SPDX-License-Identifier: Apache-2.0
//

#include "EntityEditFilters.h"

#include <QUrl>

#include <ResourceManager.h>
#include <shared/ScriptInitializerMixin.h>
#include <ScriptEngine.h>
#include <ScriptManager.h>
#include <ScriptProgram.h>

QList<EntityItemID> EntityEditFilters::getZonesByPosition(glm::vec3& position) {
    QList<EntityItemID> zones;
    QList<EntityItemID> missingZones;
    _lock.lockForRead();
    auto zoneIDs = _filterDataMap.keys();
    _lock.unlock();
    for (auto id : zoneIDs) {
        if (!id.isInvalidID()) {
            // for now, look it up in the tree (soon we need to cache or similar?)
            EntityItemPointer itemPtr = _tree->findEntityByEntityItemID(id);
            auto zone = std::dynamic_pointer_cast<ZoneEntityItem>(itemPtr);
            if (!zone) {
                // TODO: maybe remove later?
                removeFilter(id);
            } else if (zone->contains(position)) {
                zones.append(id);
            }
        } else {
            // the null id is the global filter we put in the domain server's
            // advanced entity server settings
            zones.append(id);
        }
    }
    return zones;
}

bool EntityEditFilters::filter(glm::vec3& position, EntityItemProperties& propertiesIn, EntityItemProperties& propertiesOut,
        bool& wasChanged, EntityTree::FilterType filterType, EntityItemID& itemID, const EntityItemPointer& existingEntity) {

    // get the ids of all the zones (plus the global entity edit filter) that the position
    // lies within
    auto zoneIDs = getZonesByPosition(position);
    for (auto id : zoneIDs) {
        if (!itemID.isInvalidID() && id == itemID) {
            continue;
        }

        // get the filter pair, etc...
        _lock.lockForRead();
        FilterData filterData = _filterDataMap.value(id);
        _lock.unlock();

        if (filterData.valid()) {
            if (filterData.rejectAll) {
                return false;
            }

            // check to see if this filter wants to filter this message type
            if ((!filterData.wantsToFilterEdit && filterType == EntityTree::FilterType::Edit) ||
                (!filterData.wantsToFilterPhysics && filterType == EntityTree::FilterType::Physics) ||
                (!filterData.wantsToFilterDelete && filterType == EntityTree::FilterType::Delete) ||
                (!filterData.wantsToFilterAdd && filterType == EntityTree::FilterType::Add)) {

                wasChanged = false;
                return true; // accept the message
            }

            auto oldProperties = propertiesIn.getDesiredProperties();
            auto specifiedProperties = propertiesIn.getChangedProperties();
            propertiesIn.setDesiredProperties(specifiedProperties);
            ScriptValue inputValues = propertiesIn.copyToScriptValue(filterData.engine.get(), false, true, true);
            propertiesIn.setDesiredProperties(oldProperties);

            auto in = QJsonValue::fromVariant(inputValues.toVariant()); // grab json copy now, because the inputValues might be side effected by the filter.

            ScriptValueList args;
            args << inputValues;
            args << filterData.engine->newValue(filterType);

            // get the current properties for then entity and include them for the filter call
            if (existingEntity && filterData.wantsOriginalProperties) {
                auto currentProperties = existingEntity->getProperties(filterData.includedOriginalProperties);
                ScriptValue currentValues = currentProperties.copyToScriptValue(filterData.engine.get(), false, true, true);
                args << currentValues;
            }


            // get the zone properties
            if (filterData.wantsZoneProperties) {
                auto zoneEntity = _tree->findEntityByEntityItemID(id);
                if (zoneEntity) {
                    auto zoneProperties = zoneEntity->getProperties(filterData.includedZoneProperties);
                    ScriptValue zoneValues = zoneProperties.copyToScriptValue(filterData.engine.get(), false, true, true);

                    if (filterData.wantsZoneBoundingBox) {
                        bool success = true;
                        AABox aaBox = zoneEntity->getAABox(success);
                        if (success) {
                            ScriptValue boundingBox = filterData.engine->newObject();
                            ScriptValue bottomRightNear = vec3ToScriptValue(filterData.engine.get(), aaBox.getCorner());
                            ScriptValue topFarLeft = vec3ToScriptValue(filterData.engine.get(), aaBox.calcTopFarLeft());
                            ScriptValue center = vec3ToScriptValue(filterData.engine.get(), aaBox.calcCenter());
                            ScriptValue boundingBoxDimensions = vec3ToScriptValue(filterData.engine.get(), aaBox.getDimensions());
                            boundingBox.setProperty("brn", bottomRightNear);
                            boundingBox.setProperty("tfl", topFarLeft);
                            boundingBox.setProperty("center", center);
                            boundingBox.setProperty("dimensions", boundingBoxDimensions);
                            zoneValues.setProperty("boundingBox", boundingBox);
                        }
                    }

                    // If this is an add or delete, or original properties weren't requested
                    // there won't be original properties in the args, but zone properties need
                    // to be the fourth parameter, so we need to pad the args accordingly
                    int EXPECTED_ARGS = 3;
                    if (args.length() < EXPECTED_ARGS) {
                        args << ScriptValue();
                    }
                    assert(args.length() == EXPECTED_ARGS); // we MUST have 3 args by now!
                    args << zoneValues;
                }
            }

            ScriptValue result = filterData.filterFn.call(_nullObjectForFilter, args);

            if (filterData.uncaughtExceptions()) {
                return false;
            }

            if (result.isObject()) {
                // make propertiesIn reflect the changes, for next filter...
                propertiesIn.copyFromScriptValue(result, false);

                // and update propertiesOut too.  TODO: this could be more efficient...
                propertiesOut.copyFromScriptValue(result, false);
                // Javascript objects are == only if they are the same object. To compare arbitrary values, we need to use JSON.
                auto out = QJsonValue::fromVariant(result.toVariant());
                wasChanged |= (in != out);
            } else if (result.isBool()) {

                // if the filter returned false, then it's authoritative
                if (!result.toBool()) {
                    return false;
                }

                // otherwise, assume it wants to pass all properties
                propertiesOut = propertiesIn;
                wasChanged = false;

            } else {
                return false;
            }
        }
    }
    // if we made it here,
    return true;
}

void EntityEditFilters::removeFilter(EntityItemID entityID) {
    QWriteLocker writeLock(&_lock);
    _filterDataMap.remove(entityID);
}

void EntityEditFilters::addFilter(EntityItemID entityID, QString filterURL) {

    QUrl scriptURL(filterURL);

    // setting it to an empty string is same as removing
    if (filterURL.size() == 0) {
        removeFilter(entityID);
        return;
    }

    // The following should be abstracted out for use in Agent.cpp (and maybe later AvatarMixer.cpp)
    if (scriptURL.scheme().isEmpty() || (scriptURL.scheme() == HIFI_URL_SCHEME_FILE)) {
        qWarning() << "Cannot load script from local filesystem, because assignment may be on a different computer.";
        scriptRequestFinished(entityID);
        return;
    }

    // first remove any existing info for this entity
    removeFilter(entityID);

    // reject all edits until we load the script
    FilterData filterData;
    filterData.rejectAll = true;

    _lock.lockForWrite();
    _filterDataMap.insert(entityID, filterData);
    _lock.unlock();

    auto scriptRequest = DependencyManager::get<ResourceManager>()->createResourceRequest(
        this, scriptURL, true, -1, "EntityEditFilters::addFilter");
    if (!scriptRequest) {
        qWarning() << "Could not create ResourceRequest for Entity Edit filter.";
        scriptRequestFinished(entityID);
        return;
    }
    // Agent.cpp sets up a timeout here, but that is unnecessary, as ResourceRequest has its own.
    connect(scriptRequest, &ResourceRequest::finished, this, [this, entityID]{ EntityEditFilters::scriptRequestFinished(entityID);} );
    // FIXME: handle atp rquests setup here. See Agent::requestScript()
    scriptRequest->send();
    qDebug() << "script request sent for entity " << entityID;
}

// Copied from ScriptEngine.cpp. We should make this a class method for reuse.
// Note: I've deliberately stopped short of using ScriptEngine instead of ScriptEngine, as that is out of project scope at this point.
static bool hasCorrectSyntax(const ScriptProgramPointer& program) {
    const auto syntaxCheck = program->checkSyntax();
    if (syntaxCheck->state() != ScriptSyntaxCheckResult::Valid) {
        const auto error = syntaxCheck->errorMessage();
        const auto line = QString::number(syntaxCheck->errorLineNumber());
        const auto column = QString::number(syntaxCheck->errorColumnNumber());
        const auto message = QString("[SyntaxError] %1 in %2:%3(%4)").arg(error, program->fileName(), line, column);
        qCritical() << qPrintable(message);
        return false;
    }
    return true;
}
static bool hadUncaughtExceptions(ScriptEngine& engine, const QString& fileName) {
    if (engine.hasUncaughtException()) {
        qCritical() << engine.uncaughtException();
        engine.clearExceptions();
        return true;
    }
    return false;
}

void EntityEditFilters::scriptRequestFinished(EntityItemID entityID) {
    qDebug() << "script request completed for entity " << entityID;
    auto scriptRequest = qobject_cast<ResourceRequest*>(sender());
    if (scriptRequest && scriptRequest->getResult() == ResourceRequest::Success) {
        const QString urlString = scriptRequest->getUrl().toString();
        auto scriptContents = scriptRequest->getData();
        qInfo() << "Downloaded script:" << scriptContents;
        // create a ScriptEngine for this script
        ScriptManagerPointer manager = newScriptManager(ScriptManager::ENTITY_SERVER_SCRIPT, "", urlString);
        ScriptEnginePointer engine = manager->engine();
        ScriptProgramPointer program = engine->newProgram(scriptContents, urlString);
        if (hasCorrectSyntax(program)) {
            engine->setObjectName("filter:" + entityID.toString());
            engine->setProperty("type", "edit_filter");
            engine->setProperty("fileName", urlString);
            engine->setProperty("entityID", entityID);
            engine->globalObject().setProperty("Script", engine->newQObject(manager.get()));
            DependencyManager::get<ScriptInitializers>()->runScriptInitializers(engine.get());
            engine->evaluate(scriptContents, urlString);
            if (!hadUncaughtExceptions(*engine, urlString)) {
                // put the engine in the engine map (so we don't leak them, etc...)
                FilterData filterData;
                filterData.engine = engine;
                filterData.rejectAll = false;

                // define the uncaughtException function
                ScriptEngine& engineRef = *engine;
                filterData.uncaughtExceptions = [&engineRef, urlString]() { return hadUncaughtExceptions(engineRef, urlString); };

                // now get the filter function
                auto global = engine->globalObject();
                auto entitiesObject = engine->newObject();
                entitiesObject.setProperty("ADD_FILTER_TYPE", EntityTree::FilterType::Add);
                entitiesObject.setProperty("EDIT_FILTER_TYPE", EntityTree::FilterType::Edit);
                entitiesObject.setProperty("PHYSICS_FILTER_TYPE", EntityTree::FilterType::Physics);
                entitiesObject.setProperty("DELETE_FILTER_TYPE", EntityTree::FilterType::Delete);
                global.setProperty("Entities", entitiesObject);
                filterData.filterFn = global.property("filter");
                if (!filterData.filterFn.isFunction()) {
                    qDebug() << "Filter function specified but not found. Will reject all edits for those without lock rights.";
                    engine.reset();
                    filterData.rejectAll=true;
                }

                // if the wantsToFilterEdit is a boolean evaluate as a boolean, otherwise assume true
                ScriptValue wantsToFilterAddValue = filterData.filterFn.property("wantsToFilterAdd");
                filterData.wantsToFilterAdd = wantsToFilterAddValue.isBool() ? wantsToFilterAddValue.toBool() : true;

                // if the wantsToFilterEdit is a boolean evaluate as a boolean, otherwise assume true
                ScriptValue wantsToFilterEditValue = filterData.filterFn.property("wantsToFilterEdit");
                filterData.wantsToFilterEdit = wantsToFilterEditValue.isBool() ? wantsToFilterEditValue.toBool() : true;

                // if the wantsToFilterPhysics is a boolean evaluate as a boolean, otherwise assume true
                ScriptValue wantsToFilterPhysicsValue = filterData.filterFn.property("wantsToFilterPhysics");
                filterData.wantsToFilterPhysics = wantsToFilterPhysicsValue.isBool() ? wantsToFilterPhysicsValue.toBool() : true;

                // if the wantsToFilterDelete is a boolean evaluate as a boolean, otherwise assume false
                ScriptValue wantsToFilterDeleteValue = filterData.filterFn.property("wantsToFilterDelete");
                filterData.wantsToFilterDelete = wantsToFilterDeleteValue.isBool() ? wantsToFilterDeleteValue.toBool() : false;

                // check to see if the filterFn has properties asking for Original props
                ScriptValue wantsOriginalPropertiesValue = filterData.filterFn.property("wantsOriginalProperties");
                // if the wantsOriginalProperties is a boolean, or a string, or list of strings, then evaluate as follows:
                //   - boolean - true  - include all original properties
                //               false - no properties at all
                //   - string  - empty - no properties at all
                //               any valid property - include just that property in the Original properties
                //   - list of strings - include only those properties in the Original properties
                if (wantsOriginalPropertiesValue.isBool()) {
                    filterData.wantsOriginalProperties = wantsOriginalPropertiesValue.toBool();
                } else if (wantsOriginalPropertiesValue.isString()) {
                    auto stringValue = wantsOriginalPropertiesValue.toString();
                    filterData.wantsOriginalProperties = !stringValue.isEmpty();
                    if (filterData.wantsOriginalProperties) {
                        EntityPropertyFlagsFromScriptValue(wantsOriginalPropertiesValue, filterData.includedOriginalProperties);
                    }
                } else if (wantsOriginalPropertiesValue.isArray()) {
                    EntityPropertyFlagsFromScriptValue(wantsOriginalPropertiesValue, filterData.includedOriginalProperties);
                    filterData.wantsOriginalProperties = !filterData.includedOriginalProperties.isEmpty();
                }

                // check to see if the filterFn has properties asking for Zone props
                ScriptValue wantsZonePropertiesValue = filterData.filterFn.property("wantsZoneProperties");
                // if the wantsZoneProperties is a boolean, or a string, or list of strings, then evaluate as follows:
                //   - boolean - true  - include all Zone properties
                //               false - no properties at all
                //   - string  - empty - no properties at all
                //               any valid property - include just that property in the Zone properties
                //   - list of strings - include only those properties in the Zone properties
                if (wantsZonePropertiesValue.isBool()) {
                    filterData.wantsZoneProperties = wantsZonePropertiesValue.toBool();
                    filterData.wantsZoneBoundingBox = filterData.wantsZoneProperties; // include this too
                } else if (wantsZonePropertiesValue.isString()) {
                    auto stringValue = wantsZonePropertiesValue.toString();
                    filterData.wantsZoneProperties = !stringValue.isEmpty();
                    if (filterData.wantsZoneProperties) {
                        if (stringValue == "boundingBox") {
                            filterData.wantsZoneBoundingBox = true;
                        } else {
                            EntityPropertyFlagsFromScriptValue(wantsZonePropertiesValue, filterData.includedZoneProperties);
                        }
                    }
                } else if (wantsZonePropertiesValue.isArray()) {
                    auto length = wantsZonePropertiesValue.property("length").toInteger();
                    for (int i = 0; i < length; i++) {
                        auto stringValue = wantsZonePropertiesValue.property(i).toString();
                        if (!stringValue.isEmpty()) {
                            filterData.wantsZoneProperties = true;

                            // boundingBox is a special case since it's not a true EntityPropertyFlag, so we
                            // need to detect it here.
                            if (stringValue == "boundingBox") {
                                filterData.wantsZoneBoundingBox = true;
                                break; // we can break here, since there are no other special cases
                            }

                        }
                    }
                    if (filterData.wantsZoneProperties) {
                        EntityPropertyFlagsFromScriptValue(wantsZonePropertiesValue, filterData.includedZoneProperties);
                    }
                }

                _lock.lockForWrite();
                _filterDataMap.insert(entityID, filterData);
                _lock.unlock();

                qDebug() << "script request filter processed for entity id " << entityID;

                emit filterAdded(entityID, true);
                return;
            }
        }
    } else if (scriptRequest) {
        const QString urlString = scriptRequest->getUrl().toString();
        qCritical() << "Failed to download script";
        // See HTTPResourceRequest::onRequestFinished for interpretation of codes. For example, a 404 is code 6 and 403 is 3. A timeout is 2. Go figure.
        qCritical() << "ResourceRequest error was" << scriptRequest->getResult();
    } else {
        qCritical() << "Failed to create script request.";
    }
    emit filterAdded(entityID, false);
}