/*
 * 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 "StdAfx.h"

#include <Asset/BlastAsset.h>
#include <AzCore/std/parallel/lock.h>
#include <Blast/BlastSystemBus.h>
#include <NvBlastExtAssetUtils.h>
#include <NvBlastExtPxSerialization.h>
#include <NvBlastExtSerialization.h>
#include <NvBlastExtTkSerialization.h>
#include <NvBlastTkAsset.h>
#include <NvBlastTypes.h>

namespace Blast
{
    AZStd::mutex BlastAsset::s_assetCreationMutex;

    BlastAsset::BlastAsset(Nv::Blast::ExtPxAsset* pxAsset, NvBlastExtDamageAccelerator* damageAccelerator)
        : m_pxAsset(pxAsset)
        , m_damageAccelerator(damageAccelerator)
        , m_bondHealthMax(0)
    {
    }

    bool BlastAsset::LoadFromBuffer(void* buffer, size_t bytesSize)
    {
        Nv::Blast::ExtSerialization* serialization = nullptr;

        BlastSystemRequestBus::BroadcastResult(serialization, &BlastSystemRequestBus::Events::GetExtSerialization);

        if (serialization == nullptr)
        {
            AZ_Error("Blast", false, "Trying to load blast asset before blast system has initialized.");
            return false;
        }

        AZ::u32 objectTypeId;
        void* asset = nullptr;
        {
            AZStd::lock_guard<AZStd::mutex> lock(s_assetCreationMutex);
            asset = serialization->deserializeFromBuffer(buffer, bytesSize, &objectTypeId);
        }

        if (asset == nullptr)
        {
            AZ_Error("Blast", asset != nullptr, "can't load .blast file.");
            return false;
        }
        else if (objectTypeId == Nv::Blast::ExtPxObjectTypeID::Asset)
        {
            m_pxAsset.reset(reinterpret_cast<Nv::Blast::ExtPxAsset*>(asset));
            const Nv::Blast::TkAsset& tkAsset = m_pxAsset->getTkAsset();
            NvBlastAsset* llAsset = const_cast<NvBlastAsset*>(tkAsset.getAssetLL());
            m_damageAccelerator.reset(NvBlastExtDamageAcceleratorCreate(llAsset, 3));
            m_pxAsset->setAccelerator(m_damageAccelerator.get());
        }
        else
        {
            // in this case we'll want to extract the physics meshes from the fbx.
            // We don't necessarily have access to the mesh data though, so if we want to support this,
            // we'll need to come up with a way to associate with the mesh data
            // See BlastAssetModel in the SDK sample for how to create that data
            AZ_Error("Blast", false, "We currently don't support loading Non-ExtPx objects");
            return false;
        }

        // Initialize maximum bond health
        const auto& actorDesc = m_pxAsset->getDefaultActorDesc();
        if (actorDesc.initialBondHealths)
        {
            m_bondHealthMax = std::numeric_limits<float>::min();
            const uint32_t bondCount = m_pxAsset->getTkAsset().getBondCount();
            for (uint32_t i = 0; i < bondCount; ++i)
            {
                m_bondHealthMax = std::max<float>(m_bondHealthMax, actorDesc.initialBondHealths[i]);
            }
        }
        else
        {
            m_bondHealthMax = actorDesc.uniformInitialBondHealth;
        }

        return true;
    }
} // namespace Blast