#include <creaImageIODicomDatabase.h>

#include "CppSQLite3.h"

#include <sys/stat.h>

#include <creaImageIODicomDatabaseStructure.h>

//#include <creaImageIOUtilities.h>

//#include <icons/database.xpm>

#include <deque>

#include "wx/wx.h"
#include <wx/dir.h>
#include <wx/filename.h>


//#include <icons/close.xpm>

#include <creaWx.h>
#include <creaMessageManager.h>
using namespace crea;

#include <boost/filesystem.hpp>
#include <boost/algorithm/string/replace.hpp>

namespace creaImageIO
{


  //=============================================================
  DicomDatabase::DicomDatabase(const std::string& location, int flags)
    : DicomNode(DicomNode::Database,0,0),
      mFileName(location),
      mFlags(flags)
  {
    mDicomDatabase = this;
    DicomNodeTypeDescription::FieldDescriptionMapType& M = 
      mDicomNodeTypeDescription[DicomNode::Database].GetFieldDescriptionMap();

    boost::filesystem::path full_path(location);
    mName = full_path.leaf();
    Field::Description fname("Name",0,0,"Name",0);
    M[fname.key] = fname;
    UnsafeSetFieldValue(fname.key,mName);
    Field::Description flocation("File name",0,0,"File name",0);
    M[flocation.key] = flocation;
    UnsafeSetFieldValue(flocation.key,location);

    //    Field::Description ftype("Type",0,0,"Type",0);
    //    M[ftype.key] = ftype;
    //    UnsafeSetFieldValue(ftype.key,"Invalid location");

    mDB = new CppSQLite3DB;
    //    std::cout << "** SQLite Version: " << mDB->SQLiteVersion() << std::endl;


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

  //=============================================================
  DicomDatabase::~DicomDatabase()
  {
    delete mDB;
    /*
      Already done in DicomNode now that DicomDatabase inherits from it
    ChildrenListType::iterator i;
    for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
      {
	delete *i;
      }
    */
  }
  //=============================================================
  

  //=============================================================
  void DicomDatabase::BuildDefaultDicomNodeTypeDescriptions()
  {
    for (int i = DicomNode::Patient;
	 i <= DicomNode::Image; 
	 ++i)
      {
	mDicomNodeTypeDescription[i].BuildDefault(i);
      }
  }
  //=============================================================

  //=============================================================
  void DicomDatabase::Print() const 
  {
    std::cout << "-> '"<<GetName()<< "' - '"
	      << GetFileName()<<"'"<<std::endl;
    ChildrenListType::const_iterator i;
    for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
      {
	(*i)->Print();
      }
  }
  //=============================================================
  
  //=====================================================================
  bool DicomDatabase::LocationIsValid()
  {
    // TO DO 
    return true;
  }
  //=====================================================================

  char* format_sql(const std::string& s)
  { 
    return sqlite3_mprintf("%q",s.c_str());
  }
  //  sqlite3_exec(db, zSQL, 0, 0, 0);
  //  sqlite3_free(zSQL);
  //	char* CHAIN = format_sql(QUER);		\
//  sqlite3_free(CHAIN);				\

  //=====================================================================
#define QUERYDB(QUER,RES)						\
    try									\
      {									\
	RES = mDB->execQuery(QUER.c_str());				\
      }									\
    catch (CppSQLite3Exception& e)					\
      {									\
	std::cout << "SQLite query '"<<QUER<<"' : "<< e.errorCode() << ":" \
		  << e.errorMessage()<<std::endl;			\
	creaError("SQLite query '"<<QUER<<"' : "<< e.errorCode() << ":" \
		   << e.errorMessage() );				\
      }									\
    
  //=====================================================================
  
  //=====================================================================
#define UPDATEDB(UP)							\
  try									\
    {									\
      mDB->execDML(UP.c_str());						\
    }									\
  catch (CppSQLite3Exception& e)					\
    {									\
      std::cout << "SQLite update '"<<UP<<"' Error : "<< e.errorCode() << ":" \
		<< e.errorMessage()<<std::endl;				\
      creaError("SQLite update '"<<UP<<"' Error : "<< e.errorCode() << ":" \
		 << e.errorMessage() );					\
    }									
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::Open()
  {
    //    std::cout << "***> DicomDatabase::Open('"<<GetFileName()<<"')"<<std::endl;
    return OpenDB();
  }

  //=====================================================================
  bool DicomDatabase::New()
  {
    //    std::cout << "***> DicomDatabase::New('"<<GetFileName()<<"')"<<std::endl;
    return CreateDB();
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::OpenDB()
  {
    //    std::cout << "### Opening SQLite database '"<<GetFileName()<<std::endl;
    // OPENING FILE
    if (!boost::filesystem::exists(GetFileName())) 
      {
	return false;
      }

    try
      {
	mDB->open(GetFileName().c_str());
      }
    catch (CppSQLite3Exception& e)
      {
	std::cerr << "Opening '"<<GetFileName()<<"' : "
		  << e.errorCode() << ":" 
		  << e.errorMessage() << std::endl;
	return false;
      }
    // TESTING STRUCTURE VALIDITY
    if (!DBStructureIsValid())
      {
 	std::cerr << "Opening '"<<GetFileName()<<"' : "
		  << " invalid database structure" << std::endl;
	return false;
      }
    // IMPORTING NODE TYPE DESCRIPTIONS
    ImportDicomNodeTypeDescriptionsFromDB();
    return true;
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::CreateDB()
  {
    //    std::cout << "### Creating SQLite database '"<<GetFileName()<<std::endl;

    if (boost::filesystem::exists(GetFileName())) 
      {
	return false;
      }
    // OPENING
    try
      {
	mDB->open(GetFileName().c_str());
      }
    catch (CppSQLite3Exception& e)
      {
	std::cerr << "Creating '"<<GetFileName()<<"' : "
		   << e.errorCode() << ":" 
		  << e.errorMessage() <<std::endl;
	return false;
      }
    
    // CREATING DEFAULT DB STRUCTURE
    BuildDefaultDicomNodeTypeDescriptions();

    // CREATING TABLES
    try
      {
	std::string command;
	// PATIENT
//	command = "create table PATIENT\n(\nID INTEGER PRIMARY KEY AUTOINCREMENT,\n";
// LG : AUTOINCREMENT unknown on sqlite3 for Win32 ??
	command = "create table PATIENT\n(\nID INTEGER PRIMARY KEY,\n";
	AppendSQLFieldsDefinition(DicomNode::Patient,command);
	command += "\n)";
	UPDATEDB(command);

	// STUDY
//	command = "create table STUDY\n(\nID INTEGER PRIMARY KEY AUTOINCREMENT,\nPARENT_ID int not null,\n";	
	command = "create table STUDY\n(\nID INTEGER PRIMARY KEY,\nPARENT_ID int not null,\n";	
	AppendSQLFieldsDefinition(DicomNode::Study,command);
	command +=",\n";
	command +="constraint FK_PARENT foreign key (PARENT_ID) references PATIENT(ID) on delete restrict on update restrict\n)";
	UPDATEDB(command);
	
	// SERIES
//	command = "create table SERIES\n(\nID INTEGER PRIMARY KEY AUTOINCREMENT,\nPARENT_ID int not null,\n";
	command = "create table SERIES\n(\nID INTEGER PRIMARY KEY,\nPARENT_ID int not null,\n";
	AppendSQLFieldsDefinition(DicomNode::Series,command);
	command += ",\n";
	command += "constraint FK_PARENT foreign key (PARENT_ID) references STUDY(ID) on delete restrict on update restrict\n)";
	UPDATEDB(command);
	
	// IMAGE
//	command = "create table IMAGE\n(\nID INTEGER PRIMARY KEY AUTOINCREMENT,\nPARENT_ID int not null,\n";
	command = "create table IMAGE\n(\nID INTEGER PRIMARY KEY,\nPARENT_ID int not null,\n";
	AppendSQLFieldsDefinition(DicomNode::Image,command);
	command += ",\n";
	command += "constraint FK_PARENT foreign key (PARENT_ID) references SERIE (ID) on delete restrict on update restrict\n)";
	UPDATEDB(command);

	//constraint FK_DIRECTORY foreign key (DIRECTORY_ID)		\
	    //      references ROOTDIRECTORY (ID)			\
	    //      on delete restrict on update restrict,		
	
	
	// Create tables *_FIELDS
	for (DicomNode::Type type=DicomNode::Patient; 
	     type<=DicomNode::Image; type++)
	  {
	    command = "create table ";
	    command += DicomDatabaseStructure::Table(type);
	    command += "_FIELDS\n(\n";
	    command += "Key text,\n";
	    command += "DicomGroup int,\n";
	    command += "DicomElement int,\n";	    
	    command += "Name text,\n";	    
	    command += "Flags int\n";	    
	    command += "\n)";
	    UPDATEDB(command);
	  }
	// Fill the tables *_FIELDS
	ExportDicomNodeTypeDescriptionsToDB();

      }
    catch (std::exception)
      {
	return false;
      }
    // LG : TEST
    if (DBStructureIsValid())
      {
	//	std::cout << "*** DONE ***"<<std::endl;
	//	mDBLoaded = true;
	SetChildrenLoaded(true);
	return true;
	
      }
    else 
      {
	//	std::cout << "*** AAAARRRRGGG ***"<<std::endl;
	
	return false;
      }
  }
  //=====================================================================

  //=====================================================================
  void DicomDatabase::AppendSQLFieldsDefinition(DicomNode::Type c,
					     std::string& s)
  {
    std::vector<std::string*> keys;
    DicomNodeTypeDescription::FieldDescriptionMapType::iterator i;
    for (i  = GetDicomNodeTypeDescription(c).GetFieldDescriptionMap().begin();
	 i != GetDicomNodeTypeDescription(c).GetFieldDescriptionMap().end();
	 ++i)
      {
	if (i->second.flags==1) continue;
	keys.push_back(&(i->second.key));
      }
    std::vector<std::string*>::iterator j;
    for (j=keys.begin();j!=keys.end();)
      {
	s += **j + " text";
	++j;
	if (j!=keys.end())
	  s += ",\n";
      }

  }
  //=====================================================================
  
  //=====================================================================
  void DicomDatabase::ExportDicomNodeTypeDescriptionsToDB()
  {
    //    std::cout<<"ExportDicomNodeTypeDescriptionsToDB()"<<std::endl;
    for (DicomNode::Type type=DicomNode::Patient; 
	 type<=DicomNode::Image; 
	 type++)
      {
	DicomNodeTypeDescription::FieldDescriptionMapType::iterator i;
	for (i = GetDicomNodeTypeDescription(type).GetFieldDescriptionMap().begin();
	     i!= GetDicomNodeTypeDescription(type).GetFieldDescriptionMap().end();
	     i++)
	  {
	    
	    std::stringstream insert;
	    insert << "INSERT INTO "
		   << std::string(DicomDatabaseStructure::Table(type))
		   << "_FIELDS (Key,DicomGroup,DicomElement,Name,Flags) "
		   << "VALUES ('"
		   << (*i).second.GetKey() << "',"
		   << (*i).second.GetGroup() << ","
		   << (*i).second.GetElement() << ",'"
		   << (*i).second.GetName() << "',"
		   << (*i).second.GetFlags() << ");";

	    //	    std::cout << "** SQL = '"<<insert.str()<<"'"<<std::endl;
	    
	    UPDATEDB(insert.str());
	  }
      }
  }
  //=====================================================================

  //=====================================================================
  void DicomDatabase::ImportDicomNodeTypeDescriptionsFromDB()
  {
    //    std::cout<<"ImportDicomNodeTypeDescriptionsFromDB()"<<std::endl;
    for (DicomNode::Type type=DicomNode::Patient; 
	 type<=DicomNode::Image; 
	 type++)
      {
	std::string query = "SELECT * FROM ";
	query += DicomDatabaseStructure::Table(type);
	query += "_FIELDS";

	//	std::cout << "** SQL = '"<<query<<"'"<<std::endl;
	
	CppSQLite3Query q;
	QUERYDB(query,q);
	

	while (!q.eof())
	  {
	    Field::Description d(q.getStringField(0), // Key
				 q.getIntField(1), // Group
				 q.getIntField(2), // Element 
				 q.getStringField(3), // Name
				 q.getIntField(4) // Flags
				 );
	    GetDicomNodeTypeDescription(type).GetFieldDescriptionMap()[d.key] = d;
	    //	    std::cout << d << std::endl;
	    q.nextRow();
	  }
      }
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::Close()
  {
    //    std::cout << "***> DicomDatabase::Close"<<std::endl;

    //    std::cout << "<*** DicomDatabase::Close"<<std::endl;
	  return true;
  }
  //=====================================================================
  /*
  //=====================================================================
  bool DicomDatabase::LoadAll()
  {
    DBLoadChildren(0,true);
    mDBLoaded = true;
    return true;
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::LoadUpToSeries()
  {
    //return LoadAll();
    DBLoadChildren(0,false);
    //    mDBLoaded = true;
    return true;
  }
  //=====================================================================
  
  //=====================================================================
  bool DicomDatabase::LoadSeriesImages(DicomNode* series)
  {
    //    return false;
    
    if (!series->GetType()==DicomNode::Series) 
      {
	return false;
	creaError("DicomDatabase::LoadSeriesImages : node is not a series !");
      }
    DBLoadChildren(series,true);
    return true;
  }
  //=====================================================================
*/

  //=====================================================================
  void DicomDatabase::Clear()
  {
  }
  //=====================================================================
  

  //=====================================================================
  int DicomDatabase::DBLoadChildren(DicomNode* parent, 
				     DicomNode::Type maxlevel)
  {

    //    std::cout << "DicomDatabase::DBLoadChildren("<<parent<<","<<maxlevel
    //	      << ")"<<std::endl;
    int nbloaded = 0;
    if (parent == this) { parent = 0; }
    DicomNode* xparent = parent;
    if ( xparent==0 ) xparent = this;
    if ( xparent->ChildrenLoaded() ) 
      {
	//	std::cout << "--> Children already loaded"<<std::endl;
	return nbloaded;
      }
    if ( xparent->GetType() == DicomNode::Image ) 
      {
	return nbloaded;
      }
    if ( xparent->GetType() >= maxlevel ) 
      {
	return nbloaded;
      }
    /*
    if ( parent->ChildrenLoaded().size()>0 ) 
      {	
	DicomNode* n = this;
	if (parent) n = parent;
	// If parent already has loaded its children 
	// simply recurse to its children 
	DicomNode::ChildrenListType::iterator i;
	for (i  = n->GetChildrenList().begin();
	     i != n->GetChildrenList().end();
	     i++)
	  {
	    DBLoadChildren(*i,load_images);
	  }
	return;
      }
    */
    msw[2].Pause();
    msw[2].Resume();
    DicomNode::Type type = xparent->GetType()+1;

    // Query DB

    std::string query = "SELECT * FROM ";
    query += DicomDatabaseStructure::Table(type);
    if (parent!=0)
      {
	query += " WHERE PARENT_ID='" + parent->GetFieldValue("ID") + "'";
      }

    //    std::cout << "** SQL = '"<<query<<"'"<<std::endl;

    CppSQLite3Query q;
    QUERYDB(query,q);

    while (!q.eof())
      {
	nbloaded++;
	DicomNode* n = new DicomNode(type,
			   this,xparent);
	for (int fld = 0; fld < q.numFields(); fld++)
	  {
	    n->SetFieldValue(q.fieldName(fld),q.getStringField(fld));	    
	  }
	// Index 
	TypeId ti;
	ti.type = type;
	ti.id = n->GetFieldValue("ID");    
	mTypeIdToDicomNodeMap[ti] = n;
	// recurse 
	if ( type < maxlevel ) 
	  {
	    msw[2].Pause();
	    nbloaded += DBLoadChildren(n,maxlevel);
	    msw[2].Resume();
	  }
	// next entry in db
	q.nextRow();
      }

    xparent->SetChildrenLoaded(true);
    
    msw[2].Pause();
    return nbloaded;
  }
  //=====================================================================



  //=====================================================================
  bool DicomDatabase::DBStructureIsValid()
  {
    bool success = true;
    for (int i = DicomDatabaseStructure::TableBegin();
	 i    != DicomDatabaseStructure::TableEnd();++i)
      {
	bool ok = mDB->tableExists(DicomDatabaseStructure::Table(i));
	if (ok) 
	  {
	    //	    std::cout << "** Table "<<DicomDatabaseStructure::Table(i)
	    //		      <<" exists"<<std::endl;
	    // TO DO : TEST MANDATORY FIELDS EXIST
	  }
	else 
	  {
	    //	    std::cout << "** Table "<<DicomDatabaseStructure::Table(i)
	    //		      <<" does *NOT* exist"<<std::endl;
	    success = false;
	  }
      }
    return success;
  }  
  //=====================================================================



  //=====================================================================
  bool DicomDatabase::DBInsert(DicomNode* alien_node,
			       UpdateSummary& summary)
  {
    //    std::cout << "DicomDatabase::Insert('"<<alien_node->GetLabel()
    //	      <<"')"<<std::endl;
    
    //    if (!ChildrenLoaded()) DBLoadChildren(this,DicomNode::Database);
    
    // Find parent
    DicomNode* parent;
    std::string parent_id;
    parent = DBGetOrCreateParent(alien_node,parent_id,summary);
    
    // Insert 
    DBRecursiveGetOrCreateDicomNode(alien_node,parent,parent_id,summary);
   return true;
  }
  //=====================================================================


  //=====================================================================
  DicomNode* DicomDatabase::DBGetOrCreateParent(DicomNode* alien_node,
						std::string& parent_id,
						UpdateSummary& summary)
  {
    //    std::cout << "DBGetOrCreateParent '" << alien_node->GetLabel()<<"'"
    //	      << std::endl;
    // Load the patients if not already done
    DBLoadChildren(this,DicomNode::Patient);

    parent_id = "";
    DicomNode* parent = this;

    // The chain of ancestors
    std::deque<DicomNode*> chain;
    DicomNode* cur = alien_node->GetParent();
    for (int type=DicomNode::Patient; 
	 type<alien_node->GetType();++type)
      {
	chain.push_front(cur);
	cur = cur->GetParent();
      }

    // create the nodes if do not exist
    std::deque<DicomNode*>::iterator i;
    for (i=chain.begin();i!=chain.end();++i)
      {
	//	std::cout << " cur = '"<<(*i)->GetLabel()<<"'"<<std::endl;
	//	std::string cur_id = DBGetDicomNodeId(*i,parent_id);
	//	if (cur_id.size()==0)
	//	  {
	// Node does not exist : create it
	std::string cur_id;
	parent = DBGetOrCreateDicomNode(*i, 
					parent,
					parent_id,
					cur_id,
					summary
					);
	DBLoadChildren(parent,parent->GetType()+1);
	/*	  }
	  else
	  {
	    // Node exists : get it and load its children
	    parent = GetDicomNodeFromTypeId((*i)->GetType(),cur_id);
	    DBLoadChildren(parent,parent->GetType()+1);
	  }
	*/
	parent_id = cur_id;
      }
    return parent;
  }
  //=====================================================================



  //=====================================================================
  void DicomDatabase::DBRecursiveGetOrCreateDicomNode(DicomNode* alien_node, 
						      DicomNode* parent, 
						      const std::string& parent_id,
						      UpdateSummary& summary)
  {
    //    std::cout << "DicomDatabase::RecursiveGetOrCreateDicomNode('"
    //	      <<alien_node->GetLabel()
    //	      <<"','"<<parent<<"','"<<parent_id<<"')"<<std::endl;
    if (parent != 0) 
      {
	//	std::cout << " -- Parent = '"<<parent->GetLabel()<<"'"<<std::endl;
      }   
    std::string new_id;
    DicomNode* new_node = DBGetOrCreateDicomNode(alien_node, 
						 parent,
						 parent_id,
						 new_id,
						 summary);
    DicomNode::ChildrenListType::iterator i;
    for (i  = alien_node->GetChildrenList().begin();
	 i != alien_node->GetChildrenList().end();
	 i++)
      {
	DBRecursiveGetOrCreateDicomNode((*i),new_node,new_id,summary);
      }
  }
  //=====================================================================


  //=====================================================================
  DicomNode* DicomDatabase::DBGetOrCreateDicomNode(DicomNode* alien_node, 
						   DicomNode* internal_parent,
						   std::string parent_id,
						   std::string& node_id,
						   UpdateSummary& summary)
  {
    //   std::cout << "DBGetOrCreateDicomNode('"<<alien_node->GetLabel()<<"','"
    //	      << internal_parent << "','"<< parent_id<<"')"<<std::endl;
    if (internal_parent != 0) 
      {
	//	std::cout << " -- Parent = '"<<internal_parent->GetLabel()<<"'"<<std::endl;
      }
    // DicomNode Exists ? return it 
    // First try among children of internal parent 
    DicomNode* node = GetChildrenLike(internal_parent,alien_node);
    if (node>0)
      {
	node_id = node->UnsafeGetFieldValue("ID");
	return node;
      }
    // Second : try in DB 
    /*
    node_id = DBGetDicomNodeId(alien_node,parent_id);
    if (node_id.size()>0)
      {
	msw[4].Pause();
	return GetDicomNodeFromTypeId(alien_node->GetType(),node_id);
      }
    */
    // Does not exist : Create new one
    node = new DicomNode(alien_node->GetType(),this,internal_parent);
    node->SetChildrenLoaded(true);
    // Copy fields values from alien
    DicomNode::FieldValueMapType::iterator i,j;
    for (i =  node->GetFieldValueMap().begin();
	 i != node->GetFieldValueMap().end();
	 i++)
      {
	j = alien_node->GetFieldValueMap().find(i->first);
	if (j != alien_node->GetFieldValueMap().end() )
	  {
	    i->second = j->second;
	  }
      }

    msw[2].Resume();
    if (node->GetType()!=DicomNode::Patient) 
      node->SetFieldValue("PARENT_ID",parent_id);

    // Insert in DB
    std::string val;
    BuildSQLFieldsValues(node,val);
    std::string insert("INSERT INTO ");
    insert += std::string(DicomDatabaseStructure::Table(node->GetType())) 
      + " " + val + ";";
    //    std::cout << "** SQL = '"<<insert<<"'"<<std::endl;
    UPDATEDB(insert);
    //    std::cout << "** SQL OK"<<std::endl;

    // Store DB id of newly created node;
    long lastrow = mDB->lastRowId();
    std::stringstream ri;
    ri << mDB->lastRowId();
    node_id = ri.str();
    //    std::cout << "LastRowId='"<<mDB->lastRowId()<<"' vs '"<<created_id<<"'"<<std::endl;

    node->SetFieldValue("ID",node_id);
    // Insert in TypeId map
    TypeId ti;
    ti.type = node->GetType();
    ti.id = node_id;
    mTypeIdToDicomNodeMap[ti] = node;
    //    std::cout << "== Insert TypeId ("<<ti.type<<","<<ti.id<<")"<<std::endl; 
    // 
    msw[2].Pause();

    if (node->GetType()==DicomNode::Patient) summary.added_patients++;
    if (node->GetType()==DicomNode::Study) summary.added_studies++;
    if (node->GetType()==DicomNode::Series) summary.added_series++;
    if (node->GetType()==DicomNode::Image) summary.added_images++;

    return node;
  }
  //=====================================================================

  //=====================================================================
  DicomNode* DicomDatabase::GetChildrenLike(DicomNode* parent,
					    DicomNode* alien_node)
  {
    DicomNode::ChildrenListType::iterator i;
    for (i  = parent->GetChildrenList().begin();
	 i != parent->GetChildrenList().end();
	 i++)
      {
	DicomNode::Type type = alien_node->GetType();
	bool ok = true;
	for (int j=0;
	     j<DicomDatabaseStructure::NbQueryFields(type);
	     j++) 
	  {
	    if ( 
		alien_node->GetFieldValue(DicomDatabaseStructure::
				    QueryField(type,j).key )   !=
		(*i)->GetFieldValue(DicomDatabaseStructure::
				    QueryField(type,j).key ) )
	      {
		ok = false;
		break;
	      }
	  }
	if (ok) 
	  {
	    return (*i);
	  }
      }
    return 0;    
  }
  //=====================================================================

  //=====================================================================
  std::string DicomDatabase::DBGetDicomNodeId(DicomNode* node, 
					      const std::string& parent_id)
  {
    //    std::cout << "DicomDatabase::DBGetDicomNodeId('"<<node->GetLabel()
    //	      <<"','"<<parent_id<<"')"
    //	      <<std::endl;
    msw[2].Resume();
    int type = node->GetType();

    std::string table = DicomDatabaseStructure::Table(type);
    std::string where = "WHERE ";
    
    if (type!=DicomNode::Patient)
      {
	where += "PARENT_ID='" + parent_id 
	  //node->GetFieldValue("PARENT_ID") 
	  + "' AND ";
      }

    for (int i=0;i<DicomDatabaseStructure::NbQueryFields(type);i++) 
      {
	where += DicomDatabaseStructure::QueryField(type,i).key + "='"
	  + node->GetFieldValue(DicomDatabaseStructure::QueryField(type,i).key) + "' ";
	if (i<DicomDatabaseStructure::NbQueryFields(type)-1)
	  where += "AND ";
    }

    std::string query = "SELECT ID FROM " + table + " " + where + ";";							  
    //    std::cout << "** SQL = '"<<query<<"'"<<std::endl;
    CppSQLite3Query q;
    QUERYDB(query,q);

    if (!q.eof())
      {
	
	//	std::cout << " - DicomNode exists " << std::endl;
	std::string id = q.getStringField(0);
	//	std::cout << " id = '"<<id<<"'"<<std::endl;
	msw[2].Pause();
	return id;
      }
    msw[2].Pause();
    return "";
  }
  //=====================================================================



  //=====================================================================
  DicomNode* DicomDatabase::GetDicomNodeFromTypeId(DicomNode::Type type,
				       const std::string& id)
  {
    //    std::cout << "GetDicomNodeFromTypeId("<<type<<","<<id<<")"<<std::endl;

    TypeId ti;
    ti.type = type;
    ti.id = id;
    
    TypeIdToDicomNodeMapType::iterator i = mTypeIdToDicomNodeMap.find(ti);
    if (i == mTypeIdToDicomNodeMap.end())
      {
	/*
	LoadAll();
	i = mTypeIdToDicomNodeMap.find(ti);
	if (i == mTypeIdToDicomNodeMap.end())
	  {
	*/
	    std::cout << "Internal error : mTypeIdToDicomNodeMap does not contain key"
		      << std::endl;
	    creaError("Internal error : mTypeIdToDicomNodeMap does not contain key");
	    // }
      }

    //    std::cout << " ** DicomNode = "<<i->second<<std::endl;
    return i->second;
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::Remove(DicomNode* node)
  {
    DBRecursiveRemoveDicomNode(node);
    /*
    if (node->GetType()==DicomNode::Patient)
      {
	//	std::cout << "IS PATIENT"<<std::endl;
	ChildrenListType::iterator i = find(GetChildrenList().begin(),
					   GetChildrenList().end(),
					   node);
	//	std::cout << "ERASE"<<std::endl;
	GetChildrenList().erase(i);
	//	std::cout << "ERASE OK"<<std::endl;
      }
    */
    //    std::cout << "DELETE"<<std::endl;
    if (node->GetParent())
      {
	node->GetParent()->RemoveChildrenFromList(node);
      }
    delete node;
    //    std::cout << "DELETE OK"<<std::endl;
    return true;
  }
  //========================================================================

  //=====================================================================
  void DicomDatabase::DBRecursiveRemoveDicomNode(DicomNode* node)
  {
    //    std::cout << "DicomDatabase::DBRecursiveRemoveDicomNode('"
    //	      <<node->GetLabel()<<"')"<<std::endl;

    std::string query = "DELETE FROM ";
    query += DicomDatabaseStructure::Table(node->GetType());
    query += " WHERE ID='"+ node->GetFieldValue("ID") + "';";
 
    UPDATEDB(query);

    DicomNode::ChildrenListType::iterator i;
    for (i  = node->GetChildrenList().begin();
	 i != node->GetChildrenList().end();
	 i++)
      {
	DBRecursiveRemoveDicomNode((*i));
      }
  }
  //=====================================================================
  
  //=====================================================================
  int DicomDatabase::DBQueryNumberOfChildren(DicomNode* node)
  {
    std::string query = "SELECT COUNT (ID) FROM ";
    query += DicomDatabaseStructure::Table(node->GetType()+1);
    if (node->GetType() != DicomNode::Database) 
      {
	query += " WHERE PARENT_ID='"+ node->GetFieldValue("ID")+"'";
      }
    query  += ";";
    
    //   std::cout << "**SQL = "<< query << std::endl;
    
    CppSQLite3Query q;
    QUERYDB(query,q);
   
     //    std::cout << "**RES = "<< q.getIntField(0) <<std::endl;

    return q.getIntField(0);
  }
  //=====================================================================
 
  //========================================================================
  std::string& format_sql2(std::string& str)
  {
    // quote must be doubled
    //    crea::Utils::Replace( str, "'", "''" );
    boost::algorithm::replace_all(str,"'","''");
    // Found strange strings which contained NULL char INSIDE string 
    int i,size=str.size();
    for (i=0;i<size;++i) 
      {
	if (str[i]==0) 
	  {
	    str = str.substr(0,i);
	    break;
	  }
      }
    //    if (i<str.size())
    return str;
  }
   //========================================================================

  //=====================================================================
  void DicomDatabase::BuildSQLFieldsValues(DicomNode* n,
					std::string& str)
  {
    //    std::cout << "BuildSQLFieldsValues('"<<n->GetLabel()<<"')"<<std::endl;

    std::string atts="";
    std::string values="";
    DicomNode::FieldValueMapType::iterator i;
    for (i =  n->GetFieldValueMap().begin();
	 i != n->GetFieldValueMap().end();
	 i++)
      {
	if (i->first=="ID") 
	  {
	    continue;
	  }
	//	std::cout << "("<<i->first<<","<<i->second<<")"<<std::endl;
	atts += "'" + i->first + "'";
	values += "'" + format_sql2(i->second) + "'"; 
	atts += ",";
	values += ",";
      }
    atts[atts.size()-1]=' ';
    values[values.size()-1]=' ';

    str = "("+atts+") VALUES ("+values+")";

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

  //=====================================================================
  bool DicomDatabase::IsHandledFile( const std::string& filename)
  {
    return (mReader.CanRead(filename,""));
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::AddFiles( const std::vector<std::string>& filenames,
				wxProgressDialog* progress, 
				UpdateSummary& summary)
  {
     for (int swi=0;swi<10;swi++) 
      {
	msw[swi].Start(0);
	msw[swi].Pause();
      }
    
    // Parse directory
    wxStopWatch sw; 


     summary.added_images = 0;
     unsigned int nbf = filenames.size(); 
     std::vector<std::string>::const_iterator i;
     for (i=filenames.begin();i!=filenames.end();++i)
       {
	 summary.scanned_files++;
	 if (IsHandledFile(*i)) 
	   {
	     summary.handled_images++;
	     AddFile(*i,summary);
	     
	     if (progress)
	       {
		 std::string mess("Adding ");
		 mess += *i;
		 if (!progress->Update( (int)(summary.added_images*999./nbf),
					std2wx(mess)))
		   {
		     // Some file was added hence we must return true !
		     summary.cancelled_by_user = true;
		     break;
		   }
	       }
	   }
       }


     sw.Pause();
     msw[0].Pause();
     msw[1].Pause();
     msw[2].Pause();

     summary.total_time = sw.Time();
     summary.file_scan_time = msw[1].Time();
     summary.update_database_time = msw[2].Time();
     summary.update_structs_time = 
       summary.total_time - 
       summary.parse_time - 
       summary.file_scan_time - 
       summary.update_database_time;
     
     return true;
  }
  //=====================================================================

  //=====================================================================
  bool DicomDatabase::AddFile( const std::string& filename,
			       UpdateSummary& summary)
   {
     // std::cout << "** DicomDatabase::AddFile '"<<filename<<"'"<<std::endl;
     // Create *unknown* patient / study / series 
     DicomNode* patient = new DicomNode(DicomNode::Patient,this,0);
     //	 FillFields/*<GDCM_NAME_SPACE::DicomDir>*/(patient,0);
     //	 patient->SetData(new DirDicomNodeData());
     // Insert 
     //GetChildrenList().push_back(patient);
     DicomNode* study = new DicomNode(DicomNode::Study,this,patient);
     //FillFields/*<GDCM_NAME_SPACE::DicomDir>*/(study,0);
     //study->SetData(new DirDicomNodeData());
     DicomNode* series = new DicomNode(DicomNode::Series,this,study);
     //FillFields/*<GDCM_NAME_SPACE::DicomDir>*/(series,0);
     //series->SetData(new DirDicomNodeData());
     DicomNode* image = new DicomNode(DicomNode::Image,this,series);
     
     msw[1].Resume();
     mReader.ReadDicomInfo(filename,image);
     msw[1].Pause();

     image->SetFieldValue("FullFileName",filename);
     
     DBInsert(patient,summary);
     
     delete patient;
     
     //image->SetData(new DirDicomNodeData());
     // Fill Fields
     //FillFields/*<GDCM_NAME_SPACE::DicomDir>*/(image,0);
     //std::string f(Utilities::GetFileName(*i));
     //image->SetFieldValue("A0004_1500",cclean(f));
     //image->SetFieldValue("FullFileName",cclean(*i));   
     return true;
   }
  //=====================================================================

  //=====================================================================
  /**
   * \brief   Explore a directory with possibility of recursion
   *          return number of files read
   * @param  dirpath   directory to explore
   * @param  recursive whether we want recursion or not
   */
  void DicomDatabase::ParseDirectory( const std::string &dirpath, 
				      std::vector<std::string> &Filenames,
				      bool recursive,
				      wxProgressDialog* progress, 
				      UpdateSummary& summary)
    
  {
    if (progress) 
      {
		std::string mess("Parsing ");
		mess += dirpath;
		progress->Pulse(std2wx(mess));
      }

	wxStopWatch sw; 
	sw.Start(0);
    
    std::string fileName;
    std::string dirName = dirpath;

    summary.scanned_dirs++;

    wxDir dir( std2wx(dirpath) );

    if ( !dir.IsOpened() )
    {
        // deal with the error here - wxDir would already log an error message
        // explaining the exact reason of the failure
        return;
    }

    wxString filename;

    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES | wxDIR_HIDDEN );
    while ( cont )
    {
		if ((progress)&&( sw.Time() >= 250 )) 
		{
//			std::cout << "PULSE"<<std::endl;
			sw.Start(0);
			if (!progress->Pulse()) 
			{
				summary.cancelled_by_user = true;
				break;
			}
		}

		summary.scanned_files++;
		wxFileName wxffn(dir.GetName(),filename);
		std::string ffn = wx2std(wxffn.GetFullPath());
//		std::cout << ffn << std::endl;
		if (mReader.CanRead(ffn,""))
			{
				Filenames.push_back( ffn );
				summary.handled_images++;
			}
        cont = dir.GetNext(&filename);
    }

	// Recurse into subdirs
	if ( recursive )
		{
			cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN );
			while ( cont )
			{

				wxFileName wxffn(dir.GetName(),filename);
				std::string ffn = wx2std(wxffn.GetFullPath());
		
//				std::cout << "dir="<< ffn<< std::endl;

				ParseDirectory( ffn, 
								Filenames,
								recursive,
								progress,
								summary);
				if (summary.cancelled_by_user) break;

				cont = dir.GetNext(&filename);
			}
		}
    
  }
  //=======================================================================


  //=====================================================================
  bool DicomDatabase::AddDirectory( const std::string& directory,
				    bool recurse,
				    wxProgressDialog* progress, 
				    UpdateSummary& summary
				    )
  {
    //    std::cout << "** DicomDatabase::AddDirectory"
    //	      << " '"<<directory<<"'"<<std::endl;
    //    std::cout << "------ Parsing directory ------"<<std::endl;
    
    if (progress)
      {
	progress->Pulse();
      }

    for (int swi=0;swi<10;swi++) 
      {
	msw[swi].Start(0);
	msw[swi].Pause();
      }
    
    // Parse directory
    wxStopWatch sw; 
    
    bool was_canceled_by_user(false);
    std::vector<std::string> filenames;
    ParseDirectory( directory, 
		    filenames,
		    recurse, 
		    progress,
		    summary);
    
    if ( summary.cancelled_by_user ) 
      {
	return false;
      }
    
    summary.parse_time = sw.Time();


     summary.added_images = 0;
     unsigned int nbf = filenames.size(); // , nf = 0;
     std::vector<std::string>::iterator i;
     for (i=filenames.begin();i!=filenames.end();++i)
       {
	 AddFile(*i,summary);

	 if (progress)
	   {
	     std::string mess("Adding ");
	     mess += *i;
	     if (!progress->Update( (int)(summary.added_images*999./nbf),
				    std2wx(mess)))
	       {
		 // Some file was added hence we must return true !
		 summary.cancelled_by_user = true;
		 break;
	       }
	   }
       }


     sw.Pause();
     msw[0].Pause();
     msw[1].Pause();
     msw[2].Pause();

     summary.total_time = sw.Time();
     summary.file_scan_time = msw[1].Time();
     summary.update_database_time = msw[2].Time();
     summary.update_structs_time = 
       summary.total_time - 
       summary.parse_time - 
       summary.file_scan_time - 
       summary.update_database_time;
     
     return true;
  }
  //=====================================================================







} // namespace creaImageIO