/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/


#include <PhysX_precompiled.h>

#include <Pipeline/MeshAssetHandler.h>
#include <AzCore/IO/GenericStreams.h>
#include <AzCore/IO/FileIO.h>
#include <AzCore/Serialization/Utils.h>
#include <PhysX/MeshAsset.h>
#include <PhysX/SystemComponentBus.h>
#include <Source/Pipeline/MeshAssetHandler.h>

namespace PhysX
{
    namespace Pipeline
    {
        const char* MeshAssetHandler::s_assetFileExtension = "pxmesh";

        MeshAssetHandler::MeshAssetHandler()
        {
            Register();
        }

        MeshAssetHandler::~MeshAssetHandler()
        {
            Unregister();
        }

        void MeshAssetHandler::Register()
        {
            bool assetManagerReady = AZ::Data::AssetManager::IsReady();
            AZ_Error("PhysX Mesh Asset", assetManagerReady, "Asset manager isn't ready.");
            if (assetManagerReady)
            {
                AZ::Data::AssetManager::Instance().RegisterHandler(this, AZ::AzTypeInfo<MeshAsset>::Uuid());
            }

            AZ::AssetTypeInfoBus::Handler::BusConnect(AZ::AzTypeInfo<MeshAsset>::Uuid());
        }

        void MeshAssetHandler::Unregister()
        {
            AZ::AssetTypeInfoBus::Handler::BusDisconnect();

            if (AZ::Data::AssetManager::IsReady())
            {
                AZ::Data::AssetManager::Instance().UnregisterHandler(this);
            }
        }

        // AZ::AssetTypeInfoBus
        AZ::Data::AssetType MeshAssetHandler::GetAssetType() const
        {
            return AZ::AzTypeInfo<MeshAsset>::Uuid();
        }

        void MeshAssetHandler::GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions)
        {
            extensions.push_back(s_assetFileExtension);
        }

        const char* MeshAssetHandler::GetAssetTypeDisplayName() const
        {
            return "PhysX Collision Mesh (PhysX Gem)";
        }

        const char* MeshAssetHandler::GetBrowserIcon() const
        {
            return "Editor/Icons/Components/ColliderMesh.svg";
        }

        const char* MeshAssetHandler::GetGroup() const
        {
            return "Physics";
        }

        // Disable spawning of physics asset entities on drag and drop
        AZ::Uuid MeshAssetHandler::GetComponentTypeId() const
        {
            // NOTE: This doesn't do anything when CanCreateComponent returns false
            return AZ::Uuid("{FD429282-A075-4966-857F-D0BBF186CFE6}"); // EditorColliderComponent
        }

        bool MeshAssetHandler::CanCreateComponent(const AZ::Data::AssetId& assetId) const
        {
            return false;
        }

        // AZ::Data::AssetHandler
        AZ::Data::AssetPtr MeshAssetHandler::CreateAsset(const AZ::Data::AssetId& id, const AZ::Data::AssetType& type)
        {
            if (type == AZ::AzTypeInfo<MeshAsset>::Uuid())
            {
                return aznew MeshAsset();
            }

            AZ_Error("PhysX Mesh Asset", false, "This handler deals only with PhysXMeshAsset type.");
            return nullptr;
        }

        bool MeshAssetHandler::LoadAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream, const AZ::Data::AssetFilterCB& assetLoadFilterCB)
        {
            MeshAsset* meshAsset = asset.GetAs<MeshAsset>();
            if (!meshAsset)
            {
                AZ_Error("PhysX Mesh Asset", false, "This should be a PhysXMeshAsset, as this is the only type we process.");
                return false;
            }

            AZ::SerializeContext* serializeContext = nullptr;
            AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);

            if (!AZ::Utils::LoadObjectFromStreamInPlace(*stream, meshAsset->m_assetData, serializeContext))
            {
                return false;
            }

            return true;
        }

        bool MeshAssetHandler::LoadAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, const char* assetPath, const AZ::Data::AssetFilterCB& assetLoadFilterCB)
        {
            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);

            bool result = false;

            AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
            if (fileIO)
            {
                AZ::IO::HandleType hFile = AZ::IO::InvalidHandle;
                if (fileIO->Open(assetPath, AZ::IO::OpenMode::ModeRead, hFile))
                {
                    AZ::u64 size = 0;
                    if (fileIO->Size(hFile, size))
                    {
                        AZStd::vector<char> bytes(size);
                        if (fileIO->Read(hFile, bytes.data(), bytes.size(), true))
                        {
                            AZ::IO::MemoryStream stream(bytes.data(), bytes.size());
                            result = LoadAssetData(asset, &stream, assetLoadFilterCB);
                        }
                    }
                    fileIO->Close(hFile);
                }
            }
            return result;
        }

        void MeshAssetHandler::DestroyAsset(AZ::Data::AssetPtr ptr)
        {
            delete ptr;
        }

        void MeshAssetHandler::GetHandledAssetTypes(AZStd::vector<AZ::Data::AssetType>& assetTypes)
        {
            assetTypes.push_back(AZ::AzTypeInfo<MeshAsset>::Uuid());
        }

        void MeshAssetData::Reflect(AZ::ReflectContext* context)
        {
            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                AssetColliderConfiguration::Reflect(context);
                serializeContext->ClassDeprecate("MeshAssetCookedData", "{82955F2F-4DA1-4AEF-ACEF-0AE16BA20EF4}");

                serializeContext->Class<MeshAssetData>()
                    ->Field("ColliderShapes", &MeshAssetData::m_colliderShapes)
                    ->Field("SurfaceNames", &MeshAssetData::m_surfaceNames)
                    ->Field("MaterialNames", &MeshAssetData::m_materialNames)
                    ->Field("MaterialIndexPerShape", &MeshAssetData::m_materialIndexPerShape)
                    ;
            }
        }

        void AssetColliderConfiguration::Reflect(AZ::ReflectContext* context)
        {
            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<AssetColliderConfiguration>()
                    ->Field("CollisionLayer", &AssetColliderConfiguration::m_collisionLayer)
                    ->Field("CollisionGroupId", &AssetColliderConfiguration::m_collisionGroupId)
                    ->Field("isTrigger", &AssetColliderConfiguration::m_isTrigger)
                    ->Field("Transform", &AssetColliderConfiguration::m_transform)
                    ->Field("Tag", &AssetColliderConfiguration::m_tag)
                    ;
            }
        }

        void AssetColliderConfiguration::UpdateColliderConfiguration(Physics::ColliderConfiguration& colliderConfiguration) const
        {
            if (m_collisionLayer)
            {
                colliderConfiguration.m_collisionLayer = *m_collisionLayer;
            }

            if (m_collisionGroupId)
            {
                colliderConfiguration.m_collisionGroupId = *m_collisionGroupId;
            }

            if (m_isTrigger)
            {
                colliderConfiguration.m_isTrigger = *m_isTrigger;
            }

            if (m_transform)
            {
                // Apply the local shape transform to the collider one
                AZ::Transform existingTransform = 
                    AZ::Transform::CreateFromQuaternionAndTranslation(colliderConfiguration.m_rotation, colliderConfiguration.m_position);

                AZ::Transform shapeTransform = *m_transform;
                shapeTransform.ExtractScaleExact();

                shapeTransform = existingTransform * shapeTransform;

                colliderConfiguration.m_position = shapeTransform.GetTranslation();

                colliderConfiguration.m_rotation = AZ::Quaternion::CreateFromTransform(shapeTransform);
                colliderConfiguration.m_rotation.Normalize();
            }

            if (m_tag)
            {
                colliderConfiguration.m_tag = *m_tag;
            }
        }


} //namespace Pipeline
} // namespace PhysX