/*=========================================================================
                                                                                
  Program:   bbtk
  Module:    $RCSfile: bbtkConfigurationFile.cxx,v $
  Language:  C++
  Date:      $Date: 2008/01/22 15:02:00 $
  Version:   $Revision: 1.1 $
                                                                                
  Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  l'Image). All rights reserved. See doc/license.txt or
  http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details.
                                                                                
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

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

#include "bbtkConfigurationFile.h"
#include "bbtkMessageManager.h"
//#include "xmlParser.h"
#include <sys/stat.h> // for struct stat stFileInfo

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

namespace bbtk
{
/// Constructor
ConfigurationFile::ConfigurationFile()
{
   char *execPath = GetExecutablePath();

 #if defined(WIN32)
   std::string slash("\\");
 #else
   std::string slash("/");
 #endif
 
// ==> 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?
   }

   std::string configXmlFullPathName = currentDir + slash + "bbtk_config.xml";

   if ( 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 
   {
   #if defined(__GNUC__)
      std::string str_home(getenv("HOME"));
   #elif defined(_WIN32)
      std::string str_home(getenv("USERPROFILE"));
   #endif
      configXmlFullPathName = str_home + slash + ".bbtk/bbtk_config.xml";
      if (!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()
{
}

// See : http://www.techbytes.ca/techbyte103.html for more O.S.
bool ConfigurationFile::FileExists(std::string strFilename) {
  struct stat stFileInfo;
  bool blnReturn;
  int intStat;

  // Attempt to get the file attributes
  intStat = stat(strFilename.c_str(),&stFileInfo);
  if(intStat == 0) {
    // We were able to get the file attributes
    // so the file obviously exists.
    blnReturn = true;
  } else {
    // We were not able to get the file attributes.
    // This may mean that we don't have permission to
    // access the folder which contains this file. If you
    // need to do that level of checking, lookup the
    // return values of stat which will give you
    // more details on why stat failed.
    blnReturn = false;
  }

  return(blnReturn);
}


void ConfigurationFile::CreateConfigXML( char *rootDirectory )
{
   FILE *fp;
   char configXml[250];
   sprintf (configXml , "%s/bbtk_config.xml", rootDirectory);
   bbtkMessage("Config",1, "in CreateConfigXML[" << configXml << "]" << std::endl);
   fp = fopen (configXml, "w");
   fprintf(fp, "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n");
   fprintf(fp, "<!DOCTYPE config SYSTEM \"/mnt/windows/bbtk/bbtk_config.xml>\n");
   fprintf(fp, "<config>\n");
   fprintf(fp, "   <description>  </description>\n");
   fprintf(fp, "   <url>  http://www.creatis.insa-lyon.fr/software/bbtk  </url>\n");
   fprintf(fp, "   <install_path> </install_path>\n");
   fprintf(fp, "   <bbs_path>     </bbs_path>\n");
  // fprintf(fp, "   <ext_dll_path> </ext_dll_path>\n");
   fprintf(fp, "   <package_path> </package_path>\n");
   fprintf(fp, "   <data_path> %s </data_path>\n", BBTK_DATA_PATH);
   /// \todo find a decent default value !
   ///fprintf(fp, "   <default_doc_tmp>  %s </default_doc_tmp>\n", " ");
   // when $ will be found, default_doc_tmp value will be replaced
   fprintf(fp, "   <default_doc_tmp>$</default_doc_tmp>\n");
   fprintf(fp, "</config>\n");
   fclose(fp);
}

char *ConfigurationFile::GetExecutablePath()
{
    /// \todo : Think to delete it!
    char *buf = (char *)malloc(512);
    char *slash;

#if defined(WIN32)
    GetModuleFileName(NULL, buf, 511);
    slash = strrchr(buf, '\\');
    if (slash)
    {
        *slash = 0;
    }
#elif defined(__GNUC__)
    int res;
    res = readlink("/proc/self/exe", buf, 512);
    if (res == -1)
        return "";
    buf[res] = 0;
    slash = strrchr(buf, '/');
    if (slash)
    {
        *slash = 0;
    }
#else
    return "";
#endif

    return buf;
}



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 (!FileExists(configXmlTmp)) // bbtk_config.xml.tmp not found (not installed)
  {  
     if (!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 (!FileExists(rootDirectory))
     {
       //std::cout << "makeDir[" << makeDir << "]" << std::endl;
       system(makeDir);
     }

     if (!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 (!FileExists(configXmlTmp)) // bbtk_config.xml.tmp not found
  {
     if (!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

}

void ConfigurationFile::GetTextOrClear(const XMLNode& node, std::string& var)
{
  if (node.nText()>0) 
    {
      var = node.getText();
    }
  else if (node.nClear()>0) 
    {
      var = node.getClear().lpszValue;
    }
  else 
    {
      std::string mess("Error : element <");
      mess += node.getName();
      mess += "> : no text nor <PRE></PRE> clear tag found";
    }
}


// Gets the list of directories holding bb scripts, packages, dll, ... from the xml file
//      bbtk_config.xml

void ConfigurationFile::Read(const std::string& filename)
{

  //std::cout << "=======================in  ConfigurationFile::Read filename [" <<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::ostringstream str;
      str << XMLNode::getError(res->error);
      str << " [line " << res->nLine << ", col "<<res->nColumn<<"] ";
      str << " file "<<filename; 
      delete res;
      bbtkError(str.str());
//      throw ConfigurationException(str.str());
    }
  delete res;

  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);

  // always add "." (current working directory) at the begining

  // bbs_paths
  mBbs_paths.push_back("."); 
  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
  mPackage_paths.push_back(".");   
  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_doc_tmp
  if( BB.nChildNode((XMLCSTR)"default_doc_tmp") ) 
     GetTextOrClear(BB.getChildNode((XMLCSTR)"default_doc_tmp"),mDefault_doc_tmp);

  if ( mDefault_doc_tmp == "$") // no value found in config_xml
  {
     size_t pos = mConfig_xml_full_path.find("bbtk_config.xml");
     mDefault_doc_tmp = mConfig_xml_full_path.substr (0,pos); 
  }    
  // file separator
  #if defined(_WIN32)
     mFile_separator = "\\";
  #else
     mFile_separator = "/";
  #endif
}


} // namespace bbtk