#include <vtkDataManager.h>
#include "vtkObjectFactory.h"


#include <vtkMetaImageData.h>
#include <vtkMetaSurfaceMesh.h>
#include <vtkMetaVolumeMesh.h>
#include <vtkMetaDataSetSequence.h>

#include <vtkImageData.h>
#include <vtkPolyData.h>
#include <vtkUnstructuredGrid.h>
#include <vtkProperty.h>
#include <vtksys/SystemTools.hxx>
#include <vtkErrorCode.h>
#include <vtkDirectory.h>

#include <algorithm>

#include <sstream>
#include <time.h>

//----------------------------------------------------------------------------
vtkStandardNewMacro( vtkDataManager );
vtkCxxRevisionMacro( vtkDataManager, "$Revision: 1.4 $");


//----------------------------------------------------------------------------
vtkDataManager::vtkDataManager()
{
}

//----------------------------------------------------------------------------
vtkDataManager::~vtkDataManager()
{
  std::cout<<"deleting vtkDataManager"<<std::endl;
  
  // should delete all metadatasets...
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
    this->MetaDataSetList[i]->Delete();
  this->MetaDataSetList.clear();
  
}

//----------------------------------------------------------------------------
vtkMetaDataSet* vtkDataManager::GetMetaDataSet (unsigned int id) const
{
  if (id<0 || id >= this->MetaDataSetList.size())
    return NULL;
  return this->MetaDataSetList[id];
}

//----------------------------------------------------------------------------
vtkMetaDataSet* vtkDataManager::GetMetaDataSet (const char* name) const
{
  unsigned int id = 0;
  
  if (!this->IsNameInManager(name, id))
    return NULL;
  
  return this->MetaDataSetList[id];
}

//----------------------------------------------------------------------------
void vtkDataManager::AddMetaDataSet (vtkMetaDataSet* metadataset)
{
  if (!metadataset)
    return;

  srand (clock());
  
  // put a random color
  int i1 = 1 + (int) (100.0 * ((double)rand() / (RAND_MAX + 1.0)));
  int i2 = 1 + (int) (100.0 * ((double)rand() / (RAND_MAX + 1.0)));
  int i3 = 1 + (int) (100.0 * ((double)rand() / (RAND_MAX + 1.0)));
  double rand_1 = (double)(i1)/(100.0);
  double rand_2 = (double)(i2)/(100.0);
  double rand_3 = (double)(i3)/(100.0);
  double r = rand_1, g = rand_2, b = rand_3;
  if (i1 < 33)
    r = 1;
  else if (i1 < 66)
    g = 1;
  else if (i1 < 100)
    b = 1;
  
  
  vtkProperty* prop = vtkProperty::SafeDownCast(metadataset->GetProperty());
  
  if (prop)
    prop->SetColor (r,g,b);

  this->MetaDataSetList.push_back (metadataset);
  metadataset->Register(this);
  
}


void vtkDataManager::UpdateSequencesToTime (double time)
{
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
  {
    vtkMetaDataSetSequence* sequence = NULL;
    sequence = vtkMetaDataSetSequence::SafeDownCast(this->MetaDataSetList[i]);
    if (sequence)
    {
      sequence->UpdateToTime (time);
    }
  }

  
}


double vtkDataManager::GetSequencesRangeMin()
{
  double min = 9999999;
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
  {
    vtkMetaDataSetSequence* sequence = NULL;
    sequence = vtkMetaDataSetSequence::SafeDownCast(this->MetaDataSetList[i]);
    if (sequence)
    {
      double temp = sequence->GetMinTime();
      if (temp < min)
	min = temp;
    }
  }
  return min;
  
}

double vtkDataManager::GetSequencesRangeMax()
{
  double max = -9999999;
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
  {
    vtkMetaDataSetSequence* sequence = NULL;
    sequence = vtkMetaDataSetSequence::SafeDownCast(this->MetaDataSetList[i]);
    if (sequence)
    {
      double temp = sequence->GetMaxTime();
      if (temp > max)
	max = temp;
    }
  }
  return max;
}

unsigned int vtkDataManager::GetSequencesMaxNumber()
{
  unsigned int max = 0;
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
  {
    vtkMetaDataSetSequence* sequence = NULL;
    sequence = vtkMetaDataSetSequence::SafeDownCast(this->MetaDataSetList[i]);
    if (sequence)
    {
      unsigned int temp = sequence->GetNumberOfMetaDataSets();
      if (temp > max)
	max = temp;
    }
  }
  return max;
}

//----------------------------------------------------------------------------
unsigned int vtkDataManager::GetNumberOfMetaDataSet (void) const
{
  return this->MetaDataSetList.size();
}

//----------------------------------------------------------------------------
unsigned int vtkDataManager::GetNumberOfTypedMetaDataSet (unsigned int type) const
{
  unsigned int ret = 0;
  for (unsigned int i = 0; i < this->MetaDataSetList.size(); i++)
  {
    if (this->MetaDataSetList[i]->GetType() == type)
      ret++;
  }
  return ret;
}


//----------------------------------------------------------------------------
std::vector<vtkMetaDataSet*> vtkDataManager::GetTypedMetaDataSetList (unsigned int type) const  
{
  std::vector<vtkMetaDataSet*> list;
  for (unsigned int i = 0; i < this->MetaDataSetList.size(); i++)
  {
    if (this->MetaDataSetList[i]->GetType() == type)
      list.push_back (this->MetaDataSetList[i]);
  }
  return list;
}


//----------------------------------------------------------------------------
bool vtkDataManager::IsInManager (vtkMetaDataSet* metadataset, unsigned int &id) const
{
  if (!metadataset)   
    return false;
  for (unsigned int i = 0; i < this->MetaDataSetList.size(); i++)
  {
    if (this->MetaDataSetList[i] == metadataset)
    {
      id = i;
      return true;
    }
  }
  return false;  
}
//----------------------------------------------------------------------------
bool vtkDataManager::IsNameInManager (const char* name, unsigned int &id) const
{
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
  {  
    if (strcmp (name, this->MetaDataSetList[i]->GetName()) == 0)
    {
      id = i;
      return true;
    }
  }
  return false;
}

  
//----------------------------------------------------------------------------
const char* vtkDataManager::CreateDefaultName (unsigned int type, const char* filename)
{
  
  char* ret = new char[512];
  bool isused = true;
  int id = 0;  
  
  
  if (filename)
  {
    
    std::string filename_str = vtksys::SystemTools::GetFilenameName (filename);
    sprintf (ret, "%s", (char*)filename_str.c_str());
    unsigned int id = 0;
    
    if (!this->IsNameInManager (ret, id))
      return ret;
  }
  
  
  while (isused == true)
  {
    switch (type)
    {
	case vtkMetaDataSet::VTK_META_IMAGE_DATA :  
	  sprintf (ret, "image-%i", id);
	  break;
	case vtkMetaDataSet::VTK_META_SURFACE_MESH :  
	  sprintf (ret, "mesh-%i", id);
	  break;
	case vtkMetaDataSet::VTK_META_VOLUME_MESH :  
	  sprintf (ret, "tetra-%i", id);
	  break;
	default :
	  sprintf (ret, "unknown-%i", id);
	  break;
    }
    unsigned int dummy = 0;
    isused = this->IsNameInManager (ret, dummy);    
    id++;
  }
  return ret;
}

//----------------------------------------------------------------------------
void vtkDataManager::RemoveMetaDataSet (vtkMetaDataSet* metadataset)
{
  if (!metadataset)
    return;
  
  std::vector<vtkMetaDataSet*> templist = this->MetaDataSetList;
  this->MetaDataSetList.clear();
  
  for (unsigned int i=0; i<templist.size(); i++)
  {
    if (templist[i] != metadataset)
      this->MetaDataSetList.push_back (templist[i]);
    else
      templist[i]->Delete();
  }
  
}

//----------------------------------------------------------------------------
vtkMetaDataSet* vtkDataManager::ReadFile (const char* filename, const char* name)
{

  vtkMetaDataSet* metadataset;
  vtkDataSet* junk;
  unsigned int type = 0;
  
  if (vtkMetaSurfaceMesh::CanReadFile (filename))
  {
    type = vtkMetaDataSet::VTK_META_SURFACE_MESH;
    metadataset = vtkMetaSurfaceMesh::New();
    junk = vtkPolyData::New();
  }
  else if (vtkMetaVolumeMesh::CanReadFile (filename))
  {
    type = vtkMetaDataSet::VTK_META_VOLUME_MESH;
    metadataset = vtkMetaVolumeMesh::New();    
    junk = vtkUnstructuredGrid::New();    
  }
  else if (vtkMetaImageData::CanReadFile (filename))
  {
    type = vtkMetaDataSet::VTK_META_IMAGE_DATA;
    metadataset = vtkMetaImageData::New();
    junk = vtkImageData::New();
  }
  else
  {
    vtkErrorMacro(<<"unknown file format : "<<filename<<endl);
    throw vtkErrorCode::UnrecognizedFileTypeError;
  }
  

  try
  {
    metadataset->Read(filename);
    junk->DeepCopy (metadataset->GetDataSet());
    metadataset->SetDataSet(junk);
    junk->Delete();
    
    unsigned int dummy = 0;
    
    if (name == NULL || IsNameInManager (name, dummy))
    {
      const char* defaultname = this->CreateDefaultName(type, filename);
      metadataset->SetName (defaultname);
      delete [] defaultname;
    }
    else
      metadataset->SetName (name);

    this->AddMetaDataSet(metadataset);
    metadataset->Delete();
    
    return metadataset;
  }
  catch (vtkErrorCode::ErrorIds error)
  {
    metadataset->Delete();
    throw error;
  }


  return NULL;
  
}


//----------------------------------------------------------------------------
void vtkDataManager::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os,indent);
  os << indent <<" has " <<this->MetaDataSetList.size()<<" MetaDataSets ... " << endl;
  for (unsigned int i=0; i<this->MetaDataSetList.size(); i++)
    this->MetaDataSetList[i]->PrintSelf (os, indent);
}

//----------------------------------------------------------------------------
void vtkDataManager::ScanDirectory (const char* dirname)
{

  vtkDirectory* directory = vtkDirectory::New();
  int ret = directory->Open(dirname);
  if (!ret)
  {
    vtkErrorMacro(<<"Cannot open directory"<<dirname<<endl);
    throw vtkErrorCode::CannotOpenFileError;
  }
  
  std::string directoryname = dirname;
  std::string::size_type slashpos;
  
    // check slash position
#ifdef WIN32
  slashpos = directoryname.rfind ("\\"); // last occurence of "/"
  if (slashpos != directoryname.size()-1)
    directoryname+="\\";
#else
  slashpos = directoryname.rfind ("/"); // last occurence of "/"
  if (slashpos != directoryname.size()-1)
    directoryname+="/";
#endif
  
  std::vector<std::string> list;
  
  for (int i=0; i<directory->GetNumberOfFiles(); i++)
  {
    if ( (strcmp(directory->GetFile (i), ".") == 0 )
	 || (strcmp(directory->GetFile (i), "..") == 0 ))
      continue;
    
    list.push_back((directoryname+directory->GetFile (i)));
  }

  std::sort(list.begin(), list.end());

  for (unsigned int i = 0; i < list.size(); i++)
  {
    try
    {
      this->ReadFile(list[i].c_str());
    }
    catch (vtkErrorCode::ErrorIds)
    {
      // we don't throw exception as we want to continue scanning the directory
      std::cerr<<"skipping file "<<list[i].c_str()<<std::endl;
    }
  }
  directory->Delete();
}

//----------------------------------------------------------------------------
vtkMetaDataSetSequence* vtkDataManager::ScanDirectoryForSequence (const char* dirname, double duration)
{
 
  vtkMetaDataSetSequence* Sequence = vtkMetaDataSetSequence::New();
  try
  {
    
    Sequence->SetSequenceDuration (duration);
    Sequence->Read(dirname);
    
    this->AddMetaDataSet (Sequence);
    Sequence->Delete();
    
  }
  catch (vtkErrorCode::ErrorIds error)
  {
    Sequence->Delete();
    throw error;
  }    
  
  return Sequence;

}