#include <vtkViewImage3D.h>
#include <vtkViewImage2D.h>

#include <vtkDataManager.h>
#include <vtkMetaDataSet.h>
#include <vtkMetaDataSetSequence.h>
#include <vtksys/SystemTools.hxx>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>

#include <vtkTimerLog.h>
#include <vtkDirectory.h>
#include <vtkProperty.h>

#include <vtkActor.h>
#include <vtkLookupTableManager.h>

#include <algorithm>
#include <vtkErrorCode.h>


int main (int argc, char*argv[])
{

  if( argc<3 )
  {
    std::cout << "Usage: " << std::endl;
    std::cout << "\t" << argv[0] << " [-dir <Data Directory1 Directory2 ...>] or [-seq <Sequence-Directory1 Sequence-Directory2 ...>]" << std::endl;
    std::cout << "Example: " << std::endl;
    std::cout << "\t" << argv[0] << " -seq  [vtkINRIA3D_DATA_DIR]/Sequences/HeartImages/ [vtkINRIA3D_DATA_DIR]/Sequences/HeartMeshes/" << std::endl;
    exit (-1);
  }

  std::vector<std::string> directorylist;
  std::vector<std::string> sequencedirectorylist;
  
  if ( strcmp(argv[1], "-dir")==0 )
  {
    for( int i=2; i<argc; i++)
    {
      directorylist.push_back (argv[i]);
    }   
  }
  else if (strcmp(argv[1], "-seq")==0)
  {
    for( int i=2; i<argc; i++)
    {
      sequencedirectorylist.push_back (argv[i]);
    }
  }
  else
  {
    std::cout << "Error: Argument list is not recognized." << std::endl;
    exit (-1);
  }
  
  
  /**
     In this example, we illustrate the use of the vtkDataSetManager.
     We first set up a vtkImageView3D to display an image(s)/mesh(es) of the manager.
  */

  vtkViewImage3D* view            = vtkViewImage3D::New();
  vtkRenderWindowInteractor* iren = vtkRenderWindowInteractor::New();
  vtkRenderWindow* rwin           = vtkRenderWindow::New();
  vtkRenderer* renderer           = vtkRenderer::New();

  iren->SetRenderWindow (rwin);
  rwin->AddRenderer (renderer);
  view->SetRenderWindow ( rwin );
  view->SetRenderer ( renderer );
  
  double color[3] = {0.0,0.0,0.0};
  view->SetTextColor (color);
  view->SetRenderingModeToPlanar();
  view->SetCubeVisibility(1);
  view->SetAboutData ("Powered by vtkINRIA3D");


  vtkViewImage2D* view2            = vtkViewImage2D::New();
  vtkRenderWindowInteractor* iren2 = vtkRenderWindowInteractor::New();
  vtkRenderWindow* rwin2           = vtkRenderWindow::New();
  vtkRenderer* renderer2           = vtkRenderer::New();

  iren2->SetRenderWindow (rwin2);
  rwin2->AddRenderer (renderer2);
  view2->SetRenderWindow ( rwin2 );
  view2->SetRenderer ( renderer2 );
  view2->SetAboutData ("Powered by vtkINRIA3D");
  view2->SetBackgroundColor (0.0,0.0,0.0);
  view2->SetOrientation (vtkViewImage2D::AXIAL_ID);
  
  
  vtkDataManager* DataManager = vtkDataManager::New();
  
  if (directorylist.size())
  {
    for( unsigned int i=0; i<directorylist.size(); i++)
    {
      try
      {
        DataManager->ScanDirectory( directorylist[i].c_str() );
      }
      catch (vtkErrorCode::ErrorIds)
      {
        std::cout<<"error caught when scanning"<<std::endl;
      }
    }
  }

  bool do_sequences = false;
  if ( sequencedirectorylist.size() )
  {
    do_sequences = true;
    for( unsigned int i=0; i<sequencedirectorylist.size(); i++)
    {
      try
      {
        DataManager->ScanDirectoryForSequence( sequencedirectorylist[i].c_str(), 2.5);
      }
      catch (vtkErrorCode::ErrorIds)
      {
        std::cout<<"error caught when scanning"<<std::endl;
      }
    }
  }

  


  for (unsigned int i=0; i<DataManager->GetNumberOfMetaDataSet(); i++)
  {
    vtkMetaDataSet* metadataset = DataManager->GetMetaDataSet (i);

    vtkProperty* prop = vtkProperty::SafeDownCast(metadataset->GetProperty());   
    vtkActor* act1 = view->AddDataSet (metadataset->GetDataSet(), prop);
    metadataset->AddActor (act1);
    
    vtkProperty* prop2 = vtkProperty::New();
    prop2->DeepCopy (prop);
    prop2->SetAmbient (1.0);
    prop2->SetDiffuse (0.0);
    prop2->SetSpecular (0.0);
    vtkActor* act2 = view2->AddDataSet (metadataset->GetDataSet(), prop2);
    metadataset->AddActor (act2);
    
    prop2->Delete();

    if (vtkMetaDataSetSequence::SafeDownCast(metadataset))
    {
      vtkDataArray* array = metadataset->GetArray("Sequence_Scalars");
      if (array)
      {
// 	vtkLookupTable* lut = vtkLookupTableManager::GetLookupTable(2);
// 	lut->SetRange (array->GetRange());
// 	array->SetLookupTable(lut);
// 	array
	metadataset->ColorByArray(array);
      }
      
    }
    
  }

  
  view->ResetWindowLevel();
  view->ResetCurrentPoint();
  view2->ResetWindowLevel();
  view2->ResetCurrentPoint();
  view2->ResetZoom();
  
  if (do_sequences)
  {
    
    vtkTimerLog* TimerLog = vtkTimerLog::New();
    
    double mintime = DataManager->GetSequencesRangeMin();
    double maxtime = DataManager->GetSequencesRangeMax();
    int max_number = DataManager->GetSequencesMaxNumber();
    double time = mintime;
    double absolutetime = 0.0;
    
    TimerLog->StartTimer();
    
    while( absolutetime < 10 )
    {

      
      DataManager->UpdateSequencesToTime(time);
      view->Render();
      view2->Render();
      
     
      if (time > maxtime)
	time = mintime;
      

      TimerLog->StopTimer();
      double delay = TimerLog->GetElapsedTime();
      TimerLog->StartTimer();

      time         += delay;
      absolutetime += delay;
    
    }

    TimerLog->StopTimer();

    
    TimerLog->Delete();
  }
  
  
  
  iren->Initialize();
  iren->Start();
  
  DataManager->Delete();

  
  view->Delete();
  iren->Delete();
  rwin->Delete();
  renderer->Delete();

  view2->Delete();
  iren2->Delete();
  rwin2->Delete();
  renderer2->Delete();
  

  return 0;
}