#include <creaImageIOWxViewer.h>
#include <creaImageIOSystem.h>
#include <fstream>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkImageData.h>

#include <creaMessageManager.h>
#include <stdio.h>
#include <time.h>


using namespace crea;

namespace creaImageIO
{

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

  //=====================================================================
  class ThreadedMovie: public wxThread
  {
  public:
    ThreadedMovie(std::vector<vtkImageData*> m, vtkImageViewer2* v, crea::creawxVTKRenderWindowInteractor* i, WxViewer* parent) :
      mImagesToPlay(m), mViewer(v), mInteractor(i), mParent(parent)
    {}

    void* Entry();
    void SetImagesToPlay(std::vector<vtkImageData*> im);
    void ShowImage(vtkImageData* v);
	void StartIterator();
    void  OnExit();

  private:
	  std::vector<vtkImageData*> mImagesToPlay;
	  vtkImageViewer2* mViewer;
	  /// Associated wxvtk interactor
	crea::creawxVTKRenderWindowInteractor  *mInteractor;
	std::vector<vtkImageData*>::iterator i;
	WxViewer* mParent;
  
    int mx1,mx2,my1,my2,mz1,mz2;
    double mspx,mspy,mspz;
  };
  
  //=====================================================================



  

  //=====================================================================
  // CTor
  WxViewer::WxViewer(wxWindow *parent, 
					       wxWindowID id,
					       wxString title,
					       const wxPoint& pos,
					       const wxSize& size)
 :   wxFrame( parent, 
		  id, 
		  title,
		  pos,
		  size, 
		  wxCAPTION)
  {
    GimmickDebugMessage(1,"WxViewer::WxViewer"
			<<std::endl);
    wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);

	
    // previewer
	
    mInteractor = new crea::creawxVTKRenderWindowInteractor(this,-1);
    mInteractor->UseCaptureMouseOn();	
 
    mViewer	= vtkImageViewer2::New();
    mViewer->SetupInteractor ( mInteractor );
    
    mMovie=new ThreadedMovie(images, mViewer, mInteractor, this);
	
    topsizer-> Add( mInteractor ,1,wxGROW  ,0);
    SetSizer( topsizer );     
    Layout(); 
  }

  /// Destructor
  WxViewer::~WxViewer()
  {
    GimmickDebugMessage(1,"WxViewer::~WxViewer"
			<<std::endl);
  }


  void WxViewer::ShowImage(vtkImageData* im)
  {
    GimmickDebugMessage(5,"WxViewer::ShowImage"
			<<std::endl);
    mViewer->SetInput(im);
    mViewer->SetSlice( 0 );
    
    int x1,x2,y1,y2,z1,z2;
    double spx,spy,spz;
    im->Update();
    
    im->GetSpacing(spx,spy,spz);
    im->GetExtent (x1,x2,y1,y2,z1,z2);
    /*
    std::cout << "-----------------------------"<<std::endl;
    std::cout << x1 << "-"<<x2<<std::endl; 
    std::cout << y1 << "-"<<y2<<std::endl; 
    std::cout << z1 << "-"<<z2<<std::endl; 
    std::cout << spx << "-"<<spy<<"-"<<spz<<std::endl; 
    */
    
    if ((x1!=mx1) ||
	(x2!=mx2) ||
	(y1!=my1) ||
	(y2!=my2) ||
	(z1!=mz1) ||
	(z2!=mz2) ||
	(spx!=mspx) ||
	(spy!=mspy) ||
	(spz!=mspz) 
	)
      {
	mx1 = x1;
	mx2 = x2;
	my1 = y1;
	my2 = y2;
	mz1 = z1;
	mz2 = z2;
	mspx = spx;
	mspy = spy;
	mspz = spz;
	
	double *range = im->GetScalarRange();
	 mViewer->SetColorWindow(range[1] - range[0]);
	 mViewer->SetColorLevel(0.5 * (range[1] + range[0]));

	 mViewer->GetRenderer()->ResetCamera();
	double bounds[6];


	 mViewer->GetRenderer()->ComputeVisiblePropBounds(bounds);

	 /*
	std::cout <<"bounds : "<<bounds[0]<<","
<<bounds[1]<<","
<<bounds[2]<<","
<<bounds[3]<<","
<<bounds[4]<<","
		  <<bounds[5]<<std::endl;
	 */
	  
	 mViewer->GetRenderer()->ResetCameraClippingRange(bounds);
	/*
	vtkCamera *camera = mViewer->GetRenderer()->GetActiveCamera();
	
	camera->SetViewUp ( spx*0, -spy*1, spz*0);
	camera->SetPosition( spx*(x1+x2)/2, spy*(y1+y2)/2, spz*10000000); 
	camera->SetFocalPoint	( spx*(x1+x2)/2	, spy*(y1+y2)/2	, spz*0); 
	
	camera->ComputeViewPlaneNormal();
	camera->SetParallelScale(  spx*(x2-x1)/2.0 );
	
	camera->Roll ( 180 );
	*/
	  
      }
    
    mInteractor->Render();
    mViewer->Render();	
  } 

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

  void WxViewer::AddImage(vtkImageData* im)
  {
	  images.push_back(im);
  }

  //================================================================
   
  //================================================================
  
  void WxViewer::ShowImages()
  {
	  if(!(mMovie->IsAlive()))
	  {
		mMovie->SetImagesToPlay(images);
		mMovie->StartIterator();
		mMovie->Create();
		mMovie->Run(); 
	  }
	  else
	  {
		  if(!images.empty())
		  {
			mMovie->Pause();
			mMovie->SetImagesToPlay(images);
			mMovie->StartIterator();
			mMovie->Resume();
		  }
		  else
		  {
			GimmickMessage(1,"I'm empty!!!!! "<<std::endl);
		  }
	  }
	  
	  
  }

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

  void WxViewer::ClearImages()
  {
	  images.clear();
  }

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

  bool WxViewer::ImagesEmpty()
  {
	  return images.empty();
  }
  //================================================================
  //  BEGIN_EVENT_TABLE(WxGimmickFrame, wxDialog)
  //    END_EVENT_TABLE()
  //================================================================

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

  void*  ThreadedMovie::Entry()
  {
	  
    GimmickMessage(1,"ThreadedMovie::Entry()"<<std::endl);
			
    while(true)
      { 		
	clock_t endwait;
	for(i=mImagesToPlay.begin();i!=mImagesToPlay.end();++i)
	  {
	    if(i!=mImagesToPlay.end())
	      {   

		GimmickMessage(1,"ThreadedMovie next image"<<std::endl);
		
		ShowImage(*i);
		mParent->Refresh();
		endwait = clock () + 0.2 * CLOCKS_PER_SEC ;
		while (clock() < endwait) {}
	      }
	    
	  }
	
      }
    return 0;
  }

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

  //=====================================================================
  void ThreadedMovie::OnExit()
  {
    GimmickMessage(1,"Hello WORLD IM OUT!!!!!!!! "<<std::endl);
  }

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

  //=====================================================================
  void ThreadedMovie::SetImagesToPlay(std::vector<vtkImageData*> im)
  {
		mImagesToPlay=im;
  }

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

  //=====================================================================
  void ThreadedMovie::StartIterator()
  {
		i=mImagesToPlay.begin();
  }
			
  //=====================================================================

  //=====================================================================
 
  void  ThreadedMovie::ShowImage(vtkImageData* im)
  {
	mViewer->SetInput(im);
	mViewer->SetSlice( 0 );

	int x1,x2,y1,y2,z1,z2;
	double spx,spy,spz;

    im->Update();
    
    im->GetSpacing(spx,spy,spz);
    im->GetExtent (x1,x2,y1,y2,z1,z2);
    /*
    std::cout << "-----------------------------"<<std::endl;
      std::cout << x1 << "-"<<x2<<std::endl; 
      std::cout << y1 << "-"<<y2<<std::endl; 
      std::cout << z1 << "-"<<z2<<std::endl; 
      std::cout << spx << "-"<<spy<<"-"<<spz<<std::endl; 
    */
   
    if ((x1!=mx1) ||
	(x2!=mx2) ||
	(y1!=my1) ||
	(y2!=my2) ||
	(z1!=mz1) ||
	(z2!=mz2) ||
	(spx!=mspx) ||
	(spy!=mspy) ||
	(spz!=mspz) 
	)
      {
	mx1 = x1;
	mx2 = x2;
	my1 = y1;
	my2 = y2;
	mz1 = z1;
	mz2 = z2;
	mspx = spx;
	mspy = spy;
	mspz = spz;
	
	double *range = im->GetScalarRange();
	 mViewer->SetColorWindow(range[1] - range[0]);
	 mViewer->SetColorLevel(0.5 * (range[1] + range[0]));

	 mViewer->GetRenderer()->ResetCamera();
	double bounds[6];


	 mViewer->GetRenderer()->ComputeVisiblePropBounds(bounds);

	 /*
	std::cout <<"bounds : "<<bounds[0]<<","
<<bounds[1]<<","
<<bounds[2]<<","
<<bounds[3]<<","
<<bounds[4]<<","
		  <<bounds[5]<<std::endl;
	 */
	  
	 mViewer->GetRenderer()->ResetCameraClippingRange(bounds);
	/*
	vtkCamera *camera = mViewer->GetRenderer()->GetActiveCamera();
	
	camera->SetViewUp ( spx*0, -spy*1, spz*0);
	camera->SetPosition( spx*(x1+x2)/2, spy*(y1+y2)/2, spz*10000000); 
	camera->SetFocalPoint	( spx*(x1+x2)/2	, spy*(y1+y2)/2	, spz*0); 
	
	camera->ComputeViewPlaneNormal();
	camera->SetParallelScale(  spx*(x2-x1)/2.0 );
	
	camera->Roll ( 180 );
	*/
	  
      }
    
    //mInteractor->Render();
  }

} // EO namespace creaImageIO