/**
 * @file llvocache.h
 * @brief Cache of objects on the viewer.
 *
 * $LicenseInfo:firstyear=2003&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLVOCACHE_H
#define LL_LLVOCACHE_H

#include "lluuid.h"
#include "lldatapacker.h"
#include "lldir.h"
#include "llvieweroctree.h"
#include "llapr.h"
#include "llgltfmaterial.h"

#include <unordered_map>

//---------------------------------------------------------------------------
// Cache entries
class LLCamera;

class LLGLTFOverrideCacheEntry
{
public:
    static const std::string VERSION_LABEL;
    static const int VERSION;
    bool fromLLSD(const LLSD& data);
    LLSD toLLSD() const;

    LLUUID mObjectId;
    U32    mLocalId = 0;
    std::unordered_map<S32, LLSD> mSides; //override LLSD per side
    std::unordered_map<S32, LLPointer<LLGLTFMaterial> > mGLTFMaterial; //GLTF material per side
    U64 mRegionHandle = 0;
};

class LLVOCacheEntry
:   public LLViewerOctreeEntryData
{
    LL_ALIGN_NEW
public:
    enum
    {
        //low 16-bit state
        INACTIVE = 0x00000000,     //not visible
        IN_QUEUE = 0x00000001,     //in visible queue, object to be created
        WAITING  = 0x00000002,     //object creation request sent
        ACTIVE   = 0x00000004,      //object created, and in rendering pipeline.

        //high 16-bit state
        IN_VO_TREE = 0x00010000,    //the entry is in the object cache tree.

        LOW_BITS  = 0x0000ffff,
        HIGH_BITS = 0xffff0000
    };

    struct CompareVOCacheEntry
    {
        bool operator()(const LLVOCacheEntry* const& lhs, const LLVOCacheEntry* const& rhs) const
        {
            F32 lpa = lhs->getSceneContribution();
            F32 rpa = rhs->getSceneContribution();

            //larger pixel area first
            if(lpa > rpa)
            {
                return true;
            }
            else if(lpa < rpa)
            {
                return false;
            }
            else
            {
                return lhs < rhs;
            }
        }
    };

protected:
    ~LLVOCacheEntry();
public:
    LLVOCacheEntry(U32 local_id, U32 crc, LLDataPackerBinaryBuffer &dp);
    LLVOCacheEntry(LLAPRFile* apr_file);
    LLVOCacheEntry();

    void updateEntry(U32 crc, LLDataPackerBinaryBuffer &dp);

    void clearState(U32 state) {mState &= ~state;}
    bool hasState(U32 state)   {return mState & state;}
    void setState(U32 state);
    bool isState(U32 state)    {return (mState & LOW_BITS) == state;}
    U32  getState() const      {return mState & LOW_BITS;}

    bool isAnyVisible(const LLVector4a& camera_origin, const LLVector4a& local_camera_origin, F32 dist_threshold);

    U32 getLocalID() const          { return mLocalID; }
    U32 getCRC() const              { return mCRC; }
    S32 getHitCount() const         { return mHitCount; }
    S32 getCRCChangeCount() const   { return mCRCChangeCount; }

    void calcSceneContribution(const LLVector4a& camera_origin, bool needs_update, U32 last_update, F32 dist_threshold);
    void setSceneContribution(F32 scene_contrib) {mSceneContrib = scene_contrib;}
    F32 getSceneContribution() const             { return mSceneContrib;}

    void dump() const;
    S32 writeToBuffer(U8 *data_buffer) const;
    LLDataPackerBinaryBuffer *getDP();
    void recordHit();
    void recordDupe() { mDupeCount++; }

    /*virtual*/ void setOctreeEntry(LLViewerOctreeEntry* entry);

    void setParentID(U32 id);
    U32  getParentID() const {return mParentID;}
    bool isChild() const {return mParentID > 0;}

    void addChild(LLVOCacheEntry* entry);
    void removeChild(LLVOCacheEntry* entry);
    void removeAllChildren();
    LLVOCacheEntry* getChild(); //remove the first child, and return it.
    S32  getNumOfChildren() const { return static_cast<S32>(mChildrenList.size()); }

    void setBoundingInfo(const LLVector3& pos, const LLVector3& scale); //called from processing object update message
    void updateParentBoundingInfo();
    void saveBoundingSphere();

    void setValid(bool valid = true) {mValid = valid;}
    bool isValid() const {return mValid;}

    void setUpdateFlags(U32 flags) {mUpdateFlags = flags;}
    U32  getUpdateFlags() const    {return mUpdateFlags;}

    static void updateDebugSettings();
    static F32  getSquaredPixelThreshold(bool is_front);

private:
    void updateParentBoundingInfo(const LLVOCacheEntry* child);

public:
    typedef std::map<U32, LLPointer<LLVOCacheEntry> >      vocache_entry_map_t;
    typedef std::set<LLVOCacheEntry*>                      vocache_entry_set_t;
    typedef std::set<LLVOCacheEntry*, CompareVOCacheEntry> vocache_entry_priority_list_t;

    typedef std::unordered_map<U32, LLGLTFOverrideCacheEntry>  vocache_gltf_overrides_map_t;

    S32                         mLastCameraUpdated;
protected:
    U32                         mLocalID;
    U32                         mParentID;
    U32                         mCRC;
    U32                         mUpdateFlags; //receive from sim
    S32                         mHitCount;
    S32                         mDupeCount;
    S32                         mCRCChangeCount;
    LLDataPackerBinaryBuffer    mDP;
    U8                          *mBuffer;

    F32                         mSceneContrib; //projected scene contributuion of this object.
    U32                         mState; //high 16 bits reserved for special use.
    vocache_entry_set_t         mChildrenList; //children entries in a linked set.

    bool                        mValid; //if set, this entry is valid, otherwise it is invalid and will be removed.

    LLVector4a                  mBSphereCenter; //bounding sphere center
    F32                         mBSphereRadius; //bounding sphere radius

public:
    static U32                  sMinFrameRange;
    static F32                  sNearRadius;
    static F32                  sRearFarRadius;
    static F32                  sFrontPixelThreshold;
    static F32                  sRearPixelThreshold;
};

class LLVOCacheGroup : public LLOcclusionCullingGroup
{
public:
    LLVOCacheGroup(OctreeNode* node, LLViewerOctreePartition* part) : LLOcclusionCullingGroup(node, part){}

    //virtual
    void handleChildAddition(const OctreeNode* parent, OctreeNode* child);

protected:
    virtual ~LLVOCacheGroup();
};

class LLVOCachePartition : public LLViewerOctreePartition
{
public:
    LLVOCachePartition(LLViewerRegion* regionp);
    virtual ~LLVOCachePartition();

    bool addEntry(LLViewerOctreeEntry* entry);
    void removeEntry(LLViewerOctreeEntry* entry);
    /*virtual*/ S32 cull(LLCamera &camera, bool do_occlusion);
    void addOccluders(LLViewerOctreeGroup* gp);
    void resetOccluders();
    void processOccluders(LLCamera* camera);
    void removeOccluder(LLVOCacheGroup* group);

    void setCullHistory(bool has_new_object);

    bool isFrontCull() const {return mFrontCull;}

private:
    void selectBackObjects(LLCamera &camera, F32 projection_area_cutoff, bool use_occlusion); //select objects behind camera.

public:
    static bool sNeedsOcclusionCheck;

private:
    bool  mFrontCull; //the view frustum cull if set, otherwise is back sphere cull.
    U32   mCullHistory;
    U32   mCulledTime[LLViewerCamera::NUM_CAMERAS];
    std::set<LLVOCacheGroup*> mOccludedGroups;

    S32   mBackSlectionEnabled; //enable to select back objects if > 0.
    U32   mIdleHash;
};

//
//Note: LLVOCache is not thread-safe
//
class LLVOCache : public LLParamSingleton<LLVOCache>
{
    LLSINGLETON(LLVOCache, bool read_only);
    ~LLVOCache() ;

private:
    struct HeaderEntryInfo
    {
        HeaderEntryInfo() : mIndex(0), mHandle(0), mTime(0) {}
        S32 mIndex;
        U64 mHandle ;
        U32 mTime ;
    };

    struct HeaderMetaInfo
    {
        HeaderMetaInfo() : mVersion(0), mAddressSize(0) {}

        U32 mVersion;
        U32 mAddressSize;
    };

    struct header_entry_less
    {
        bool operator()(const HeaderEntryInfo* lhs, const HeaderEntryInfo* rhs) const
        {
            if(lhs->mTime == rhs->mTime)
            {
                return lhs < rhs ;
            }

            return lhs->mTime < rhs->mTime ; // older entry in front of queue (set)
        }
    };
    typedef std::set<HeaderEntryInfo*, header_entry_less> header_entry_queue_t;
    typedef std::map<U64, HeaderEntryInfo*> handle_entry_map_t;

public:
    // We need this init to be separate from constructor, since we might construct cache, purge it, then init.
    void initCache(ELLPath location, U32 size, U32 cache_version);
    void removeCache(ELLPath location, bool started = false) ;

    bool readFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_entry_map_t& cache_entry_map) ;
    void readGenericExtrasFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map);

    void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, bool dirty_cache, bool removal_enabled);
    void writeGenericExtrasToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map, bool dirty_cache, bool removal_enabled);
    void removeEntry(U64 handle) ;
    void removeGenericExtrasForHandle(U64 handle);

    U32 getCacheEntries() { return mNumEntries; }
    U32 getCacheEntriesMax() { return mCacheSize; }

private:
    void setDirNames(ELLPath location);
    // determine the cache filename for the region from the region handle
    void getObjectCacheFilename(U64 handle, std::string& filename);
    std::string getObjectCacheExtrasFilename(U64 handle);
    void removeFromCache(HeaderEntryInfo* entry);
    void readCacheHeader();
    void writeCacheHeader();
    void clearCacheInMemory();
    void removeCache() ;
    void removeEntry(HeaderEntryInfo* entry) ;
    void purgeEntries(U32 size);
    bool updateEntry(const HeaderEntryInfo* entry);

private:
    bool                 mEnabled;
    bool                 mInitialized ;
    bool                 mReadOnly ;
    HeaderMetaInfo       mMetaInfo;
    U32                  mCacheSize;
    U32                  mNumEntries;
    std::string          mHeaderFileName ;
    std::string          mObjectCacheDirName;
    LLVolatileAPRPool*   mLocalAPRFilePoolp ;
    header_entry_queue_t mHeaderEntryQueue;
    handle_entry_map_t   mHandleEntryMap;
};

#endif