#include <stdlib.h>
#include <stdio.h>

#if defined(__CYGWIN__)
#include <windows.h>
#include <unistd.h>
#include <pthread.h>
#elif defined(_WIN32)
#include <windows.h>
#include <conio.h>
#else
#include <unistd.h>
#include <pthread.h>
#endif

#include "TrPageArchive.h"
#include "trPagePageManager.h"
#include "trpage_print.h"

#include <osg/Group>
#include <osg/Object>
#include <osg/Node>
#include <osg/Notify>
#include <osg/Geode>
#include <osg/Texture>

#include <osgDB/Registry>
#include <osgDB/FileUtils>

#include <iostream>

using namespace txp;
using namespace osg;

OSGPageManager::OSGPageManager(TrPageArchive *in_arch,trpgPageManager *in_pageManage)
{
    archive = in_arch;
    pageManage = in_pageManage;

    if (!in_arch)
        throw 1;

    if (pageManage)
        pageManageOurs = false;
    else {
        pageManage = new trpgPageManager();
        pageManage->SetPageDistFactor(1.2);
        pageManage->Init(archive);
        pageManageOurs = true;
    }

    // Location info we'll need later
    const trpgHeader *head = archive->GetHeader();
    trpg2dPoint sw,ne;
    head->GetExtents(sw,ne);
    originX = sw.x;
    originY = sw.y;

    threadMode = ThreadNone;
}

OSGPageManager::~OSGPageManager()
{
    if (threadMode != ThreadNone)
        EndThread();
    if (pageManageOurs)
        delete pageManage;
    pageManage = NULL;
}

/* Update
    Bring the paging up to date based on the given location.
    The location is in TerraPage's coordinate system, but must
    still be adjusted to the SW corner.
 */
bool OSGPageManager::UpdateNoThread(osg::Group *rootNode,double locX,double locY,int numTile)
{
    // Adjust to TerraPage coordinates
    double lx = locX-originX;
    double ly = locY-originY;

    /* Do that paging thing:
        - Tell the manager the new location
        - Iterate over the unloads
        - Iterate over the loads
     */
    trpg2dPoint loc;
    loc.x = lx;
    loc.y = ly;
    if (pageManage->SetLocation(loc)) {
//        printf("Location (%f,%f) resulted in changes.",loc.x,loc.y);
//        trpgFilePrintBuffer printBuf(stdout);
//        pageManage->Print(printBuf);
    }

    // Do the unloads
    trpgManagedTile *tile=NULL;
    while ((tile = pageManage->GetNextUnload())) {
        archive->UnLoadTile(pageManage,tile);
        pageManage->AckUnload();
    };

    // Decide how many loads to do per frame
    int loadCount=0;

    // Do the loads
    while ((tile = pageManage->GetNextLoad())) {
        archive->LoadTile(rootNode,pageManage,tile);
        pageManage->AckLoad();
        loadCount++;
        if (numTile > 0 && loadCount >= numTile)
            break;
    };

    return true;
}

// Mutex lock function
// --- Either thread ---
void osgLockMutex(ThreadMutex &mtx)
{
#if defined (_WIN32)
    WaitForSingleObject( mtx, INFINITE);   
#else
    pthread_mutex_lock( &mtx );
#endif
}

// Mutex unlock function
// --- Either thread ---
void osgUnLockMutex(ThreadMutex &mtx)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
    ReleaseMutex(mtx);
#else
    pthread_mutex_unlock( &mtx );
#endif
}

// Wait for Event
// --- Either thread (only used in paging thread) ---
void osgWaitEvent(ThreadEvent &ev)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
    WaitForSingleObject( ev, INFINITE);
#else
    ev.wait();
#endif
}

// Set Event (i.e. notify the other thread something's up)
// --- Either thread (only used in main thread) ---
void osgSetEvent(ThreadEvent &ev)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
    SetEvent(ev);
#else
    ev.release();
#endif
}

// Windows specific thread function.
// This just fires up our own loop
// --- Paging Thread ---
#if defined(_WIN32) && !defined(__CYGWIN__)
DWORD WINAPI ThreadFunc( LPVOID lpParam ) 
{
    OSGPageManager *myPager = (OSGPageManager *)lpParam;
    myPager->ThreadLoop();

    return 0; 
}
#else // Pthreads, cause Pthreads is a POSIX standard and is EVERYWHERE else

void *ThreadFunc( void *data )
{
    OSGPageManager *myPager = static_cast<OSGPageManager *>(data);
    myPager->ThreadLoop();
    return 0L;
}
#endif

/* Start Thread
    This initialized
    --- Main Thread ---
 */
bool OSGPageManager::StartThread(ThreadMode mode,ThreadID &newThread)
{
    positionValid = false;

#if defined(_WIN32) && !defined(__CYGWIN__)
    // Create the event we'll use to wake up the pager thread when the location changes
    locationChangeEvent = CreateEvent(NULL,false,false,"Location Change Event");

    // Create the mutexes we'll need later
    changeListMutex = CreateMutex(NULL,false,"Change List Mutex");
    locationMutex = CreateMutex(NULL,false,"Location Mutex");

    {
        // Create the thread
        DWORD dwThreadId=0;
        LPVOID dwThrdParam = (LPVOID) this;

        threadID = newThread = CreateThread( 
            NULL,                        // default security attributes 
            0,                           // use default stack size  
            ThreadFunc,                  // thread function 
            dwThrdParam,                // argument to thread function 
            0,                           // use default creation flags 
            &dwThreadId);                // returns the thread identifier 
    }

    // Note: Should be optional
    // Set the priority low so this is only called when the other thread is idle
//    if (!SetThreadPriority(newThread,THREAD_PRIORITY_IDLE))
//        fprintf(stderr,"Couldn't set paging thread priority.\n");

    // Was successfull
    if (newThread != NULL)
        threadMode = mode;
#else
    //locationChangeEvent is self-initialized.
    pthread_mutex_init( &changeListMutex, 0L );
    pthread_mutex_init( &locationMutex, 0L );
    threadMode = mode;
    if( pthread_create( &newThread, 0L, ThreadFunc, (void *)this ) != 0 )
        threadMode = ThreadNone;
    threadID = newThread;
#endif
    return threadMode != ThreadNone;
}

/* End Thread
    Note: Do this
 */
bool OSGPageManager::EndThread()
{
    cancel = true;
    // claer the path for thred loop to finish 
    osgSetEvent(locationChangeEvent);
#ifdef _WIN32
    DWORD res = STILL_ACTIVE;
    while(res==STILL_ACTIVE){
        GetExitCodeThread(threadID,&res);
        Sleep(100);
    }
#else
    // Need a handle to the thread ID here.
    pthread_join( threadID, 0 );
#endif
    return true;
}

/* Thread Loop
    This method is the main loop for the pager when it's
    working in its own thread.
    --- Paging Thread ---
 */
bool OSGPageManager::ThreadLoop()
{
    // Note: Only works for free running thread
    if (threadMode != ThreadFree)
        throw 1;

    bool pagingActive = false;
    cancel = false;

    while (!cancel) {
        /* Here's how we do it:
            Wait for position change
              Update manager w/ position
              Form delete list
              Load tile (if needed)
              Add tile to merge list
         */
        // Position has already changed or we'll wait for it to do so
        osgWaitEvent(locationChangeEvent);
        double myLocX,myLocY;
        {
            osgLockMutex(locationMutex);
            myLocX = locX;
            myLocY = locY;
            osgUnLockMutex(locationMutex);
        }

        // Pass the new location on to page manager
        trpg2dPoint loc;
        loc.x = myLocX;
        loc.y = myLocY;
        if (pageManage->SetLocation(loc) || pagingActive) {
            // If there were changes, process them
            // Form the delete list first
            trpgManagedTile *tile=NULL;
            std::vector<osg::Group *> unhook;
            while ((tile = pageManage->GetNextUnload())) {
                unhook.push_back((Group *)(tile->GetLocalData()));
                pageManage->AckUnload();
            }

            // Tell the main thread to unhook tiles
            //  and get the groups to delete as well.
            std::vector <osg::Group *> nextDelete;
            {
                osgLockMutex(changeListMutex);
                // Add to the unhook list
                for (unsigned int ti=0;ti<unhook.size();ti++)
                    toUnhook.push_back(unhook[ti]);
                // Also get the list of deletions while we're here
#ifdef USE_THREADLOOP_DELETE
                nextDelete = toDelete;
                toDelete.clear();
#endif
                osgUnLockMutex(changeListMutex);
            }

#ifdef USE_THREADLOOP_DELETE
           // Unreference whatever we're supposed to delete
           for (unsigned int gi=0;gi<nextDelete.size();gi++)
                nextDelete[gi]->unref();
#endif

            // Now do a single load
           while( (tile = pageManage->GetNextLoad()) ) // Sasa's new code - more frame drops, but less missing tiles.
           //if( (tile = pageManage->GetNextLoad()) )  // original code (0.9.4 and before) - less frame drops, more missing tiles.
           {
               osg::Group *tileGroup=NULL;
               pagingActive = false;
               osg::Group *parentNode = NULL;
               tileGroup = archive->LoadTile(NULL,pageManage,tile,&parentNode);
               pageManage->AckLoad();
               if (tileGroup) {
#ifdef USE_THREADLOOP_DELETE
                   // Make an extra reference to it because we want it back for deletion
                   // RO, commenting out as we don't want to do delete here, we want it to happen in the merge thread.
                   tileGroup->ref();
#endif
               } 
               else 
               {
                   int x,y,lod;
                   tile->GetTileLoc(x,y,lod);
                   fprintf(stderr,"Failed to load tile (%d,%d,%d)\n",x,y,lod);
               }
               
               // Now add this tile to the merge list
               if (tileGroup) {
                   osgLockMutex(changeListMutex);
                   toMerge.push_back(tileGroup);
                   toMergeParent.push_back(parentNode);
                   osgUnLockMutex(changeListMutex);
               }
               // We're not necessarily done paging, we're just handing control back
               // It's likely we'll be back here
               pagingActive = true;
           }
        }
    }


    return true;
}

/* Update Position Thread
    This method updates the location for the paging thread to use.
    --- Main Thread ---
 */
void OSGPageManager::UpdatePositionThread(double inLocX,double inLocY)
{
    // Update the position
    {
        // Get the location mutex
        osgLockMutex(locationMutex);
        positionValid = true;
        locX = inLocX-originX;
        locY = inLocY-originY;
        osgUnLockMutex(locationMutex);
    }

    // Notify the paging thread there's been a position update
    osgSetEvent(locationChangeEvent);
}

class ReleaseTexturesAndDrawablesVisitor : public osg::NodeVisitor
{
public:
    ReleaseTexturesAndDrawablesVisitor():
        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN)
    {
    }
    
    virtual void apply(osg::Node& node)
    {
        apply(node.getStateSet());

        traverse(node);
    }
    
    virtual void apply(osg::Geode& geode)
    {
        apply(geode.getStateSet());
    
        for(unsigned int i=0;i<geode.getNumDrawables();++i)
        {
            apply(geode.getDrawable(i));
        }

        traverse(geode);
    }
    
    inline void apply(osg::StateSet* stateset)
    {
        if (stateset)
        {
            // search for the existance of any texture object attributes
            bool foundTextureState = false;
            osg::StateSet::TextureAttributeList& tal = stateset->getTextureAttributeList();
            for(osg::StateSet::TextureAttributeList::iterator itr=tal.begin();
                itr!=tal.end() && !foundTextureState;
                ++itr)
            {
                osg::StateSet::AttributeList& al = *itr;
                osg::StateSet::AttributeList::iterator alitr = al.find(osg::StateAttribute::TEXTURE);
                if (alitr!=al.end())
                {
                    // found texture, so place it in the texture list.
                    osg::Texture* texture = static_cast<osg::Texture*>(alitr->second.first.get());
                    texture->dirtyTextureObject();
                }
            }
        }
    }
    
    inline void apply(osg::Drawable* drawable)
    {
        apply(drawable->getStateSet());

        if (drawable->getUseDisplayList() || drawable->getUseVertexBufferObjects());
        {
            drawable->dirtyDisplayList();
        }
    }
        
};

/* Merge Updates
    Merge in the new tiles and unhook the ones we'll be deleting.
    Actually, we'll hand these back to the paging thread for deletion.
    --- Main Thread ---
 */
bool OSGPageManager::MergeUpdateThread(osg::Group *rootNode)
{
    std::vector<osg::Group *> mergeList;
    std::vector<osg::Group *> mergeParentList;
    std::vector<osg::Group *> unhookList;

    // Make local copies of the merge and unhook lists
    {
        osgLockMutex(changeListMutex);
        mergeList = toMerge;
        mergeParentList = toMergeParent;
        unhookList = toUnhook;

        toMerge.clear();
        toMergeParent.clear();
        toUnhook.clear();
        osgUnLockMutex(changeListMutex);
    }

    // Do the unhooking first
    for (unsigned int ui=0;ui<unhookList.size();ui++) {
        osg::Group *unhookMe = unhookList[ui];

        // Look for its parent(s)
        // Only expecting one, but it doesn't matter
        const osg::Node::ParentList &parents = unhookMe->getParents();
        for (unsigned int pi=0;pi<parents.size();pi++) {
            osg::Group *parent = parents[pi];
            parent->removeChild(unhookMe);
        }
    }
    
#ifdef USE_THREADLOOP_DELETE
    // Put the unhooked things on the list to delete
    {
        ReleaseTexturesAndDrawablesVisitor rtadv;
        osgLockMutex(changeListMutex);
        for (unsigned int di=0;di<unhookList.size();di++)
        {
            toDelete.push_back(unhookList[di]);
            unhookList[di]->accept(rtadv);
        }
        osgUnLockMutex(changeListMutex);
    }
#endif

    // Do the merging last
    {
        for (unsigned int mi=0;mi<mergeList.size();mi++) {
            osg::Group *mergeMe = mergeList[mi];
            osg::Group *parent = mergeParentList[mi];
            if (parent)
                parent->addChild(mergeMe);
            else
                rootNode->addChild(mergeMe);
        }
    }

    return true;
}