/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#pragma once

#include "base/HybridComponentManager.h"
#include "base/Lock.h"
#include "snapshot/common.h"
#include "GLcommon/GLBackgroundLoader.h"
#include "GLcommon/NamedObject.h"
#include "GLcommon/ObjectData.h"
#include "GLcommon/SaveableTexture.h"
#include "GLcommon/TranslatorIfaces.h"

#include <GLES/gl.h>
#include <unordered_map>
#include <unordered_set>

typedef android::base::HybridComponentManager<10000, ObjectLocalName, NamedObjectPtr> NamesMap;
typedef std::unordered_map<ObjectLocalName, ObjectDataPtr> ObjectDataMap;
typedef android::base::HybridComponentManager<10000, unsigned int, ObjectLocalName> GlobalToLocalNamesMap;
typedef android::base::HybridComponentManager<10000, ObjectLocalName, bool> BoundAtLeastOnceMap;

class GlobalNameSpace;

//
// Class NameSpace - this class manages allocations and deletions of objects
//                   from a single "local" namespace (private to a context share
//                   group). For each allocated object name, a "global" name is
//                   generated as well to be used in the space where all
//                   contexts are shared.
//
//   NOTE: this class does not used by the EGL/GLES layer directly,
//         the EGL/GLES layer creates objects using the ShareGroup class
//         interface (see below).
class NameSpace
{
public:

    NameSpace(NamedObjectType p_type, GlobalNameSpace *globalNameSpace,
              android::base::Stream* stream,
              const ObjectData::loadObject_t& loadObject);
    ~NameSpace();

    //
    // genName - creates new object in the namespace and  returns its name.
    //           if genLocal is false then the specified p_localName will be used.
    //           This function also generate a global name for the object,
    //           the value of the global name can be retrieved using the
    //           getGlobalName function.
    //
    ObjectLocalName genName(GenNameInfo genNameInfo, ObjectLocalName p_localName, bool genLocal);

    //
    // getGlobalName - returns the global name of an object or 0 if the object
    //                 does not exist.
    //
    unsigned int getGlobalName(ObjectLocalName p_localName, bool* found = nullptr);

    //
    // getLocaalName - returns the local name of an object or 0 if the object
    //                 does not exist.
    //
    ObjectLocalName getLocalName(unsigned int p_globalName);

    //
    // getNamedObject - returns the shared pointer of an object or null if the
    //                  object does not exist.
    NamedObjectPtr getNamedObject(ObjectLocalName p_localName);

    //
    // deleteName - deletes and object from the namespace as well as its
    //              global name from the global name space.
    //
    void deleteName(ObjectLocalName p_localName);

    //
    // isObject - returns true if the named object exist.
    //
    bool isObject(ObjectLocalName p_localName);

    //
    // sets an object to map to an existing global object.
    //
    void setGlobalObject(ObjectLocalName p_localName,
            NamedObjectPtr p_namedObject);
    //
    // replaces an object to map to an existing global object
    //
    void replaceGlobalObject(ObjectLocalName p_localName, NamedObjectPtr p_namedObject);

    // sets that the local name has been bound at least once, to save time later
    void setBoundAtLeastOnce(ObjectLocalName p_localName);
    bool everBound(ObjectLocalName p_localName) const;

    const ObjectDataPtr& getObjectDataPtr(ObjectLocalName p_localName);
    void setObjectData(ObjectLocalName p_localName, ObjectDataPtr data);
    // snapshot functions
    void postLoad(const ObjectData::getObjDataPtr_t& getObjDataPtr);
    void postLoadRestore(const ObjectData::getGlobalName_t& getGlobalName);
    void preSave(GlobalNameSpace *globalNameSpace);
    void onSave(android::base::Stream* stream);
    ObjectDataMap::const_iterator objDataMapBegin() const;
    ObjectDataMap::const_iterator objDataMapEnd() const;
private:
    ObjectLocalName m_nextName = 0;
    NamesMap m_localToGlobalMap;
    ObjectDataMap m_objectDataMap;
    BoundAtLeastOnceMap m_boundMap;
    GlobalToLocalNamesMap m_globalToLocalMap;
    const NamedObjectType m_type;
    GlobalNameSpace *m_globalNameSpace = nullptr;
    // touchTextures loads all textures onto GPU
    // Please only call it if the NameSpace is for textures
    void touchTextures();
};

struct EglImage;
class TextureData;

// Class GlobalNameSpace - this class maintain all global GL object names.
//                         It is contained in the EglDisplay. One emulator has
//                         only one GlobalNameSpace.
class GlobalNameSpace
{
public:
    friend class NamedObject;

    // The following are used for snapshot
    void preSaveAddEglImage(EglImage* eglImage);
    void preSaveAddTex(TextureData* texture);
    void onSave(android::base::Stream* stream,
                const android::snapshot::ITextureSaverPtr& textureSaver,
                SaveableTexture::saver_t saver);
    void onLoad(android::base::Stream* stream,
                const android::snapshot::ITextureLoaderWPtr& textureLoaderWPtr,
                SaveableTexture::creator_t creator);
    void postLoad(android::base::Stream* stream);
    const SaveableTexturePtr& getSaveableTextureFromLoad(unsigned int oldGlobalName);
    SaveableTextureMap* getSaveableTextureMap() { return &m_textureMap; }

    void clearTextureMap();

    void setIfaces(const EGLiface* eglIface,
                   const GLESiface* glesIface) {
        m_eglIface = eglIface;
        m_glesIface = glesIface;
    }

private:

    android::base::Lock m_lock;
    // m_textureMap is only used when saving / loading a snapshot
    // It is empty in all other situations
    SaveableTextureMap m_textureMap;

    std::shared_ptr<GLBackgroundLoader>     m_backgroundLoader;

    const EGLiface* m_eglIface = nullptr;
    const GLESiface* m_glesIface = nullptr;
};