text: /*
   * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
   * 
   * SPDX-License-Identifier: Apache-2.0 OR MIT
   *
   */
  
  #include <AzTest/AzTest.h>
  
  #include <SceneAPI/SceneCore/Containers/SceneManifest.h>
  #include <SceneAPI/SceneCore/Containers/Scene.h>
  #include <SceneAPI/SceneCore/DataTypes/Rules/IScriptProcessorRule.h>
  #include <SceneAPI/SceneData/ReflectionRegistrar.h>
  #include <SceneAPI/SceneData/Rules/CoordinateSystemRule.h>
  #include <SceneAPI/SceneData/Behaviors/ScriptProcessorRuleBehavior.h>
  
  #include <AzCore/Math/Quaternion.h>
  #include <AzCore/Name/NameDictionary.h>
  #include <AzCore/RTTI/BehaviorContext.h>
  #include <AzCore/RTTI/ReflectionManager.h>
  #include <AzCore/Serialization/Json/JsonSystemComponent.h>
  #include <AzCore/Serialization/Json/RegistrationContext.h>
  #include <AzCore/std/smart_ptr/make_shared.h>
  #include <AzCore/std/smart_ptr/shared_ptr.h>
  #include <AzCore/UnitTest/Mocks/MockSettingsRegistry.h>
  #include <AzCore/UnitTest/TestTypes.h>
  #include <AzFramework/FileFunc/FileFunc.h>
  
  namespace AZ
  {
      namespace SceneAPI
      {
          class MockRotationRule final
              : public DataTypes::IManifestObject
          {
          public:
              AZ_RTTI(MockRotationRule, "{90AECE4A-58D4-411C-9CDE-59B54C59354F}", DataTypes::IManifestObject);
              AZ_CLASS_ALLOCATOR(MockRotationRule, AZ::SystemAllocator, 0);
  
              static void Reflect(ReflectContext* context)
              {
                  AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
                  if (serializeContext)
                  {
                      serializeContext->Class<MockRotationRule, DataTypes::IManifestObject>()
                          ->Version(1)
                          ->Field("rotation", &MockRotationRule::m_rotation);
                  }
              }
  
              AZ::Quaternion m_rotation = AZ::Quaternion::CreateIdentity();
          };
  
          namespace Containers
          {
              class SceneManifestContainer
              {
              public:
                  static AZ::Outcome<rapidjson::Document, AZStd::string> SaveToJsonDocumentHelper(
                      SceneAPI::Containers::SceneManifest& manifest,
                      SerializeContext* context,
                      JsonRegistrationContext* registrationContext)
                  {
                      return manifest.SaveToJsonDocument(context, registrationContext);
                  }
              };
          }
      }
  
      namespace SceneData
      {
          class SceneManifest_JSON
              : public UnitTest::AllocatorsFixture
          {
          public:
              AZStd::unique_ptr<AZ::SerializeContext> m_serializeContext;
              AZStd::unique_ptr<AZ::JsonRegistrationContext> m_jsonRegistrationContext;
              AZStd::unique_ptr<JsonSystemComponent> m_jsonSystemComponent;
  
              void SetUp() override
              {
                  UnitTest::AllocatorsFixture::SetUp();
                  AZ::NameDictionary::Create();
  
                  m_serializeContext = AZStd::make_unique<AZ::SerializeContext>();
                  AZ::SceneAPI::RegisterDataTypeReflection(m_serializeContext.get());
                  AZ::SceneAPI::Containers::SceneManifest::Reflect(m_serializeContext.get());
                  AZ::SceneAPI::DataTypes::IManifestObject::Reflect(m_serializeContext.get());
                  m_serializeContext->Class<AZ::SceneAPI::DataTypes::IRule, AZ::SceneAPI::DataTypes::IManifestObject>()->Version(1);
                  AZ::SceneAPI::MockRotationRule::Reflect(m_serializeContext.get());
  
                  m_jsonRegistrationContext = AZStd::make_unique<AZ::JsonRegistrationContext>();
  
                  m_jsonSystemComponent = AZStd::make_unique<JsonSystemComponent>();
                  m_jsonSystemComponent->Reflect(m_jsonRegistrationContext.get());
  
                  m_data.reset(new DataMembers);
  
                  using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
  
                  ON_CALL(m_data->m_settings, Get(::testing::Matcher<FixedValueString&>(::testing::_), testing::_))
                      .WillByDefault([](FixedValueString& value, AZStd::string_view) -> bool
                          {
                              value = "mock_path";
                              return true;
                          });
  
                  AZ::SettingsRegistry::Register(&m_data->m_settings);
              }
  
              void TearDown() override
              {
                  m_jsonRegistrationContext->EnableRemoveReflection();
                  m_jsonSystemComponent->Reflect(m_jsonRegistrationContext.get());
                  m_jsonRegistrationContext->DisableRemoveReflection();
  
                  m_serializeContext.reset();
                  m_jsonRegistrationContext.reset();
                  m_jsonSystemComponent.reset();
  
                  AZ::SettingsRegistry::Unregister(&m_data->m_settings);
                  m_data.reset();
  
                  AZ::NameDictionary::Destroy();
                  UnitTest::AllocatorsFixture::TearDown();
              }
  
              struct DataMembers
              {
                  AZ::NiceSettingsRegistrySimpleMock  m_settings;
              };
  
              AZStd::unique_ptr<DataMembers> m_data;
          };
  
          TEST_F(SceneManifest_JSON, LoadFromString_BlankManifest_HasDefaultParts)
          {
              SceneAPI::Containers::SceneManifest sceneManifest;
              sceneManifest.LoadFromString("{}", m_serializeContext.get(), m_jsonRegistrationContext.get(), false);
          }
  
          TEST_F(SceneManifest_JSON, LoadFromString_LoadRotationRuleWithQuaternion_ReturnsTrue)
          {
              using namespace SceneAPI::Containers;
              SceneManifest sceneManifest;
  
              auto anglesInDegrees = AZ::Vector3(45.0f, 90.0f, 45.0f);
              auto originRule = AZStd::make_shared<AZ::SceneAPI::MockRotationRule>();
              originRule->m_rotation = Quaternion::CreateFromEulerAnglesDegrees(anglesInDegrees);
              sceneManifest.AddEntry(originRule);
  
              auto writeToJsonResult = SceneManifestContainer::SaveToJsonDocumentHelper(sceneManifest, m_serializeContext.get(), m_jsonRegistrationContext.get());
              ASSERT_TRUE(writeToJsonResult.IsSuccess());
  
              AZStd::string jsonText;
              auto writeToStringResult = AzFramework::FileFunc::WriteJsonToString(writeToJsonResult.GetValue(), jsonText);
              ASSERT_TRUE(writeToStringResult.IsSuccess());
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("$type": "MockRotationRule")"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("rotation": [)"));
  
              SceneManifest loaded;
              auto loadFromStringResult = loaded.LoadFromString(jsonText, m_serializeContext.get(), m_jsonRegistrationContext.get());
              EXPECT_TRUE(loadFromStringResult.IsSuccess());
              EXPECT_FALSE(loaded.IsEmpty());
  
              ASSERT_EQ(loaded.GetEntryCount(), sceneManifest.GetEntryCount());
          }
  
          TEST_F(SceneManifest_JSON, LoadFromString_LoadRotationRuleWithAnglesInDegrees_ReturnsTrue)
          {
              using namespace SceneAPI::Containers;
  
              constexpr const char* jsonWithAngles = { R"JSON(
              {
                  "values": [
                      {
                          "$type": "MockRotationRule",
                          "rotation": { "yaw" : 45.0, "pitch" : 90.0, "roll" : 0.0 }
                      }
                  ]
              })JSON"};
  
              SceneManifest loaded;
              auto loadFromStringResult = loaded.LoadFromString(jsonWithAngles, m_serializeContext.get(), m_jsonRegistrationContext.get());
              EXPECT_TRUE(loadFromStringResult.IsSuccess());
              EXPECT_FALSE(loaded.IsEmpty());
  
              auto writeToJsonResult =
                  SceneManifestContainer::SaveToJsonDocumentHelper(loaded, m_serializeContext.get(), m_jsonRegistrationContext.get());
              ASSERT_TRUE(writeToJsonResult.IsSuccess());
  
              AZStd::string jsonText;
              auto writeToStringResult = AzFramework::FileFunc::WriteJsonToString(writeToJsonResult.GetValue(), jsonText);
              ASSERT_TRUE(writeToStringResult.IsSuccess());
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("$type": "MockRotationRule")"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("rotation": [)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(0.27)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(0.65)"));
          }
  
          TEST_F(SceneManifest_JSON, LoadFromString_CoordinateSystemRule_ReturnsTrue)
          {
              AZ::SceneAPI::SceneData::CoordinateSystemRule foo;
              EXPECT_FALSE(foo.GetUseAdvancedData());
  
              using namespace SceneAPI::Containers;
  
              constexpr const char* jsonCoordinateSystemRule = { R"JSON(
              {
                  "values": [
                      {
                          "$type": "CoordinateSystemRule",
                          "useAdvancedData": true,
                          "originNodeName": "test_origin_name",
                          "translation": [1.0, 2.0, 3.0],
                          "rotation": { "yaw" : 45.0, "pitch" : 18.5, "roll" : 215.0 },
                          "scale": 10.0
                      }
                  ]
              })JSON" };
  
              SceneManifest loaded;
              auto loadFromStringResult = loaded.LoadFromString(jsonCoordinateSystemRule, m_serializeContext.get(), m_jsonRegistrationContext.get());
              EXPECT_TRUE(loadFromStringResult.IsSuccess());
              EXPECT_FALSE(loaded.IsEmpty());
  
              auto writeToJsonResult =
                  SceneManifestContainer::SaveToJsonDocumentHelper(loaded, m_serializeContext.get(), m_jsonRegistrationContext.get());
              ASSERT_TRUE(writeToJsonResult.IsSuccess());
  
              AZStd::string jsonText;
              auto writeToStringResult = AzFramework::FileFunc::WriteJsonToString(writeToJsonResult.GetValue(), jsonText);
              ASSERT_TRUE(writeToStringResult.IsSuccess());
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("$type": "CoordinateSystemRule")"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("useAdvancedData": true,)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("originNodeName": "test_origin_name",)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("rotation": [)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(0.028)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(-0.40)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(0.85)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(-0.33)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("translation": [)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(1.0)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(2.0)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"(3.0)"));
              EXPECT_THAT(jsonText.c_str(), ::testing::HasSubstr(R"("scale": 10.0)"));
          }
  
          TEST_F(SceneManifest_JSON, ScriptProcessorRule_LoadWithEmptyScriptFilename_ReturnsEarly)
          {
              using namespace SceneAPI::Containers;
              using namespace SceneAPI::Events;
  
              constexpr const char* jsonManifest = { R"JSON(
              {
                  "values": [
                      {
                          "$type": "ScriptProcessorRule",
                          "scriptFilename": ""
                      }
                  ]
              })JSON" };
  
              auto scene = AZ::SceneAPI::Containers::Scene("mock");
              auto result = scene.GetManifest().LoadFromString(jsonManifest, m_serializeContext.get(), m_jsonRegistrationContext.get());
              EXPECT_TRUE(result.IsSuccess());
              EXPECT_FALSE(scene.GetManifest().IsEmpty());
  
              auto scriptProcessorRuleBehavior =  AZ::SceneAPI::Behaviors::ScriptProcessorRuleBehavior();
              auto update = scriptProcessorRuleBehavior.UpdateManifest(scene, AssetImportRequest::Update, AssetImportRequest::Generic);
              EXPECT_EQ(update, ProcessingResult::Ignored);
          }
      }
  }
  