/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkConfigurationFile.cxx,v $
  Language:  C++
  Date:      $Date: 2008/11/12 12:47:00 $
  Version:   $Revision: 1.21 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         

/**
 *\file
 *\brief Class bbtk::ConfigurationFile
 */

#include "bbtkConfigurationFile.h"
#include "bbtkMessageManager.h"
#include "bbtkXML.h"
#include "bbtkUtilities.h"

#if defined(WIN32)
# include <direct.h> // for getcwd
# include <windows.h>
#endif

#if defined(MACOSX) // assume this is OSX 
# include <sys/param.h>
# include <mach-o/dyld.h> // _NSGetExecutablePath : must add -framework CoreFoundation to link line 
# include <string.h>
# ifndef PATH_MAX
#  define PATH_MAX MAXPATHLEN
# endif
#endif // MACOSX

#ifndef PATH_MAX // If not defined yet : do it 
#  define PATH_MAX 2048
#endif


namespace bbtk
{

  //====================================================================
  /// Constructor
  ConfigurationFile::ConfigurationFile()
  {

	mFile_separator = VALID_FILE_SEPARATOR;
    
    // ==> Set system paths 
    mBin_path = GetExecutablePath();
//EED    mInstall_path = mBin_path + mFile_separator + "..";
#ifdef MACOSX
	  mInstall_path = mBin_path + "/../../../..";
#else
	  mInstall_path = mBin_path + "/..";
#endif
	  // The relative path to the doc folder (=BBTK_DOC_REL_PATH)
    mDoc_rel_path = BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH);
    // The path to the doc folder (=mInstall_path+"/"+mDoc_rel_path)
//EED    mDoc_path = mInstall_path + mFile_separator + mDoc_rel_path;
    mDoc_path = mInstall_path + "/" + mDoc_rel_path;
    // The relative path to the doc folder (=BBTK_BBS_REL_PATH)
    mBbs_rel_path = BBTK_STRINGIFY_SYMBOL(BBTK_BBS_REL_PATH);
    // The path to the bbs folder (=mInstall_path+"/"+mBbs_rel_path)
//EED    mBbs_path = mInstall_path + mFile_separator + mBbs_rel_path;
    mBbs_path = mInstall_path + "/" + mBbs_rel_path;
    // The relative path to the rsc folder (=BBTK_RSC_REL_PATH)
    //   mRsc_rel_path = BBTK_STRINGIFY_SYMBOL(BBTK_RSC_REL_PATH);
    // The path to the rsc folder (=mInstall_path+"/"+mRsc_rel_path)
    //   mRsc_path = mInstall_path + mFile_separator + mRsc_rel_path;
    // The path to the bbtk data folder 
    // Initialized to mInstall_path+"/"+BBTK_DATA_REL_PATH
    // But can be overriden by value read from bbtk_config.xml
//EED    mData_path = mInstall_path + mFile_separator + BBTK_STRINGIFY_SYMBOL(BBTK_DATA_REL_PATH);
    mData_path = mInstall_path + "/" + BBTK_STRINGIFY_SYMBOL(BBTK_DATA_REL_PATH);

	Utilities::replace( mBin_path		, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	Utilities::replace( mInstall_path	, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	Utilities::replace( mDoc_rel_path	, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	Utilities::replace( mDoc_path		, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	Utilities::replace( mBbs_path		, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	Utilities::replace( mData_path		, INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);

    bbtkMessage("Config",1," ==> bin    : '"<<mBin_path<<"'"<<std::endl);
    bbtkMessage("Config",1," ==> prefix : '"<<mInstall_path<<"'"<<std::endl);
    bbtkMessage("Config",1," ==> doc    : '"<<mDoc_path<<"'"<<std::endl);
    bbtkMessage("Config",1," ==> bbs    : '"<<mBbs_path<<"'"<<std::endl);
    bbtkMessage("Config",1," ==> data   : '"<<mData_path<<"'"<<std::endl);



    
    // bbs_paths
    // always add "." (current working directory) at the begining
	mBbs_paths.push_back( "." ); 
    // add system bbs path 
    mBbs_paths.push_back(mBbs_path);
    // add toolsbbtk/appli 
//EED    std::string toolsappli_rel_path(mFile_separator);
    std::string toolsappli_rel_path("/");
//EED    toolsappli_rel_path +=  "toolsbbtk" + mFile_separator + "appli";
    toolsappli_rel_path +=  "toolsbbtk/appli";
    //
    //-----------------------------------------------------------
    // LG : REMOVE BUGGY PATH WITH include *:
    // 
    //    mBbs_paths.push_back(mBbs_path + toolsappli_rel_path);
    //-----------------------------------------------------------
    int iStrVec,sizeStrVec;
    
    sizeStrVec = mBbs_paths.size();
    for (iStrVec=0;iStrVec<sizeStrVec;iStrVec++){
      Utilities::replace( mBbs_paths[iStrVec] , INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
    }

    
    // always add "." (current working directory) at the begining
    mPackage_paths.push_back(".");   
    // add system bin path (for build tree / standalone folder install)
    mPackage_paths.push_back(mBin_path);
    // add system lib path (for install tree)
//EED    mPackage_paths.push_back(mInstall_path + mFile_separator + "lib");
    mPackage_paths.push_back(mInstall_path + "/lib");
#ifdef WIN32
    // add bin/Debug bin/Release paths (for build/install tree)
//EED    mPackage_paths.push_back(mBin_path + mFile_separator + "Debug");
    mPackage_paths.push_back(mBin_path + "/Debug");
//EED    mPackage_paths.push_back(mBin_path + mFile_separator + "Release");
    mPackage_paths.push_back(mBin_path + "/Release");
#endif

	sizeStrVec = mPackage_paths.size();
	for (iStrVec=0;iStrVec<sizeStrVec;iStrVec++){
		Utilities::replace( mPackage_paths[iStrVec] , INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
	}



    GetHelp(2);
   
    // ==> First we look for bbtk_config.xml in "."
    char buf[2048];
    const char *currentDir = getcwd(buf, 2048);
    
    if( !currentDir )
      {
	std::cerr << "Path was too long to fit on 2048 bytes ?!?" << std::endl;
	// \todo : what else?
	// How abort a constructor and warn the caller function?
	// LG : throw an exception 
      }
    
//    std::string configXmlFullPathName = currentDir + mFile_separator + "bbtk_config.xml";
    std::string configXmlFullPathName = currentDir ;
                configXmlFullPathName += "/bbtk_config.xml";
	Utilities::replace( configXmlFullPathName , INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);

    if ( Utilities::FileExists( configXmlFullPathName ))
      {
	bbtkMessage("Config",1, "ConfigurationFile : [" << configXmlFullPathName << 
		    "] found in current directory" << std::endl); 
	//Read(configXmlFullPathName.c_str());
	// traiter le fichier local     
      }
    
    // ==> Then we look for bbtk_config.xml in ".bbtk"
    else 
      {
	configXmlFullPathName = Utilities::MakeUserSettingsFullFileName("bbtk_config.xml");
	if (!Utilities::FileExists( configXmlFullPathName ))
	  {         
	    // ==> Nothing found, we create bbtk_config.xml in ".bbtk"
	    InstallPath ();
	  }
      }
    
    // In any case, deal with bbtk_config.xml!
    Read(configXmlFullPathName.c_str());
  }
  //=========================================================================

  //=========================================================================
  /// Destructor
  ConfigurationFile::~ConfigurationFile()
  {
  }
  //=========================================================================
  



  //=========================================================================
  void ConfigurationFile::CreateConfigXML( char *rootDirectory )
  {
    FILE *fp;
    char configXml[250];
    sprintf (configXml , "%s/bbtk_config.xml", rootDirectory);
    bbtkDebugMessage("Config",1, "in CreateConfigXML[" << configXml << "]" << std::endl);
    fp = fopen (configXml, "w");
    fprintf(fp, "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n");
    fprintf(fp, "<config>\n");
    fprintf(fp, "   <bbs_path>     </bbs_path>\n");
    fprintf(fp, "   <package_path> </package_path>\n");
    fprintf(fp, "   <default_temp_dir> $ </default_temp_dir>\n");    
    fprintf(fp, "</config>\n");
    fclose(fp);
  }
  //=========================================================================  

	
	
	//=========================================================================  
	// From http://www.fltk.org/newsgroups.php?gfltk.general+v:22083
	//
	int get_app_path (char *pname, size_t pathsize)
	{
#ifdef LINUX
        /* Oddly, the readlink(2) man page says no NULL is appended. */
        /* So you have to do it yourself, based on the return value: */
        pathsize --; /* Preserve a space to add the trailing NULL */
        long result = readlink("/proc/self/exe", pname, pathsize);
        if (result > 0)
        {
			pname[result] = 0; /* add the #@!%ing NULL */
			
			if ((access(pname, 0) == 0))
				return 0; /* file exists, return OK */
			/*else name doesn't seem to exist, return FAIL (falls
			 through) */
        }
#endif /* LINUX */
		
#ifdef WIN32
        long result = GetModuleFileName(NULL, pname, pathsize);
        if (result > 0)
        {
			/* fix up the dir slashes... */
			int len = strlen(pname);
			int idx;
			for (idx = 0; idx < len; idx++)
			{
				if (pname[idx] == '\\') pname[idx] = '/';
			}
			if ((access(pname, 0) == 0))
				return 0; /* file exists, return OK */
			/*else name doesn't seem to exist, return FAIL (falls
			 through) */
        }
#endif /* WIN32 */
		
#ifdef SOLARIS
        char *p = getexecname();
        if (p)
        {
			/* According to the Sun manpages, getexecname will
			 "normally" return an */
			/* absolute path - BUT might not... AND that IF it is not,
			 pre-pending */
			/* getcwd() will "usually" be the correct thing... Urgh!
			 */
			
			/* check pathname is absolute (begins with a / ???) */
			if (p[0] == '/') /* assume this means we have an
			 absolute path */
			{
				strncpy(pname, p, pathsize);
				if ((access(pname, 0) == 0))
					return 0; /* file exists, return OK */
			}
			else /* if not, prepend getcwd() then check if file
			 exists */
			{
				getcwd(pname, pathsize);
				long result = strlen(pname);
				strncat(pname, "/", (pathsize - result));
				result ++;
				strncat(pname, p, (pathsize - result));
				
				if ((access(pname, 0) == 0))
					return 0; /* file exists, return OK */
				/*else name doesn't seem to exist, return FAIL
				 (falls through) */
			}
        }
#endif /* SOLARIS */
		
#ifdef MACOSX /* assume this is OSX */
		/*
		 from http://www.hmug.org/man/3/NSModule.html
		 
		 extern int _NSGetExecutablePath(char *buf, unsigned long
		 *bufsize);
		 
		 _NSGetExecutablePath  copies  the  path  of the executable
		 into the buffer and returns 0 if the path was successfully
		 copied  in the provided buffer. If the buffer is not large
		 enough, -1 is returned and the  expected  buffer  size  is
		 copied  in  *bufsize.  Note that _NSGetExecutablePath will
		 return "a path" to the executable not a "real path" to the
		 executable.  That  is  the path may be a symbolic link and
		 not the real file. And with  deep  directories  the  total
		 bufsize needed could be more than MAXPATHLEN.
		 */
        int status = -1;
        char *given_path = (char*)malloc(MAXPATHLEN * 2);
        if (!given_path) return status;
		
        uint32_t npathsize = MAXPATHLEN * 2;
        long result = _NSGetExecutablePath(given_path, &npathsize);
        if (result == 0)
        { /* OK, we got something - now try and resolve the real path...
		 */
			if (realpath(given_path, pname) != NULL)
			{
				if ((access(pname, 0) == 0))
					status = 0; /* file exists, return OK */
			}
        }
        free (given_path);
        return status;
#endif /* MACOSX */
		
        return -1; /* Path Lookup Failed */
	} 
	

	
  //=========================================================================
  std::string ConfigurationFile::GetExecutablePath()
  {
	  char name[PATH_MAX];
	  int err = get_app_path(name, PATH_MAX);
	  if (err) 
	  {
		bbtkError("Could not determine current executable path ?");  
	  }
	  
	  // remove the exe name
	  char *slash;		
	  slash = strrchr(name, VALID_FILE_SEPARATOR_CHAR);
	  if (slash)
	  {
		  *slash = 0;
	  }
	  return name;
  }
	  
/*	  
    /// \todo : Think to delete it!
    char *buf = (char *)malloc(512);
	if (!buf) 
	{
		bbtkError("Could not allocate 512 bytes !");
	}
    char *slash;
    
#if defined(WIN32)
    GetModuleFileName(NULL, buf, 511);
    slash = strrchr(buf, '\\');
    if (slash)
      {
        *slash = 0;
      }
#endif 
	  

#if defined(__GNUC__)
    int res;
    res = readlink("/proc/self/exe", buf, 512);
    if (res == -1)
	{
	    free(buf);
		
	}
    buf[res] = 0;
    slash = strrchr(buf, '/');
    if (slash)
      {
        *slash = 0;
      }
#endif
    std::string ret(buf);
    free(buf);
    return ret;
  }
  //=========================================================================
*/

  //=========================================================================
  void ConfigurationFile::InstallPath ()
  {
    
    /*--------------------------------------------------
      New policy for bbtk_config.xml :
      
      if bbtk_config.xml found in current directory (user is an aware user!)
      use it!
      
      else if bbtk_config.xml found in HOME/.bbtk (user already worked with it)
      use it!
      
      else if bbtk_config.xml.tmp found in /usr/local/bin or c:\\Program Files\\BBTK\\bin
      copy it as .bbtk/bbtk_config.xml
      
      else (nothing installed)
      create a minimum version in HOME/.bbtk
      ----------------------------------------------------*/
    
    
    // -----------------------------------------------------------------
#if defined(__GNUC__)
    
    // ------------------ create some usefull strings ----------------
    // installed bbtk_path
    char bbtk_path[100];
    strcpy(bbtk_path, "/usr/local/bin");
    
    // rootDirectory
    char rootDirectory[200];
    sprintf( rootDirectory,  "%s/.bbtk", getenv("HOME"));
    
    // configPath
    char configPath[200];
    sprintf(configPath, "%s/bbtk_config.xml",rootDirectory);
    
    // makeDir
    char makeDir[250];
    sprintf( makeDir, "mkdir \"%s\" ", rootDirectory);
    
    // configXmlTmp
    char configXmlTmp[250]; 
    sprintf(configXmlTmp, "%s/bbtk_config.xml.tmp", bbtk_path);
    
    // copyFile
    char copyFile[250];
    
    if (!Utilities::FileExists(configXmlTmp)) // bbtk_config.xml.tmp not found (not installed)
      {  
	if (!Utilities::FileExists(rootDirectory)) // .bbtk not found
	  {
	    system(makeDir);  // create .bbtk
	  }
	
	// if "bbtk_path/bbtk_config.xml.tmp" doesn't exist, hard-create a minimum version in .bbtk
	CreateConfigXML( rootDirectory );// create .bbtk
      }
    else
      {
	sprintf(copyFile,"cp %s  %s/bbtk_config.xml ",configXmlTmp,rootDirectory );
	if (!Utilities::FileExists(rootDirectory))
	  {
	    //std::cout << "makeDir[" << makeDir << "]" << std::endl;
	    system(makeDir);
	  }
	
	if (!Utilities::FileExists(configPath))
	  {
	    system(copyFile);
	  }
      }
    return;
    
    // ------------------------------------------------------------------
#elif defined(WIN32)
    
    
    // installed bbtk_path
    char bbtk_path[100];
    strcpy(bbtk_path, "\"c:\\Program Files\\BBTK\\bin\"");
    char bbtk_path2[100];
    strcpy(bbtk_path2, "c:\\Program Files\\BBTK\\bin");
    
    // rootDirectory
    char rootDirectory[200];  
    sprintf(rootDirectory, "%s\\.bbtk",getenv("USERPROFILE"));
    //  std::cout << "[" << rootDirectory << "]" << std::endl;
    
    // configPath
    char configPath[200];
    sprintf(configPath, "%s\\bbtk_config.xml",rootDirectory);
    
    // makeDir
    char makeDir[250];
    sprintf( makeDir, "mkdir \"%s\" ", rootDirectory);
    
    // configXmlTmp
    char configXmlTmp[250]; 
    sprintf(configXmlTmp, "%s\\bbtk_config.xml.tmp", bbtk_path2);
    
    // copyFile
    char copyFile[250];
    
    if (!Utilities::FileExists(configXmlTmp)) // bbtk_config.xml.tmp not found
      {
	if (!Utilities::FileExists(rootDirectory)) // .bbtk not found
	  {
	    system(makeDir);  // create .bbtk
	  }
	
	// if "bbtk_path/bbtk_config.xml.tmp" doesn't exist, hard-create a minimum version in .bbtk
	CreateConfigXML( rootDirectory );// create .bbtk
	return;
      }  
    
    sprintf(copyFile,"copy %s\\bbtk_config.xml.tmp \"%s\"\\bbtk_config.xml ",bbtk_path,rootDirectory );
    
    int attribs = GetFileAttributes (rootDirectory);
    bbtkMessage("Config",1,std::hex << attribs << " " << FILE_ATTRIBUTE_DIRECTORY << std::endl);
    if ( attribs != 0xFFFFFFFF)
      {
	if ((attribs & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY ) /// \TODO : check !
	  {
	    if ( GetFileAttributes( configPath ) == 0xFFFFFFFF)
	      {
		system(copyFile);  
	      } 
	  }
      } 
    else 
      {
	system(makeDir);
	system(copyFile); 
      }    
    return;  
    // ------------------------------------------------------------------    
#else
/// \todo  ConfigurationFile::InstallPath() : exit when for not WIN32 and not__GNUC__

  return;    
#endif

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



  //=========================================================================
  // Gets the list of directories holding bb scripts, packages, dll, ... from the xml file
  //      bbtk_config.xml
  
  void ConfigurationFile::Read(const std::string& filename)
  {
    
    bbtkDebugMessage("Config",1,"ConfigurationFile::Read(" <<filename << ")" << std::endl);
    
    mConfig_xml_full_path = filename;
    XMLResults* res = new XMLResults;
    XMLNode BB = XMLNode::parseFile((XMLCSTR)filename.c_str(),(XMLCSTR)"config",res);
    
    if ( res->error != eXMLErrorNone ) 
      {
	std::string mess = GetErrorMessage(res,filename);
	delete res;
	bbtkDebugMessage("Config",1,mess<< std::endl);
 	bbtkError(mess);
      }
    delete res;
    
    bbtkDebugMessage("Config",1,"OK" << std::endl);
  
    int i,j;
    
    // Description
    for (i=0,j=0; i<BB.nChildNode((XMLCSTR)"description"); i++) 
      {
	std::string val;
	GetTextOrClear(BB.getChildNode((XMLCSTR)"description",&j),val);
	mDescription += val;
      }    
    
    // Url
    if( BB.nChildNode((XMLCSTR)"url") ) 
      GetTextOrClear(BB.getChildNode((XMLCSTR)"url"),mUrl);
    
    // Data_Path
    if( BB.nChildNode((XMLCSTR)"data_path") ) 
      GetTextOrClear(BB.getChildNode((XMLCSTR)"data_path"),mData_path);
    
    // install_path
    //  if( BB.nChildNode((XMLCSTR)"install_path") )
    //   GetTextOrClear(BB.getChildNode((XMLCSTR)"install_path"),mInstall_path);
    
    // add user bbs paths
    for (i=0,j=0; i<BB.nChildNode((XMLCSTR)"bbs_path"); i++) 
      {
	std::string val;
	GetTextOrClear(BB.getChildNode((XMLCSTR)"bbs_path",&j),val);
	mBbs_paths.push_back(val);
      }
    
    // package_paths
    
    // add user package path
    for (i=0,j=0; i<BB.nChildNode((XMLCSTR)"package_path"); i++) 
      {
	std::string val;
	GetTextOrClear(BB.getChildNode((XMLCSTR)"package_path",&j),val);
	mPackage_paths.push_back(val);
      }
    
    // default_temp_dir
    if( BB.nChildNode((XMLCSTR)"default_temp_dir") ) 
      GetTextOrClear(BB.getChildNode((XMLCSTR)"default_temp_dir"),mDefault_temp_dir);
    
    if ( mDefault_temp_dir == "$") // no value found in config_xml
      {
	size_t pos = mConfig_xml_full_path.find("bbtk_config.xml");
	mDefault_temp_dir = mConfig_xml_full_path.substr (0,pos); 
      }    

    GetHelp(2);
  }
  //=========================================================================
  
  //=========================================================================
  bool ConfigurationFile::AddPackagePathsAndWrite( const std::string& path )
  {
    bbtkDebugMessageInc("Config",9,
			"ConfigurationFile::AddPackagePathsAndWrite("
			<<path<<")"<<std::endl);
    
     XMLResults* res = new XMLResults;
    XMLNode BB = 
      XMLNode::parseFile((XMLCSTR)Get_config_xml_full_path().c_str(),
			 (XMLCSTR)"config",res);
    
    if ( res->error != eXMLErrorNone ) 
      {
	std::string mess = GetErrorMessage(res,Get_config_xml_full_path());
	delete res;
	bbtkDebugMessage("Config",1,mess<< std::endl);
 	bbtkError(mess);
      }
   delete res;

#ifdef _WIN32
    std::string bbs_path = path + "/bbs";
#else
    std::string bbs_path = path + "/share/bbtk/bbs" ;
#endif
    XMLNode BBSPATH = BB.addChild((XMLCSTR)"bbs_path");
    BBSPATH.addText((XMLCSTR)bbs_path.c_str());
    Utilities::replace(bbs_path, INVALID_FILE_SEPARATOR, VALID_FILE_SEPARATOR);
    mBbs_paths.push_back(bbs_path);
 
#ifdef _WIN32
    std::string pack_path = path + "/bin";
#else
    std::string pack_path = path ;
#endif
    XMLNode PACKPATH = BB.addChild((XMLCSTR)"package_path");
    PACKPATH.addText((XMLCSTR)pack_path.c_str());
    Utilities::replace(pack_path,INVALID_FILE_SEPARATOR,VALID_FILE_SEPARATOR);
    mPackage_paths.push_back(pack_path);

#ifdef _WIN32
    pack_path = path + "/Debug";
    PACKPATH = BB.addChild((XMLCSTR)"package_path");
    PACKPATH.addText((XMLCSTR)pack_path.c_str());
    Utilities::replace(pack_path,INVALID_FILE_SEPARATOR,VALID_FILE_SEPARATOR);
    mPackage_paths.push_back(pack_path);
    pack_path = path + "/Release";
    PACKPATH = BB.addChild((XMLCSTR)"package_path");
    PACKPATH.addText((XMLCSTR)pack_path.c_str());
    Utilities::replace(pack_path,INVALID_FILE_SEPARATOR,VALID_FILE_SEPARATOR);
    mPackage_paths.push_back(pack_path);
#endif


    XMLError err = BB.writeToFile((XMLCSTR)Get_config_xml_full_path().c_str());
    if ( err != eXMLErrorNone ) 
      {
	std::string mess = GetErrorMessage(res,Get_config_xml_full_path());
	bbtkDebugMessage("Config",1,mess<< std::endl);
 	bbtkError(mess);
      }

    return true;
  }
  //=========================================================================

  //=========================================================================
  void ConfigurationFile::GetHelp(int level) const
  {
    bbtkDebugMessageInc("Config",9,"ConfigurationFile::GetHelp("<<level
			<<")"<<std::endl);
    
    const std::string config_xml_full_path      = Get_config_xml_full_path();    
    const std::string description               = Get_description();
    const std::string url                       = Get_doc_path();
    const std::string data_path                 = Get_data_path();
    const std::string default_temp_dir          = Get_default_temp_dir();    
    const std::string file_separator            = Get_file_separator();    
    const std::vector<std::string>bbs_paths     = Get_bbs_paths();
    const std::vector<std::string>package_paths = Get_package_paths();
    
    bbtkMessage("Help",level, "============="   << std::endl);           
    bbtkMessage("Help",level, "Configuration"   << std::endl);
    bbtkMessage("Help",level, "============="   << std::endl);
    bbtkMessage("Help",level, "bbtk_config.xml    : [" << config_xml_full_path  << "]" << std::endl); 
    bbtkMessage("Help",level, "Documentation Path : [" << url             << "]" << std::endl);
    bbtkMessage("Help",level, "Data Path          : [" << data_path       << "]" << std::endl);
    bbtkMessage("Help",level, "Temp Directory     : [" << default_temp_dir << "]" << std::endl);
    bbtkMessage("Help",level, "File Separator     : [" << file_separator  << "]" << std::endl);

    std::vector<std::string>::const_iterator i;
           
    bbtkMessage("Help",level, "BBS Paths   " << std::endl);     
    for (i = bbs_paths.begin(); i!=bbs_paths.end(); ++i )
    {
      bbtkMessage("Help",level,"--- ["<<*i<<"]"<<std::endl);
    }    
    
    bbtkMessage("Help",level, "PACKAGE Paths : " << std::endl);     
    for (i = package_paths.begin(); i!=package_paths.end(); ++i )
    {
      bbtkMessage("Help",level,"--- ["<<*i<<"]"<<std::endl);
    }

    bbtkDebugDecTab("Config",9);
  }
  //=========================================================================


} // namespace bbtk