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

#include <AzCore/IO/GenericStreams.h>
#include <AzFramework/Asset/SimpleAsset.h>
#include <AzFramework/Asset/AssetCatalogBus.h>
#include <AzCore/XML/rapidxml.h>

#include <ICryPak.h>

#include <LmbrCentral/Rendering/LensFlareAsset.h>
#include "LensFlareAssetHandler.h"

#define LENS_FLARE_EXT "xml"

namespace LmbrCentral
{
    LensFlareAssetHandler::~LensFlareAssetHandler()
    {
        Unregister();
    }

    AZ::Data::AssetPtr LensFlareAssetHandler::CreateAsset(const AZ::Data::AssetId& id, const AZ::Data::AssetType& type)
    {
        (void)type;
        AZ_Assert(type == AZ::AzTypeInfo<LensFlareAsset>::Uuid(), "Invalid asset type! We handle only 'LensFlareAsset'");

        if (!CanHandleAsset(id))
        {
            return nullptr;
        }

        return aznew LensFlareAsset;
    }

    bool LensFlareAssetHandler::LoadAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream, const AZ::Data::AssetFilterCB& assetLoadFilterCB)
    {
        (void)assetLoadFilterCB;

        // Load from preloaded stream.
        AZ_Assert(asset.GetType() == AZ::AzTypeInfo<LensFlareAsset>::Uuid(), "Invalid asset type! We handle only 'LensFlareAsset'");
        if (stream)
        {
            LensFlareAsset* data = asset.GetAs<LensFlareAsset>();

            const size_t sizeBytes = static_cast<size_t>(stream->GetLength());
            char* buffer = new char[sizeBytes];
            stream->Read(sizeBytes, buffer);

            bool loaded = LoadFromBuffer(data, buffer, sizeBytes);

            delete[] buffer;

            return loaded;
        }

        return false;
    }

    bool LensFlareAssetHandler::LoadAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, const char* assetPath, const AZ::Data::AssetFilterCB& assetLoadFilterCB)
    {
        (void)assetLoadFilterCB;

        // Load from CryPak.
        AZ::IO::HandleType fileHandle = gEnv->pCryPak->FOpen(assetPath, "rb");
        if (fileHandle)
        {
            LensFlareAsset* data = asset.GetAs<LensFlareAsset>();

            const size_t sizeBytes = gEnv->pCryPak->FGetSize(fileHandle);

            char* buffer = new char[sizeBytes];
            gEnv->pCryPak->FReadRawAll(buffer, sizeBytes, fileHandle);
            gEnv->pCryPak->FClose(fileHandle);
            fileHandle = AZ::IO::InvalidHandle;

            bool loaded = LoadFromBuffer(data, buffer, sizeBytes);

            delete[] buffer;

            return loaded;
        }

        return false;
    }

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

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

    void LensFlareAssetHandler::Register()
    {
        AZ_Assert(AZ::Data::AssetManager::IsReady(), "Asset manager isn't ready!");
        AZ::Data::AssetManager::Instance().RegisterHandler(this, AZ::AzTypeInfo<LensFlareAsset>::Uuid());

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

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

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

    AZ::Data::AssetType LensFlareAssetHandler::GetAssetType() const
    {
        return AZ::AzTypeInfo<LensFlareAsset>::Uuid();
    }

    const char* LensFlareAssetHandler::GetAssetTypeDisplayName() const
    {
        return "Lens Flare";
    }

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

    AZ::Uuid LensFlareAssetHandler::GetComponentTypeId() const
    {
        return AZ::Uuid("{4B85E77D-91F9-40C5-8FCB-B494000A9E69}");
    }

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

    bool LensFlareAssetHandler::CanHandleAsset(const AZ::Data::AssetId& id) const
    {
        // Look up the asset path to ensure it's actually a lens flare library.
        AZStd::string assetPath;
        EBUS_EVENT_RESULT(assetPath, AZ::Data::AssetCatalogRequestBus, GetAssetPathById, id);

        bool isLensFlareLibrary = false;
        if (!assetPath.empty() && strstr(assetPath.c_str(), "." LENS_FLARE_EXT))
        {
            //check whether the file includes "LensFlareLibrary" string
            AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
            AZ_Assert(fileIO, "FileIO is not initialized.");
            AZ::IO::HandleType fileHandle = AZ::IO::InvalidHandle;
            const AZ::IO::Result result = fileIO->Open(assetPath.c_str(), AZ::IO::OpenMode::ModeRead, fileHandle);
            if (result)
            {
                AZ::u64 fileSize = 0;
                if (fileIO->Size(fileHandle, fileSize) && fileSize)
                {
                    AZStd::vector<char> memoryBuffer;
                    memoryBuffer.resize_no_construct(fileSize);
                    if (fileIO->Read(fileHandle, memoryBuffer.begin(), fileSize, true))
                    {
                        //compare string instead of parse the entire xml because it's faster. 
                        isLensFlareLibrary = (nullptr != strstr(memoryBuffer.begin(), "LensFlareLibrary"));
                    }
                }

                fileIO->Close(fileHandle);
            }
        }
        return isLensFlareLibrary;
    }

    bool LensFlareAssetHandler::LoadFromBuffer(LensFlareAsset* data, char* buffer, size_t bufferSize)
    {
        using namespace AZ::rapidxml;

        xml_document<char> xmlDoc;
        xmlDoc.parse<parse_no_data_nodes>(buffer);

        xml_node<char>* root = xmlDoc.first_node();
        if (root)
        {
            //get the name of this lens flare library
            xml_attribute<char>* nameAttribute = root->first_attribute("Name");
            if (nameAttribute)
            {
                const char* libName = nameAttribute->value();
                if (libName && libName[0])
                {
                    xml_node<char>* flareNode = root->first_node("FlareItem");
                    while (flareNode)
                    {
                        //for each of FlareItem add their path, combined with lib name, to LensFlareAsset data. 
                        xml_attribute<char>* flareNameAttribute = flareNode->first_attribute("Name");
                        if (flareNameAttribute)
                        {
                            const char* effectName = flareNameAttribute->value();
                            if (effectName && effectName[0])
                            {
                                AZStd::string flarePath = AZStd::string::format("%s.%s", libName, effectName);
                                data->AddPath(std::move(flarePath));
                            }
                        }

                        flareNode = flareNode->next_sibling("FlareItem");
                    }
                    return true;
                }
            }
        }

        return false;
    }
} // namespace LmbrCentral