#include <creaImageIOGimmick.h>

#include <creaImageIOSystem.h>

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

namespace creaImageIO
{


  //==============================================================
  Gimmick::Gimmick()
    : mImageAdder(0)
  {    
    RegisterGimmickMessageTypes();
  }
  //==============================================================



  //==============================================================
  Gimmick::~Gimmick()
  {
    
  }
  //==============================================================
  

  //==============================================================
  void Gimmick::Initialize()
  {
	  std::string i_nameDB = "Local database";
    // Create the UserSettings dir if does not exist
    CreateUserSettingsDirectory();
    // Sets the current directory to the home dir
    mCurrentDirectory =  GetHomeDirectory();
	mSynchronizer=0;

	std::string dbpath = GetLocalDatabasePath();
    // Create or open local database
	mLocalDatabase = createDB(i_nameDB, mCurrentDirectory + "\\.gimmick\\localdatabase_Descriptor.txt", dbpath);
    // Add it to the TreeHandlerMap
    mTreeHandlerMap[i_nameDB] = mLocalDatabase;
    
	// Creates files and directories database
    mTimestampDatabase = new TimestampDatabaseHandler(GetTimestampDatabasePath());
    // Create or open local database
    if (! boost::filesystem::exists( GetTimestampDatabasePath() ) )
      {
	std::string mess = "Timestamp database '";
	mess += GetTimestampDatabasePath();
	mess += "' does not exist : creating it";
	GimmickMessage(1,mess<<std::endl);
	
	if ( ! mTimestampDatabase->Create() )
	  {
	    GimmickError("ERROR CREATING '"<<GetTimestampDatabasePath()<<"'");
	  }
	
     }
    else 
      {
	/// Open and test it
	GimmickMessage(1,"Opening Timestamp database '"
		       <<GetTimestampDatabasePath()<<"' "
		       <<std::endl);
	if ( ! mTimestampDatabase->Open() )
	  {
	    GimmickError("ERROR OPENING '"<<GetTimestampDatabasePath()<<"'");
	  }
	
      }

  }

   ///////////////////////////////////////////////////////////////////////
   // add DB to TreeHandler Map											//
   // @param i_name : DB name										    //
   // @param i_location : DB location								    //
   // return : -														//
  ///////////////////////////////////////////////////////////////////////
	void Gimmick::addDB(std::string &i_name, std::string &i_location)
	{
		mTreeHandlerMap[i_name] = new SQLiteTreeHandler(i_location);
	}

 
  ///////////////////////////////////////////////////////////////////////////
  // create a DB from a attributes descriptor file for medical images      //
  // @param i_name : DB name											   //
  // @param i_locDesc : location of descriptor file						   //
  // @param i_locDB : location of DB									   //
  // return : the SQLiteTreeHandler object on DB						   //
	/////////////////////////////////////////////////////////////////////////
	SQLiteTreeHandler *Gimmick::createDB(std::string &i_name, std::string &i_locDesc, std::string &i_locDB)
  {
      SQLiteTreeHandler *sqlTreeH = new SQLiteTreeHandler(i_locDB);
    // Create or open local database
    if (! boost::filesystem::exists(i_locDB) )
     {
         std::string mess = "Local database '";
         mess += i_locDB;
         mess += "' does not exist : creating it";
         GimmickMessage(1,mess<<std::endl);
         
		 // CREATING DB STRUCTURE
         sqlTreeH->GetTree().GetDescriptor().createDescriptorfromFile(i_locDesc);
         if ( ! sqlTreeH->Create(true) )
		 {
			GimmickError("ERROR CREATING '"<<i_locDB<<"'");
         }
         sqlTreeH->SetAttribute(0,"Name",i_name);
	 }
	 else 
	 {
		/// Open and test it
		GimmickMessage(1,"Opening local database '" <<i_locDB<< "' " << std::endl);
        if ( !sqlTreeH->Open(true) )
		{
			GimmickError("ERROR OPENING '"<<i_locDB<<"'");
		}
      }
	 return sqlTreeH;
  }


  //==============================================================
  void Gimmick::Finalize()
  {
	 
	  // delete SQLiteTreeHandler Object
	   for( TreeHandlerMapType::const_iterator it = mTreeHandlerMap.begin();
           it!= mTreeHandlerMap.end(); ++it)
	   {
		   delete it->second;
	   }
	delete mTimestampDatabase;
  }
  //==============================================================

  //================================================================
  // file separator
#if defined(_WIN32)
#define VALID_FILE_SEPARATOR "\\"
#define INVALID_FILE_SEPARATOR "/"
#else
#define INVALID_FILE_SEPARATOR "\\"
#define VALID_FILE_SEPARATOR "/"
#endif
  //================================================================

  //================================================================
  const std::string& Gimmick::GetHomeDirectory()
  {
    if (mHomeDirectory.size()==0) 
      {
#if defined(__GNUC__)
	mHomeDirectory = getenv("HOME");
#elif defined(_WIN32)
	mHomeDirectory = getenv("USERPROFILE");
#endif
      }
    return mHomeDirectory;
  }
  //================================================================
  const std::string& Gimmick::GetUserSettingsDirectory()
  {
    if (mUserSettingsDirectory.size()==0) 
      {
	mUserSettingsDirectory = GetHomeDirectory();
	mUserSettingsDirectory += "/.gimmick/";
	boost::algorithm::replace_all( mUserSettingsDirectory, 
				       INVALID_FILE_SEPARATOR , 
				       VALID_FILE_SEPARATOR);
      }
    return mUserSettingsDirectory;
  }
  //================================================================

  //================================================================
  const std::string& Gimmick::GetLocalDatabasePath()
  {
    if (mLocalDatabasePath.size()==0) 
      {
	mLocalDatabasePath = GetUserSettingsDirectory();
	mLocalDatabasePath += "local_database.sqlite3";
	boost::algorithm::replace_all( mLocalDatabasePath,
				       INVALID_FILE_SEPARATOR , 
				       VALID_FILE_SEPARATOR);
      }
    return mLocalDatabasePath;    
  }

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

  //================================================================
  const std::string& Gimmick::GetTimestampDatabasePath()
  {
    if (mTimestampDatabasePath.size()==0) 
      {
	mTimestampDatabasePath = GetUserSettingsDirectory();
	mTimestampDatabasePath += "timestamp_database.sqlite3";
	boost::algorithm::replace_all( mTimestampDatabasePath,
				       INVALID_FILE_SEPARATOR , 
				       VALID_FILE_SEPARATOR);
      }
    return mTimestampDatabasePath;    
  }
  //========================================================================

  //========================================================================
  void Gimmick::CreateUserSettingsDirectory()
  {
    if (! boost::filesystem::is_directory( GetUserSettingsDirectory() ) )
      {
	GimmickMessage(1,"Directory '"<<GetUserSettingsDirectory()<<"' "
		       << "does not exist : creating it"<<std::endl);
	
	if ( ! boost::filesystem::create_directory( GetUserSettingsDirectory() ) )
	  {
	    GimmickError("ERROR CREATING '"<<GetUserSettingsDirectory()<<"'");
	  }
      }
  }
  //========================================================================


  //========================================================================
  /// Sets message level
  void Gimmick::SetMessageLevel(int l)
  {
    SetGimmickMessageLevel(l);
  }
  //========================================================================

  //========================================================================
  /// Sets message level
  void Gimmick::SetDebugMessageLevel(int l)
  {
    SetGimmickDebugMessageLevel(l);
  }
  //========================================================================

  //========================================================================
  /// Returns the tree handler with the given name
  TreeHandler* Gimmick::GetTreeHandler(const std::string& name) const 
  {  
    TreeHandlerMapType::const_iterator i;
    i = GetTreeHandlerMap().find(name);
    if ( i == GetTreeHandlerMap().end() )
      {
	GimmickError("TreeHandler '"<<name<<"' does not exist");
      }
    return i->second;
  }

  //========================================================================
  ///Returns the timestamp database handler
  TimestampDatabaseHandler* Gimmick::GetTimestampDatabase() const 
  {  
    return mTimestampDatabase;
  }


  //========================================================================
  /// Add the files to the tree handler
  void Gimmick::AddFiles(const std::string& d, 
			const std::vector<std::string>& filenames)
  {
    GimmickMessage(2,"Adding files to '"<<d<<"'"<<std::endl);
 
    mImageAdder.SetTreeHandler(GetTreeHandler(d));
	mImageAdder.SetTimestampHandler(mTimestampDatabase);
    mImageAdder.AddFiles(filenames);

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

  //========================================================================
  /// Add a dir to the local database
  void Gimmick::AddDir(const std::string& d, const std::string& f, 
		       bool recurse)
  {
    GimmickMessage(2,"Adding dir '"<<f<<"' to '"<<d<<"' recurse:"
		   <<recurse<<std::endl);

	TreeHandler * handler=GetTreeHandler(d);
    mImageAdder.SetTreeHandler(handler);
	mImageAdder.SetTimestampHandler(mTimestampDatabase);
    mImageAdder.AddDirectory(f,recurse);
	//Synchronize(true, handler);
    
  }

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

  //========================================================================
 
  void Gimmick::Synchronize(bool update, TreeHandler* handler)
  {
	  GimmickMessage(4,"Synchronizing. Update:"<<update<<std::endl);
	  if(mSynchronizer==0)
	  {
		  mSynchronizer=new Synchronizer(handler);
	  }
	  else
	  {
		  mSynchronizer->SetTreeHandler(handler);
	  }
	  mSynchronizer->Synchronize(update);

  }

  //========================================================================
  /// 
  void Gimmick::Print(const std::string& d)
  {
    GetTreeHandler(d)->GetTree().Print();
  }
  //========================================================================


}