#include <Ogre.h>
#include <OgreDataStream.h>
#include <OgreMeshSerializer.h>
#include <array>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

using Trace = std::vector<std::string>;

class TargetProbe final : public Ogre::RenderTarget {
public:
    explicit TargetProbe(Trace& trace) : trace_(trace) {
        mName = "audit-target";
        setActive(true);
        setAutoUpdated(true);
    }

    void updateImpl() override { trace_.push_back("update"); }
    void swapBuffers() override { trace_.push_back("swap"); }
    void copyContentsToMemory(const Ogre::Box&, const Ogre::PixelBox&, FrameBuffer) override {}
    bool requiresTextureFlipping() const override { return false; }

private:
    Trace& trace_;
};

class ListenerProbe final : public Ogre::FrameListener {
public:
    explicit ListenerProbe(Trace& trace) : trace_(trace) {}

    bool frameStarted(const Ogre::FrameEvent&) override {
        trace_.push_back("start");
        return allowStart;
    }
    bool frameRenderingQueued(const Ogre::FrameEvent&) override {
        trace_.push_back("queued");
        return allowQueued;
    }
    bool frameEnded(const Ogre::FrameEvent&) override {
        trace_.push_back("end");
        return allowEnd;
    }

    bool allowStart = true;
    bool allowQueued = true;
    bool allowEnd = true;

private:
    Trace& trace_;
};

int main(int argc, char** argv) {
    assert(argc == 2);
    static_assert(OGRE_VERSION == 919043);
    std::cout << "OGRE_VERSION=" << OGRE_VERSION << '\n';

    Trace trace;
    ListenerProbe listener(trace);
    Ogre::Root root("", "", "native-probe-ogre.log");
    root.loadPlugin(argv[1]);
    assert(root.getAvailableRenderers().size() == 1);
    auto* backend = root.getAvailableRenderers().front();
    root.setRenderSystem(backend);
    root.initialise(false);
    auto* window = root.createRenderWindow("audit-window", 32, 32, false);
    auto* scene = root.createSceneManager();
    auto* camera = scene->createCamera("audit-camera");
    scene->getRootSceneNode()->createChildSceneNode()->attachObject(camera);
    auto* viewport = window->addViewport(camera);
    viewport->setBackgroundColour(Ogre::ColourValue(1.0f, 0.0f, 0.0f));

    auto* target = new TargetProbe(trace);
    backend->attachRenderTarget(*target);
    root.addFrameListener(&listener);

    assert(root.renderOneFrame());
    assert((trace == Trace{"start", "update", "queued", "swap", "end"}));
    std::array<std::uint8_t, 32 * 32 * 3> image{};
    const Ogre::PixelBox pixels(32, 32, 1, Ogre::PF_BYTE_RGB, image.data());
    window->copyContentsToMemory(Ogre::Box(0, 0, 32, 32), pixels, Ogre::RenderTarget::FB_BACK);
    assert(image[0] == 255 && image[1] == 0 && image[2] == 0);
    std::cout << "Tiny viewport readback: RGB 255,0,0\n";

    trace.clear();
    listener.allowStart = false;
    assert(!root.renderOneFrame());
    assert((trace == Trace{"start"}));
    std::cout << "start false: start\n";

    trace.clear();
    listener.allowStart = true;
    listener.allowQueued = false;
    assert(!root.renderOneFrame());
    assert((trace == Trace{"start", "update", "queued", "swap"}));
    std::cout << "queued false: start,update,queued,swap\n";

    trace.clear();
    listener.allowQueued = true;
    listener.allowEnd = false;
    bool taskRan = false;
    root.getWorkQueue()->addMainThreadTask([&]() { taskRan = true; });
    assert(!root.renderOneFrame());
    assert((trace == Trace{"start", "update", "queued", "swap", "end"}));
    assert(taskRan);
    std::cout << "end false: start,update,queued,swap,end; main-thread task ran\n";
    root.removeFrameListener(&listener);
    backend->destroyRenderTarget("audit-target");

    const std::array<Ogre::Real, 16> rowMajor{
        1, 0, 0, 10,
        0, 1, 0, 20,
        0, 0, 1, 30,
        0, 0, 0, 1,
    };
    const Ogre::Matrix4 matrix(rowMajor.data());
    assert(matrix.getTrans() == Ogre::Vector3(10, 20, 30));
    assert(matrix[0][3] == 10 && matrix[1][3] == 20 && matrix[2][3] == 30);
    const Ogre::Plane nonUnitPlane(2, 0, 0, -6);
    assert(nonUnitPlane.normal == Ogre::Vector3(2, 0, 0));
    assert(nonUnitPlane.getDistance(Ogre::Vector3::ZERO) == -6);
    std::cout << "Matrix4 row-major translation at [3,7,11]; Plane retains nonunit normal\n";

    const Ogre::Ray ray(Ogre::Vector3::ZERO, Ogre::Vector3(2, 0, 0));
    const auto planeHit = ray.intersects(Ogre::Plane(Ogre::Vector3::UNIT_X, Ogre::Vector3(6, 0, 0)));
    const auto behind = ray.intersects(Ogre::Plane(Ogre::Vector3::UNIT_X, Ogre::Vector3(-6, 0, 0)));
    assert(planeHit.first && planeHit.second == 3 && !behind.first && behind.second == -3);
    std::cout << "plane: t=3 at world distance 6, behind returns false and t=-3\n";

    auto plane = Ogre::MeshManager::getSingleton().createPlane(
        "audit-plane", "General", Ogre::Plane(Ogre::Vector3::UNIT_Z, 0), 8, 8);
    auto data = std::make_shared<Ogre::MemoryDataStream>(16384);
    Ogre::MeshSerializer serializer;
    serializer.exportMesh(plane.get(), data, Ogre::Serializer::ENDIAN_LITTLE);
    const auto total = data->tell();
    const auto* bytes = data->getPtr();
    std::size_t offset = 2;
    while (offset < total && bytes[offset] != '\n') ++offset;
    assert(offset + 7 < total);
    ++offset;
    const std::uint32_t chunkLength = std::uint32_t(bytes[offset + 2]) |
        (std::uint32_t(bytes[offset + 3]) << 8) | (std::uint32_t(bytes[offset + 4]) << 16) |
        (std::uint32_t(bytes[offset + 5]) << 24);
    assert(chunkLength == total - offset);
    std::cout << "Mesh first chunk: size=" << chunkLength
              << ", header=6, payload=" << chunkLength - 6 << '\n';
}
