#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()
  {
    // Create the UserSettings dir if does not exist
    CreateUserSettingsDirectory();
    // Sets the current directory to the home dir
    mCurrentDirectory =  GetHomeDirectory();
	mSynchronizer=0;

    // Create local database handler
    mLocalDatabase = new SQLiteTreeHandler(GetLocalDatabasePath());
    // Add it to the TreeHandlerMap
    mTreeHandlerMap["Local database"] = mLocalDatabase;
    // Create or open local database
    if (! boost::filesystem::exists( GetLocalDatabasePath() ) )
      {
	std::string mess = "Local database '";
	mess += GetLocalDatabasePath();
	mess += "' does not exist : creating it";
	GimmickMessage(1,mess<<std::endl);
	
	// CREATING DEFAULT DB STRUCTURE
	mLocalDatabase->GetTree().GetDescriptor().CreateDefault();
	
	if ( ! mLocalDatabase->Create(true) )
	  {
	    GimmickError("ERROR CREATING '"<<GetLocalDatabasePath()<<"'");
	  }
	mLocalDatabase->SetAttribute(0,"Name","Local database");
      }
    else 
      {
	/// Open and test it
	GimmickMessage(1,"Opening local database '"
		       <<GetLocalDatabasePath()<<"' "
		       <<std::endl);
	if ( ! mLocalDatabase->Open(true) )
	  {
	    GimmickError("ERROR OPENING '"<<GetLocalDatabasePath()<<"'");
	  }
	
      }


	// 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()<<"'");
	  }
	
      }

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


  //==============================================================
  void Gimmick::Finalize()
  {
    delete mLocalDatabase;
	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();
  }
  //========================================================================


}