AssetManager.h

#pragma once

#include "AssetEntity.h"

namespace ParaEngine
{
    template <class IDTYPE, class ClassImpType = IDTYPE, class ETYPE = AssetEntity>
    class AssetManager : public IAttributeFields
    {
    public:
        typedef AssetManager<IDTYPE, ClassImpType, ETYPE> MyType_t;
        typedef std::map<std::string, ETYPE*> AssetItemsNameMap_t;
        typedef std::map<AssetKey, ETYPE*> AssetItemsSet_t;

        AssetManager()
        {
            static_assert(std::is_convertible<IDTYPE*, AssetEntity*>::value, "Invalid Type for AssetManager!");
            // since asset manager is kind of singleton pattern, we will always set reference count to 1 during creation. 
            addref();
        }
        virtual ~AssetManager()
        {
            Cleanup();
        }

        ATTRIBUTE_DEFINE_CLASS(AssetManager);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName){
            return GetByName(sName);
        };
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0) { return (int)m_items.size(); };
        virtual int GetChildAttributeColumnCount() { return 1; };
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0){
            if (nRowIndex < (int)m_items.size())
            {
                auto iter = m_items.begin();
                std::advance(iter, nRowIndex);
                return iter->second;
            }
            return NULL;
        }

        inline static MyType_t& GetInstance() {
            static MyType_t s_instance;
            return s_instance;
        }

        virtual const std::string& GetIdentifier() {
            return m_sName;
        }
        virtual void SetIdentifier(const std::string& sName){
            m_sName = sName;
        }

        virtual void Cleanup()
        {
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
#ifdef _DEBUG
                ETYPE* pAsset =itCurCP->second;
                if(pAsset->GetRefCount()>1){
                    OUTPUT_LOG("warning: asset <%s> exits with ref %d\n", pAsset->m_key.c_str(), pAsset->GetRefCount()-1);
                }
#endif
                // normally, it should have 0 reference count at this place. And a delete this operation is performed. 
                itCurCP->second->Release();

                // force deletion regardless of reference count. 
                //(*itCurCP)->Cleanup();
                //delete ((IDTYPE*)(*itCurCP));
            }
            m_items.clear();

            // clean up named references
            m_names.clear();

            m_lowercase_item_maps.clear();
        }

        inline void GetLowerCaseString(std::string& outNameLowered, const AssetKey& key){
            const char A = (char)'A';
            const char Z = (char)'Z';
            const char diff = (char)'a' - A;
            int nLen = (int)key.size();
            outNameLowered = key;
            char c;
            for (int i=0; i<nLen; ++i)
            {
                c = key[i];
                if (c>=A && c<=Z)
                    outNameLowered[i] = c + diff;
            }
        }

        virtual bool DeleteEntity(ETYPE* entity)
        {
            // remove from the list
            const AssetKey& key = entity->GetKey();

            // remove from lower cased name mapping. 
            std::string sNameLowered;
            GetLowerCaseString(sNameLowered, key);
            typename AssetItemsNameMap_t::iterator iter = m_lowercase_item_maps.find(sNameLowered);
            if( iter != m_lowercase_item_maps.end())
            {
                // remove name mapping
                if(iter->second != entity)
                {
                    OUTPUT_LOG("warning: DeleteEntity %s with multiple candidates\n", key.c_str());
                }
                m_lowercase_item_maps.erase(iter);
            }

            // remove anyway
            typename AssetItemsSet_t::iterator itCur = m_items.find(key);
            if(itCur!=m_items.end())
            {
                m_items.erase(itCur);
            }

            // check references
            if(entity->GetRefCount() > 1) 
            {
                OUTPUT_LOG("warning: you are deleting an entity %s whose has unreleased external references\n", entity->GetKey().c_str());
            }
            // unload anyway.
            entity->UnloadAsset();
            // normally, it should have 0 reference count at this place. And a delete this operation is performed. 
            entity->Release();

            return true;
        }

        void DeleteByName(const std::string& name)
        {
            typename AssetItemsNameMap_t::iterator iter = m_names.find(name);
            if( iter != m_names.end())
            {
                // delete entity
                DeleteEntity((*iter).second);
                // remove name mapping
                m_names.erase(iter);
            }
        }

        IDTYPE* GetByName(const std::string& name)
        {
            typename AssetItemsNameMap_t::iterator iter = m_names.find(name);
            if( iter != m_names.end())
                return (IDTYPE*)((*iter).second);
            else
                return NULL;
        }

        ETYPE* get(const AssetKey& key)
        {
            // first search using asset key, if not found, we will search the lower cased AssetKey version. 
            typename AssetItemsSet_t::iterator iter = m_items.find(key);
            if(iter != m_items.end())
            {
                return iter->second;
            }
            else
            {
                // search in lower cased 
                std::string sNameLowered;
                GetLowerCaseString(sNameLowered, key);
                typename AssetItemsNameMap_t::iterator iter1 = m_lowercase_item_maps.find(sNameLowered);
                if( iter1 != m_lowercase_item_maps.end())
                {
                    // remove name mapping
                    return iter1->second;
                }

            }
            return NULL;
        }
    public:

        IDTYPE* NewEntity(const AssetKey& key){
            IDTYPE* pEntity = new ClassImpType(key);
            return pEntity;
        }

        bool AddEntity(const std::string& name, IDTYPE* pEntity)
        {
            const AssetKey& key = pEntity->GetKey();
            ETYPE* pEntityOld = get(key);
            if (pEntityOld)
            {
                if (pEntityOld == pEntity)
                    return true;
                else
                {
                    if (!DeleteEntity(pEntityOld))
                    {
                        return false;
                    }
                }
            }
            
            {
                if (!name.empty())
                {
                    // add a named asset reference.
                    m_names[name] = pEntity;
                }
                m_items[key] = pEntity;
                pEntity->addref();

                // add a lower cased map
                std::string sNameLowered;
                GetLowerCaseString(sNameLowered, key);
                m_lowercase_item_maps[sNameLowered] = pEntity;
            }
            return true;
        }

        pair<IDTYPE*, bool> CreateEntity(const string& name, const AssetKey& key)
        {
            ETYPE* pEntity = get(key);
            if(pEntity)
            {
                if( ! name.empty() )
                {
                    ETYPE* pOld = GetByName(name);
                    if(pOld == NULL)
                    {
                        // add a named asset reference.
                        m_names[name] = pEntity;
                    }
                }
                return pair<IDTYPE*, bool>((IDTYPE*)pEntity, false);
            }
            else
            {
                pEntity = NewEntity(key);
                if( ! name.empty() )
                {
                    // add a named asset reference.
                    m_names[name] = pEntity;
                }
                m_items[key] = pEntity;
                pEntity->addref();

                // add a lower cased map
                std::string sNameLowered;
                GetLowerCaseString(sNameLowered, key);
                m_lowercase_item_maps[sNameLowered] = pEntity;

                return pair<IDTYPE*, bool>((IDTYPE*)pEntity, true);
            }
        }

        
        IDTYPE* GetEntity(const string& name)
        {
            return (IDTYPE*)get(name);
        }

        void LoadAsset(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->LoadAsset();
            }
        }
        void UnloadAsset(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->UnloadAsset();
            }
        }
        void GarbageCollectAll(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->GarbageCollectMe();
            }
        }

        bool CheckRefresh(const std::string& sEntityName)
        {
            ETYPE* pEntity = GetEntity(sEntityName);
            if(pEntity!=0){
                pEntity->Refresh();
                return true;
            }
            return false;
        }

        virtual int PrintToFile(CParaFile* pOutputFile)
        {
            int i=0;
            if (pOutputFile)
            {
                typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
                for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP,++i)
                {
                    pOutputFile->WriteString(itCurCP->second->GetKey());
                    pOutputFile->WriteString("\n");
                }
            }
            return i;
        }

    public:
        virtual void InitDeviceObjects(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->InitDeviceObjects();
            }
        };
        virtual void RestoreDeviceObjects(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->RestoreDeviceObjects();
            }
        }
        virtual void InvalidateDeviceObjects(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->InvalidateDeviceObjects();
            }
        }
        virtual void DeleteDeviceObjects(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for( itCurCP = m_items.begin(); itCurCP != itEndCP; ++ itCurCP)
            {
                itCurCP->second->DeleteDeviceObjects();
            }
        }
        virtual void RendererRecreated(){
            typename AssetItemsSet_t::iterator itCurCP, itEndCP = m_items.end();
            for (itCurCP = m_items.begin(); itCurCP != itEndCP; ++itCurCP)
            {
                itCurCP->second->RendererRecreated();
            }
        }
    public:
        std::string m_sName;
        AssetItemsNameMap_t m_names;
        AssetItemsSet_t m_items;
        AssetItemsNameMap_t m_lowercase_item_maps;
    };
}