#include <creaImageIOMultiThreadImageReader.h>
#include <creaImageIOImageReader.h>
#include <wx/utils.h>

namespace creaImageIO
{

  //=====================================================================
  void MultiThreadImageReaderUser::MultiThreadImageReaderSendEvent
  ( const std::string& filename,
    EventType type,
    vtkImageData* image)
  {
    wxMutexLocker lock(mMultiThreadImageReaderUserMutex);
    this->OnMultiThreadImageReaderEvent(filename,type,image);
  }
  //=====================================================================

  //=====================================================================
  class ThreadedImageReader: public wxThread
  {
  public:
    ThreadedImageReader(MultiThreadImageReader* tir) :
      mMultiThreadImageReader(tir)
    {}

    void* Entry();
    void  OnExit();

    vtkImageData* Read(const std::string& filename);
    

  private:
    ImageReader mReader;
    MultiThreadImageReader* mMultiThreadImageReader;
  };
  //=====================================================================

  
  //=====================================================================
  MultiThreadImageReader::MultiThreadImageReader(int number_of_threads)
    : //mDoNotSignal(false),
      mReader(0),
      mTotalMem(0),
      mTotalMemMax(10000)
  {
    //    std::cout << "#### MultiThreadImageReader::MultiThreadImageReader("
    //	      << " #threads= " << number_of_threads <<" )"<<std::endl;

    // Create the threads
    for (int i=0; i<number_of_threads; i++) 
      {
	ThreadedImageReader* t = new ThreadedImageReader(this);
	mThreadedImageReaderList.push_back(t);
      }
    mNumberOfThreadedReadersRunning = 0;
    // Init the queue
    mQueue.set(mComparator);
    mQueue.set(mIndexer);
    // 
    // no thread : alloc self reader
    if (number_of_threads==0)
      {
	mReader = new ImageReader();
      }
  }
  //=====================================================================


  //=====================================================================
  bool MultiThreadImageReader::Start()
  {

    //    std::cout << "#### MultiThreadImageReader::Start()"
    //    	      <<std::endl;
    ThreadedImageReaderListType::iterator i;
    for (i =mThreadedImageReaderList.begin();
	 i!=mThreadedImageReaderList.end();
	 i++)
      {
	(*i)->Create();
	if ( (*i)->Run() != wxTHREAD_NO_ERROR )
	  {
	    std::cout << "ERROR starting a thread"<< std::endl;
	    return false;
	  }
	else 
	  {
	    //	    std::cout << "  ===> Thread "<<(*i)->GetCurrentId()
	    //		      <<" successfully created"<< std::endl;
	    
	  }
      }
    wxMutexLocker locker(GetMultiThreadImageReaderUserMutex());
    //    std::cout << "EO Start : #Threads running = "
    //      	      << mNumberOfThreadedReadersRunning<<std::endl;

    return true;
  }
  //=====================================================================

  //=====================================================================
  void MultiThreadImageReader::Stop()
  { 
//		    std::cout << "#### MultiThreadImageReader::Stop()"
//    	      <<std::endl;
  //  std::cout << "Sending stop order to the threads..."<<std::endl;

    ThreadedImageReaderListType::iterator i;
    for (i =mThreadedImageReaderList.begin();
	 i!=mThreadedImageReaderList.end();
	 i++)
      {
	(*i)->Delete();
      }
    mThreadedImageReaderList.clear();
    // Wait a little to be sure that all threads have stopped
    // A better way to do this ?
    //    wxMilliSleep(1000);
    // New method : the threads generate a stop event when they have finished
    // We wait until all threads have stopped
//        std::cout << "Waiting for stop signals..."<<std::endl;
    do 
      {
	// Sleep a little
	wxMilliSleep(10);
	// Lock
	{
	  wxMutexLocker locker(GetMultiThreadImageReaderUserMutex());
//	  	  std::cout << "#Threads running = "
//	  		    << mNumberOfThreadedReadersRunning<<std::endl;
	  // Break if all readers have stopped
	  if (mNumberOfThreadedReadersRunning <= 0) 
	    {
	      break;
	    }
	}
      } 
    while (true);
//        std::cout << "All threads stopped : OK "<<std::endl;

    ImageMapType::iterator j;
    for (j =mImages.begin();
	 j!=mImages.end();
	 ++j)

      {
	delete j->first;
      }
    mImages.clear();
  }
  //=====================================================================

  //=====================================================================
  MultiThreadImageReader::~MultiThreadImageReader()
  {
    //    std::cout << "#### MultiThreadImageReader::~MultiThreadImageReader()"
    //	      <<std::endl;
    Stop();
    if (mReader) delete mReader;
  }
  //=====================================================================

  //=====================================================================
  void MultiThreadImageReader::UpdateUnloadPriority(ImageToLoadPtr p, 
						    int priority)
  {
    // not in unload queue : ciao
    if (p->UnloadIndex()<0) return;
    int old_prio = p->GetPriority();
    if (priority > old_prio) 
      {
	p->SetPriority(priority);
	mUnloadQueue.downsort(p->UnloadIndex());
      }
    else if ( old_prio > priority )
      {
 	p->SetPriority(priority);
	mUnloadQueue.upsort(p->UnloadIndex());
     }
  }
  //=====================================================================

  //=====================================================================
  void MultiThreadImageReader::Request( MultiThreadImageReaderUser* user,
					const std::string& filename, 
					int priority )
  {
    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);
    
    if (mThreadedImageReaderList.size()==0) 
      {
	// no detached reader : use self reader
	ImageToLoad itl(user,filename);
	ImageMapType::iterator i = mImages.find(&itl);
	if (i!=mImages.end())
	  {
	    ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
	    // Already inserted
	    if (pitl->GetImage() != 0)
	      {
		// Already read
		pitl->SetUser(user);
		UpdateUnloadPriority(pitl,priority);
		SignalImageRead(pitl,false);
		return; // pitl->GetImage();
	      }
	  }
	ImageToLoadPtr pitl = new ImageToLoad(user,filename,0);
	mImages[pitl] = 0;
	pitl->SetImage(mReader->Read(filename));
	UpdateUnloadPriority(pitl,priority);
	SignalImageRead(pitl,true);
	//	return pitl->GetImage();
	return;
      }


    ImageToLoad itl(user,filename);
    ImageMapType::iterator i = mImages.find(&itl);
    if (i!=mImages.end())
      {
	// Already inserted
	if (i->first->GetImage() != 0)
	  {
	    // Already read : ok :signal the user
	    UpdateUnloadPriority(i->first,priority);
	    SignalImageRead(i->first,false);
	    return;
	  }
	/// Already requested : change the priority
	ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
	pitl->SetPriority(priority);
	// Already in queue
	if (pitl->Index()>=0) 
	  {
	    // Re-sort the queue
	    mQueue.upsort(pitl->Index());
	  }
	// Not read but not in queue = being read = ok
	else 
	  {
	    
	  }
      }
    else 
      {
	// Never requested before or unloaded 
	ImageToLoadPtr pitl = new ImageToLoad(user,filename,priority);
	mImages[pitl] = 0;
	mQueue.insert(pitl);
      }
  }
  //=====================================================================

  //=====================================================================
  void MultiThreadImageReader::OnMultiThreadImageReaderEvent
  (const std::string& filename,
   MultiThreadImageReaderUser::EventType e,
   vtkImageData* image)
  {
    if ((e==MultiThreadImageReaderUser::ImageLoaded) &&
	(filename == mRequestedFilename))
      {
	mRequestedImage = image;
      }
    else if (e==MultiThreadImageReaderUser::ThreadedReaderStarted)
      {
	mNumberOfThreadedReadersRunning++;
	//	std::cout << "#TR=" << mNumberOfThreadedReadersRunning << std::endl;
      }
    else if (e==MultiThreadImageReaderUser::ThreadedReaderStopped)
      {
	mNumberOfThreadedReadersRunning--;
	//	std::cout << "#TR=" << mNumberOfThreadedReadersRunning << std::endl;
      }
  }
  //=====================================================================

  //=====================================================================
  vtkImageData* MultiThreadImageReader::GetImage(const std::string& filename)
  {
    
    //    std::cout << "** MultiThreadImageReader::GetImage('"<<filename<<"')"
    //	      <<std::endl;
    
    do 
      {
	wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);
		
	if (mThreadedImageReaderList.size()==0)
	  {
	    ImageToLoad itl(this,filename);
	    ImageMapType::iterator i = mImages.find(&itl);
	    if (i!=mImages.end())
	      {
		ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
		// Already inserted
		if (pitl->GetImage() != 0)
		  {
		    // Already read
		    UpdateUnloadPriority(pitl,
					 GetMaximalPriorityWithoutLocking()+1);
		    return pitl->GetImage();
		  }
	      }
	    ImageToLoadPtr pitl = new ImageToLoad(this,filename,0);
	    mImages[pitl] = 0;
	    pitl->SetImage(mReader->Read(filename));
	    UpdateUnloadPriority(pitl,
				 GetMaximalPriorityWithoutLocking()+1);
	    return pitl->GetImage();
	  }
	
	mRequestedFilename = filename;
	mRequestedImage = 0;
	ImageToLoad itl(this,filename);
	ImageMapType::iterator i = mImages.find(&itl);
	if (i!=mImages.end())
	  {
	    // Already inserted in queue
	    if (i->first->GetImage() != 0)
	      {
		// Already read : ok : return it 
		return i->first->GetImage();
	      }
	    /// Already requested : change the priority
	      ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
	      pitl->SetPriority( GetMaximalPriorityWithoutLocking() + 1 );
	      pitl->SetUser( this );
	      // Already in queue
	      if (pitl->Index()>=0) 
		{
		  // Re-sort the queue
		  mQueue.upsort(pitl->Index());
		}
	      // Not read but not in queue = being read = ok
	      else 
		{
		  pitl->SetUser( this );
		}
	  }
	else 
	  {
	    
	    // Never requested before or unloaded 
	    ImageToLoadPtr pitl = 
	      new ImageToLoad(this,filename,
			      GetMaximalPriorityWithoutLocking() + 1);
	    mImages[pitl] = 0;
	    mQueue.insert(pitl);
	  }
      }
    while (0);

    //    std::cout << "Waiting..."<<std::endl;

    // Waiting that it is read
    int n = 0;
    do 
      {
	//	std::cout << n++ << std::endl;
	wxMilliSleep(10);
	do 
	  {
	    //	    wxMutexLocker lock(mMutex);
	    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex());
	    if (mRequestedImage!=0) 
	      {
		return mRequestedImage;
	      } 
	  }
	while (0);
      }
    while (true);
    // 
    
  }
  //=====================================================================
  
  //=====================================================================
  void MultiThreadImageReader::SignalImageRead(ImageToLoadPtr p, 
					       bool purge)
  {
    //    std::cout << "MultiThreadImageReader::SignalImageRead" <<std::endl;
    //    std::cout << "this="<<this <<std::endl;
    //    std::cout << "user="<<p->GetUser() <<std::endl;

    if ( p->GetUser() == this ) 
      GetMultiThreadImageReaderUserMutex().Unlock();

    p->GetUser()->MultiThreadImageReaderSendEvent
      (p->GetFilename(),
       MultiThreadImageReaderUser::ImageLoaded,
       p->GetImage());

    /*
      AN ATTEMPT TO UNLOAD OLDEST IMAGE IF EXCEEDED A CERTAIN MEMORY QUOTA
      BUGGY : TO FIX 
    */
    if (!purge)  return;

    //    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex());
	   
    mUnloadQueue.insert(p);
    p->GetImage()->UpdateInformation();
    p->GetImage()->PropagateUpdateExtent();
    long ImMem = p->GetImage()->GetEstimatedMemorySize();
    mTotalMem += ImMem;
    //    std::cout << " ==> Total mem = "<<mTotalMem<<" Ko"<<std::endl;
    while (mTotalMem > mTotalMemMax)
      {
	//	std::cout 
	//		  <<"   ! Exceeded max of "
	//		  << mTotalMemMax << " : unloading oldest image ... "
	//		  << std::endl;
	if ( mUnloadQueue.size() <= 1 ) 
	  {
	    //	    std::cout << "Only one image : cannot load AND unload it !!"
	    //		      <<std::endl;
	    break; 

	  }
	ImageToLoadPtr unload = mUnloadQueue.remove_top();
	MultiThreadImageReaderUser* user = unload->GetUser();

	if ((user!=0)&&(user!=this)) 
	  {
	    user->GetMultiThreadImageReaderUserMutex().Lock();
	  }


	//	std::cout << "'" << unload->GetFilename() << "'" << std::endl;
	mTotalMem -= unload->GetImage()->GetEstimatedMemorySize();
	//	std::cout << " ==> Total mem = "<<mTotalMem<<" Ko "<<std::endl;
	

	std::string filename = unload->GetFilename();
	if (unload->Index()>=0)
	  {
	    //   std::cout << "still in queue"<<std::endl;
	  }
	unload->Index() = -1;


	ImageMapType::iterator it = mImages.find(unload);
	if (it!=mImages.end())
	  {
	    mImages.erase(it);
	  }
	//	    std::cout << "delete..."<<std::endl;
	delete unload;
	//	    std::cout << "delete ok."<<std::endl;

	if (user!=0) 
	  {
	    //	    std::cout << "unlock..."<<std::endl;
	    user->GetMultiThreadImageReaderUserMutex().Unlock();
	    //	    std::cout << "event"<<std::endl;
	    user->MultiThreadImageReaderSendEvent
	      (filename,
	       MultiThreadImageReaderUser::ImageUnloaded,
	       0);
	    //	    std::cout << "event ok"<<std::endl;

	  }
      }
    
  
  }
  //=====================================================================

  //=====================================================================
  int MultiThreadImageReader::GetMaximalPriority()
  { 
    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);
    return GetMaximalPriorityWithoutLocking();
  }
  //=====================================================================


  //=====================================================================
  int MultiThreadImageReader::GetMaximalPriorityWithoutLocking()
  { 
    long max = 0;
    if (mQueue.size()>0) 
      {
	max = mQueue.top()->GetPriority();
      }
    if (mUnloadQueue.size()>0)
      {
	int max2 = mUnloadQueue.top()->GetPriority();
	if (max2>max) max=max2;
      }
    return max;
  }
  //=====================================================================


  //=====================================================================
  //=====================================================================
  //=====================================================================
  //=====================================================================

  //=====================================================================
  void*  ThreadedImageReader::Entry()
  {
    //    std::cout << "### Thread "<<GetCurrentId()<<"::Entry()"
    //    	      << std::endl;

    mMultiThreadImageReader->MultiThreadImageReaderSendEvent
      ("",
       MultiThreadImageReaderUser::ThreadedReaderStarted,
       0);

    // While was not deleted 
    while (!TestDestroy())
      {
	//	std::cout << "### Thread "<<GetCurrentId()<<" waiting for image"
	//	  << std::endl;
	  
	// Lock the mutex
	mMultiThreadImageReader->MultiThreadImageReaderEventLock();
	//mMutex.Lock();
	// If image in queue
	if (mMultiThreadImageReader->mQueue.size()>0)
	  {
	    MultiThreadImageReader::ImageToLoadPtr i = 
	      mMultiThreadImageReader->mQueue.remove_top();

	    mMultiThreadImageReader->MultiThreadImageReaderEventUnlock();
	    //mMutex.Unlock();

	    
	    //	    std::cout << "### Thread "<<GetCurrentId()<<" : reading '"
	    //		      << i->GetFilename() << "'" << std::endl;
	    
	    // Do the job
	    vtkImageData* im = Read(i->GetFilename());

	    // Store it in the map
	    mMultiThreadImageReader->MultiThreadImageReaderEventLock();
	    //mMutex.Lock();
	    MultiThreadImageReader::ImageToLoad itl(0,i->GetFilename());
	    MultiThreadImageReader::ImageMapType::iterator it = 
	      mMultiThreadImageReader->mImages.find(&itl);
	    MultiThreadImageReader::ImageToLoadPtr 
	      pitl = const_cast<MultiThreadImageReader::ImageToLoadPtr>
	      (it->first);
	    pitl->SetImage(im);
	    mMultiThreadImageReader->SignalImageRead(pitl,true);//i->GetFilename());
	    mMultiThreadImageReader->MultiThreadImageReaderEventUnlock();	    //mMutex.Unlock();
	    
	    //	    std::cout << "### Thread "<<GetCurrentId()<<" : reading '"
	    //		      << i->GetFilename() << "' : DONE" << std::endl;
	    
	  }
	else 
	  {
	    mMultiThreadImageReader->MultiThreadImageReaderEventUnlock();
	    //mMutex.Unlock();
	    // Wait a little to avoid blocking 
	    Sleep(10);
	  }
      };
    //    std::cout << "### Thread "<<GetCurrentId()<<" stopping"
    //   	      << std::endl;
       
    return 0;
  }
  //=====================================================================

  //=====================================================================
  void ThreadedImageReader::OnExit()
  {
    mMultiThreadImageReader->MultiThreadImageReaderSendEvent
      ("",
       MultiThreadImageReaderUser::ThreadedReaderStopped,
       0);
  }
  //=====================================================================

  //=====================================================================
  vtkImageData* ThreadedImageReader::Read(const std::string& filename)
  {
    return mReader.Read(filename);
  }
  //=====================================================================

} // namespace creaImageIO