// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only


#include <QtTest/QTest>
#include <QObject>
#include <QSignalSpy>

#include <qbackendnodetester.h>

#include <Qt3DCore/QEntity>
#include <Qt3DCore/private/qaspectjobmanager_p.h>
#include <Qt3DCore/private/qnodevisitor_p.h>
#include <Qt3DCore/qtransform.h>

#include <Qt3DRender/qcamera.h>
#include <Qt3DRender/qcameralens.h>
#include <Qt3DRender/qrenderaspect.h>
#include <Qt3DRender/private/entity_p.h>
#include <Qt3DRender/private/qcamera_p.h>
#include <Qt3DRender/private/cameralens_p.h>
#include <Qt3DRender/private/managers_p.h>
#include <Qt3DRender/private/nodemanagers_p.h>
#include <Qt3DRender/private/transform_p.h>
#include <Qt3DRender/private/qrenderaspect_p.h>
#include <Qt3DRender/private/updateworldtransformjob_p.h>

QT_BEGIN_NAMESPACE

namespace Qt3DRender {

QList<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
{
    using namespace Qt3DCore;

    QList<QNode *> nodes;
    Qt3DCore::QNodeVisitor visitor;
    visitor.traverse(root, [&nodes](QNode *node) {
        nodes.append(node);

        // Store the metaobject of the node in the QNode so that we have it available
        // to us during destruction in the QNode destructor. This allows us to send
        // the QNodeId and the metaobject as typeinfo to the backend aspects so they
        // in turn can find the correct QBackendNodeMapper object to handle the destruction
        // of the corresponding backend nodes.
        QNodePrivate *d = QNodePrivate::get(node);
        d->m_typeInfo = const_cast<QMetaObject*>(QNodePrivate::findStaticMetaObject(node->metaObject()));

        // Mark this node as having been handled for creation so that it is picked up
        d->m_hasBackendNode = true;
    });

    return nodes;
}

QList<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QList<Qt3DCore::QNode *> nodes)
{
    QList<Qt3DCore::NodeTreeChange> nodeTreeChanges;
    nodeTreeChanges.reserve(nodes.size());

    for (Qt3DCore::QNode *n : nodes) {
        nodeTreeChanges.push_back({
                                      n->id(),
                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
                                      Qt3DCore::NodeTreeChange::Added,
                                      n
                                  });
    }

    return nodeTreeChanges;
}

class TestAspect : public Qt3DRender::QRenderAspect
{
public:
    TestAspect(Qt3DCore::QNode *root)
        : Qt3DRender::QRenderAspect(Qt3DRender::QRenderAspect::Manual)
        , m_sceneRoot(nullptr)
    {
        QRenderAspect::onRegistered();

        const QList<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));

        Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
        Q_ASSERT(rootEntity);
        m_sceneRoot = rootEntity;
    }

    ~TestAspect();

    void onRegistered() override { QRenderAspect::onRegistered(); }
    void onUnregistered() override { QRenderAspect::onUnregistered(); }

    Qt3DRender::Render::NodeManagers *nodeManagers() const { return d_func()->m_renderer->nodeManagers(); }
    Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const { return d_func()->m_renderer->frameGraphRoot(); }
    Qt3DRender::Render::RenderSettings *renderSettings() const { return d_func()->m_renderer->settings(); }
    Qt3DRender::Render::Entity *sceneRoot() const { return m_sceneRoot; }

private:
    Render::Entity *m_sceneRoot;
};

TestAspect::~TestAspect()
{
    QRenderAspect::onUnregistered();
}

} // namespace Qt3DRender

QT_END_NAMESPACE

namespace {

void runRequiredJobs(Qt3DRender::TestAspect *test)
{
    Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
    updateWorldTransform.setRoot(test->sceneRoot());
    updateWorldTransform.setManagers(test->nodeManagers());
    updateWorldTransform.run();
}

void fuzzyCompareMatrix(const QMatrix4x4 &a, const QMatrix4x4 &b)
{
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            // Fuzzy comparison. qFuzzyCompare is not suitable because zero is compared to small numbers.
            QVERIFY(qAbs(a(i, j) - b(i, j)) < 1.0e-6f);
        }
    }
}

} // anonymous

class tst_QCamera : public Qt3DCore::QBackendNodeTester
{
    Q_OBJECT

private Q_SLOTS:

    void initTestCase()
    {
    }

    void checkDefaultConstruction()
    {
        // GIVEN
        Qt3DRender::QCamera camera;

        // THEN
        QCOMPARE(camera.projectionType(), Qt3DRender::QCameraLens::PerspectiveProjection);
        QCOMPARE(camera.nearPlane(), 0.1f);
        QCOMPARE(camera.farPlane(), 1024.0f);
        QCOMPARE(camera.fieldOfView(), 25.0f);
        QCOMPARE(camera.aspectRatio(), 1.0f);
        QCOMPARE(camera.left(), -0.5f);
        QCOMPARE(camera.right(), 0.5f);
        QCOMPARE(camera.bottom(), -0.5f);
        QCOMPARE(camera.top(), 0.5f);
        QCOMPARE(camera.exposure(), 0.0f);
    }

    void checkTransformWithParent()
    {
        // GIVEN
        QScopedPointer<Qt3DCore::QEntity> root(new Qt3DCore::QEntity);

        QScopedPointer<Qt3DCore::QEntity> parent(new Qt3DCore::QEntity(root.data()));
        Qt3DCore::QTransform *parentTransform = new Qt3DCore::QTransform();
        parentTransform->setTranslation(QVector3D(10, 9, 8));
        parentTransform->setRotationX(10.f);
        parentTransform->setRotationY(20.f);
        parentTransform->setRotationZ(30.f);
        parent->addComponent(parentTransform);

        QScopedPointer<Qt3DRender::QCamera> camera(new Qt3DRender::QCamera(parent.data()));

        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
        runRequiredJobs(test.data());

        Qt3DRender::Render::Entity *cameraEntity = test->nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Qt3DRender::Render::EntityManager>(camera->id());

        // THEN
        QVERIFY(qFuzzyCompare(convertToQMatrix4x4(*cameraEntity->worldTransform()), convertToQMatrix4x4(parentTransform->matrix())));
    }

    void checkTransformWithParentAndLookAt()
    {
        // GIVEN
        QScopedPointer<Qt3DCore::QEntity> root(new Qt3DCore::QEntity);

        QScopedPointer<Qt3DCore::QEntity> parent(new Qt3DCore::QEntity(root.data()));
        Qt3DCore::QTransform *parentTransform = new Qt3DCore::QTransform();
        parentTransform->setRotationZ(90.f);
        parent->addComponent(parentTransform);

        QScopedPointer<Qt3DRender::QCamera> camera(new Qt3DRender::QCamera(parent.data()));
        camera->setPosition(QVector3D(1.f, 0.f, 0.f));
        camera->setViewCenter(QVector3D(1.f, 0.f, -1.f)); // look in -z
        camera->setUpVector(QVector3D(0.f, 1.f, 0.f));

        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
        runRequiredJobs(test.data());

        Qt3DRender::Render::Entity *cameraEntity = test->nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Qt3DRender::Render::EntityManager>(camera->id());

        // THEN
        QMatrix4x4 m;
        m.translate(0.f, 1.f, 0.f); // 90 deg z-rotation + x-translation = y-translation
        m.rotate(90.f, QVector3D(0.f, 0.f, 1.f));

        const QMatrix4x4 worldTransform = convertToQMatrix4x4(*cameraEntity->worldTransform());
        fuzzyCompareMatrix(worldTransform, m);

    }

    void checkTransformOfChild()
    {
        // GIVEN
        QScopedPointer<Qt3DCore::QEntity> root(new Qt3DCore::QEntity);

        QScopedPointer<Qt3DCore::QEntity> parent(new Qt3DCore::QEntity(root.data()));
        Qt3DCore::QTransform *parentTransform = new Qt3DCore::QTransform();
        parentTransform->setTranslation(QVector3D(10, 9, 8));
        parent->addComponent(parentTransform);

        QScopedPointer<Qt3DRender::QCamera> camera(new Qt3DRender::QCamera(parent.data()));
        camera->setPosition(QVector3D(2.f, 3.f, 4.f));
        camera->setViewCenter(QVector3D(1.f, 3.f, 4.f)); // looking in -x = 90 deg y-rotation
        camera->setUpVector(QVector3D(0.f, 1.f, 0.f));

        // Child coordinate system:
        // y = camera up vector = global y
        // z = negative camera look direction = global x
        // x = y cross z = global -z
        QScopedPointer<Qt3DCore::QEntity> child(new Qt3DCore::QEntity(camera.data()));
        Qt3DCore::QTransform *childTransform = new Qt3DCore::QTransform();
        childTransform->setTranslation(QVector3D(1.f, 2.f, 3.f));
        child->addComponent(childTransform);

        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
        runRequiredJobs(test.data());

        Qt3DRender::Render::Entity *childEntity = test->nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Qt3DRender::Render::EntityManager>(child->id());

        // THEN
        QMatrix4x4 m;
        m.translate(10.f, 9.f, 8.f); // parent's world translation
        m.translate(2.f, 3.f, 4.f); // camera's world translation
        m.translate(3.f, 2.f, -1.f); // child's world translation
        m.rotate(90.f, QVector3D(0.f, 1.f, 0.f)); // camera's rotation

        fuzzyCompareMatrix(convertToQMatrix4x4(*childEntity->worldTransform()), m);
    }
};


QTEST_MAIN(tst_QCamera)

#include "tst_qcamera.moc"
