/* Copyright 2026 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

/*

 * Multi-target fuzzer for Ogre3D covering:

 * 1. Mesh binary format deserialization (7 format versions)

 * 2. Skeleton binary format deserialization

 * 3. Script lexer and parser pipeline

 * 4. ConfigFile parsing

 * 5. StreamSerialiser chunk reading (extended)

 *

 * Uses FuzzedDataProvider to select which target to exercise per input,

 * maximizing code coverage across the Ogre codebase.

 */

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <fuzzer/FuzzedDataProvider.h>

#include <string>

#include "OgreConfigFile.h"

#include "OgreDataStream.h"

#include "OgreDefaultHardwareBufferManager.h"

#include "OgreException.h"

#include "OgreLodStrategyManager.h"

#include "OgreLogManager.h"

#include "OgreMaterialManager.h"

#include "OgreMesh.h"

#include "OgreMeshManager.h"

#include "OgreMeshSerializer.h"

#include "OgreSkeleton.h"

#include "OgreSkeletonManager.h"

#include "OgreSkeletonSerializer.h"

#include "OgreStreamSerialiser.h"

enum FuzzTarget {

  FUZZ_MESH = 0,

  FUZZ_SKELETON,

  FUZZ_CONFIG,

  FUZZ_STREAM_SERIALISER,

  FUZZ_TARGET_COUNT

};

static bool g_initialized = false;

static void global_init() {

  if (g_initialized)

    return;

  /* Suppress all log output */

  auto *logMgr = new Ogre::LogManager();

  logMgr->createLog("fuzz.log", true, false, true); /* suppressFileOutput */

  logMgr->setMinLogLevel(Ogre::LML_CRITICAL);

  /* Create singletons needed for Mesh/Skeleton operations */

  new Ogre::ResourceGroupManager();

  new Ogre::LodStrategyManager();

  new Ogre::DefaultHardwareBufferManager();

  new Ogre::MeshManager();

  new Ogre::SkeletonManager();

  auto *matMgr = new Ogre::MaterialManager();

  matMgr->initialise();

  g_initialized = true;

}

static void fuzz_mesh(const uint8_t *data, size_t size) {

  // manual, so we can load it from memory without a file

  auto mesh = Ogre::MeshManager::getSingleton().create("fuzz.mesh", "General", true);

  mesh->load(); // ensure cleanup runs

  Ogre::DataStreamPtr stream(

      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));

  Ogre::MeshSerializer serializer;

  try {

    serializer.importMesh(stream, mesh.get());

  } catch (std::exception &) {

  }

  Ogre::MeshManager::getSingleton().remove(mesh);

}

static void fuzz_skeleton(const uint8_t *data, size_t size) {

  // manual, so we can load it from memory without a file

  auto skeleton = Ogre::SkeletonManager::getSingleton().create("fuzz.skeleton", "General", true);

  skeleton->prepare();   // ensure cleanup runs

  Ogre::DataStreamPtr stream(

      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));

  Ogre::SkeletonSerializer serializer;

  try {

    serializer.importSkeleton(stream, skeleton.get());

  } catch (std::exception &) {

  }

  Ogre::SkeletonManager::getSingleton().remove(skeleton);

}

static void fuzz_config(const uint8_t *data, size_t size) {

  Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(

      "fuzz.cfg", const_cast<uint8_t *>(data), size, false, true));

  Ogre::ConfigFile cf;

  try {

    cf.load(stream);

    /* Exercise iteration over parsed sections and settings */

    for (auto &sec : cf.getSettingsBySection()) {

      for (auto &kv : sec.second) {

        volatile const char *k = kv.first.c_str();

        volatile const char *v = kv.second.c_str();

        (void)k;

        (void)v;

      }

    }

  } catch (Ogre::Exception &) {

  } catch (std::exception &) {

  }

}

static void fuzz_stream_serialiser(const uint8_t *data, size_t size) {

  Ogre::DataStreamPtr stream(

      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));

  try {

    Ogre::StreamSerialiser serialiser(stream);

    /* Try to read multiple chunks, exercising the chunk state machine */

    for (int i = 0; i < 32; i++) {

      const Ogre::StreamSerialiser::Chunk *c = serialiser.readChunkBegin();

      if (!c)

        break;

      /* Try reading various data types from the chunk */

      Ogre::String str;

      try { serialiser.read(&str); } catch (...) {}

      Ogre::Real r;

      try { serialiser.read(&r); } catch (...) {}

      Ogre::Vector3 v3;

      try { serialiser.read(&v3); } catch (...) {}

      Ogre::Vector4 v4;

      try { serialiser.read(&v4); } catch (...) {}

      serialiser.readChunkEnd(c->id);

    }

  } catch (Ogre::Exception &) {

  } catch (std::exception &) {

  }

}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

  if (size < 2)

    return 0;

  global_init();

  FuzzedDataProvider provider(data, size);

  uint8_t target = provider.ConsumeIntegral<uint8_t>() % FUZZ_TARGET_COUNT;

  auto remaining = provider.ConsumeRemainingBytes<uint8_t>();

  if (remaining.empty())

    return 0;

  switch (target) {

  case FUZZ_MESH:

    fuzz_mesh(remaining.data(), remaining.size());

    break;

  case FUZZ_SKELETON:

    fuzz_skeleton(remaining.data(), remaining.size());

    break;

  case FUZZ_CONFIG:

    fuzz_config(remaining.data(), remaining.size());

    break;

  case FUZZ_STREAM_SERIALISER:

    fuzz_stream_serialiser(remaining.data(), remaining.size());

    break;

  }

  return 0;

}