#include "tsystem.h"

#include <time.h></time.h>

#include <sys timeb.h=""></sys>

#include <sys types.h=""></sys>

#include <sys stat.h=""></sys>

#include <errno.h></errno.h>

#include <set></set>

#undef PLATFORM

#ifdef WIN32

#define PLATFORM WIN32

#include <process.h></process.h>

#include <io.h></io.h>

#include <stdlib.h></stdlib.h>

#include <direct.h></direct.h>

#include "winsock2.h"

#include "lmcons.h"

#include <sys utime.h=""></sys>

#endif

#ifdef LINUX

#define PLATFORM LINUX

#include <grp.h></grp.h>

#include <utime.h></utime.h>

#include <sys param.h=""></sys>

#include <unistd.h></unistd.h>

#include <sys types.h=""></sys>

#include <stdio.h></stdio.h>

#include <unistd.h></unistd.h>

#include <dirent.h></dirent.h>

#include <sys dir.h=""></sys>

#include <sys sysinfo.h=""></sys>

#include <sys swap.h=""></sys>

#include <sys statfs.h=""></sys>

#include <pwd.h></pwd.h>

#include <mntent.h></mntent.h>

#include <dlfcn.h></dlfcn.h>

extern "C" {

int gethostname(char *, size_t);

// int L_cuserid;

char *cuserid(char *);

char *tempnam(const char *, const char *);

}

#endif

#ifdef __sgi

#define PLATFORM SGI

#include <sys param.h=""></sys>

#include <unistd.h></unistd.h>

#include <grp.h></grp.h>

#include <sys dir.h="">  // dirent.h</sys>

#include <sys utime.h=""></sys>

#include <sys swap.h=""></sys>

#include <sys statfs.h=""></sys>

#include <pwd.h></pwd.h>

#include <mntent.h></mntent.h>

#include <dlfcn.h></dlfcn.h>

#endif

#ifndef PLATFORM

PLATFORM_NOT_SUPPORTED

#endif

using namespace std;

#ifdef WIN32

const int TSystem::MaxPathLen     = _MAX_PATH;

const int TSystem::MaxFNameLen    = _MAX_FNAME;

const int TSystem::MaxHostNameLen = 64;

const unsigned short TFileStatus::UserReadable   = _S_IREAD;

const unsigned short TFileStatus::UserWritable   = _S_IWRITE;

const unsigned short TFileStatus::UserExecutable = _S_IEXEC;

const unsigned short TFileStatus::OwnerReadWriteExec =

    TFileStatus::UserReadable | TFileStatus::UserWritable |

    TFileStatus::UserExecutable;

const unsigned short TFileStatus::OwnerReadable   = TFileStatus::UserReadable;

const unsigned short TFileStatus::OwnerWritable   = TFileStatus::UserWritable;

const unsigned short TFileStatus::OwnerExecutable = TFileStatus::UserExecutable;

const unsigned short TFileStatus::GroupReadWriteExec =

    TFileStatus::OwnerReadWriteExec;

const unsigned short TFileStatus::GroupReadable   = TFileStatus::UserReadable;

const unsigned short TFileStatus::GroupWritable   = TFileStatus::UserWritable;

const unsigned short TFileStatus::GroupExecutable = TFileStatus::UserExecutable;

const unsigned short TFileStatus::OtherReadWriteExec =

    TFileStatus::UserReadable | TFileStatus::UserWritable |

    TFileStatus::UserExecutable;

;

const unsigned short TFileStatus::OtherReadable   = TFileStatus::UserReadable;

const unsigned short TFileStatus::OtherWritable   = TFileStatus::UserWritable;

const unsigned short TFileStatus::OtherExecutable = TFileStatus::UserReadable;

const unsigned short TFileStatus::IfDir = _S_IFDIR;

#define MKDIR _mkdir

#define RMDIR _rmdir

#define TEMPNAM _tempnam

#define ACCESS _access

#define STAT _stat

#define UTIME _utime

#define FTIME _ftime

using std::ifstream;

using std::ofstream;

using std::filebuf;

#else  // these are common for IRIX & LINUX

const int TSystem::MaxPathLen     = MAXPATHLEN;

const int TSystem::MaxHostNameLen = MAXHOSTNAMELEN;

const unsigned short TFileStatus::OwnerReadWriteExec = S_IRWXU;

const unsigned short TFileStatus::OwnerReadable      = S_IRUSR;

const unsigned short TFileStatus::OwnerWritable      = S_IWUSR;

const unsigned short TFileStatus::OwnerExecutable    = S_IXUSR;

const unsigned short TFileStatus::GroupReadWriteExec = S_IRWXG;

const unsigned short TFileStatus::GroupReadable      = S_IRGRP;

const unsigned short TFileStatus::GroupWritable      = S_IWGRP;

const unsigned short TFileStatus::GroupExecutable    = S_IXGRP;

const unsigned short TFileStatus::OtherReadWriteExec = S_IRWXO;

const unsigned short TFileStatus::OtherReadable      = S_IROTH;

const unsigned short TFileStatus::OtherWritable      = S_IWOTH;

const unsigned short TFileStatus::OtherExecutable    = S_IXOTH;

#define MKDIR mkdir

#define RMDIR rmdir

#define TEMPNAM tempnam

#define ACCESS access

#define STAT stat

#define UTIME utime

#define FTIME ftime

#ifdef __sgi

const int TSystem::MaxFNameLen                       = MAXNAMELEN;

const unsigned short TFileStatus::UserReadable       = S_IREAD;

const unsigned short TFileStatus::UserWritable       = S_IWRITE;

const unsigned short TFileStatus::UserExecutable     = S_IEXEC;

const unsigned short TFileStatus::IfDir              = S_IFDIR;

#else

const int TSystem::MaxFNameLen                   = 1024;

const unsigned short TFileStatus::UserReadable   = __S_IREAD;

const unsigned short TFileStatus::UserWritable   = __S_IWRITE;

const unsigned short TFileStatus::UserExecutable = __S_IEXEC;

const unsigned short TFileStatus::IfDir          = __S_IFDIR;

#endif

#endif

//-----------------------------------------------------------------------------------

ostream &operator<<(ostream &out, const TSystemException &e) {

  return out << "TSystem Exception : " << e.getMessage() << endl;

}

//-----------------------------------------------------------------------------------

// conversion functions

namespace {

//---------------------------------------------------------

void makeTm(const TTime &t, tm *p) {

  ::memset(p, 0, sizeof(tm));

  p->tm_year  = t.getYear() - 1900;

  p->tm_mon   = t.getMonth() - 1;  //[0,11]

  p->tm_mday  = t.getDay();

  p->tm_hour  = t.getHour();

  p->tm_min   = t.getMinutes();

  p->tm_sec   = t.getSeconds();

  p->tm_isdst = -1;

}

//---------------------------------------------------------

TTime makeTTime(const tm &p, int msec = 0) {

  return TTime(p.tm_year + 1900, p.tm_mon + 1, p.tm_mday, p.tm_hour, p.tm_min,

               p.tm_sec, msec);

}

//---------------------------------------------------------

time_t makeTimeT(const TTime &t) {

  tm x;

  makeTm(t, &x);

  time_t tt = mktime(&x);

  return tt;

}

}  // namespace

//-----------------------------------------------------------------------------------

TDeltaTime::TDeltaTime(long sec, long msec) {

  // assert((sec && msec>=0) ||(sec==0 ));

  assert(!((sec < 0 && msec > 0) || (sec > 0 && msec < 0)));

  /*

0   0   ok

0   1   ok

1   0   ok

1   1   ok

0  -1   ok

-1   0   ok

-1  -1   ok

-1   1   NO

1  -1   NO

*/

  m_dsec  = sec + msec / 1000;

  m_dmsec = msec % 1000;

}

//------------------------------------------------------------

TDeltaTime TDeltaTime::operator+(const TDeltaTime &tdt) {

  long sumSec  = m_dsec + tdt.m_dsec;

  long sumMsec = m_dmsec + tdt.m_dmsec;

  if (sumSec > 0 && sumMsec < 0) return TDeltaTime(sumSec - 1, sumMsec + 1000);

  if (sumSec < 0 && sumMsec > 0) return TDeltaTime(sumSec + 1, sumMsec - 1000);

  return TDeltaTime(sumSec, sumMsec);

}

//------------------------------------------------------------

TDeltaTime TDeltaTime::operator-(const TDeltaTime &tdt) {

  long diffSec  = m_dsec - tdt.m_dsec;

  long diffMsec = m_dmsec - tdt.m_dmsec;

  if (diffSec < 0 && diffMsec > 0)

    return TDeltaTime(diffSec + 1, diffMsec - 1000);

  if (diffSec > 0 && diffMsec < 0)

    return TDeltaTime(diffSec - 1, diffMsec + 1000);

  return TDeltaTime(diffSec, diffMsec);

}

//------------------------------------------------------------

ostream &operator<<(ostream &out, const TDeltaTime &dt) {

  return out << dt.getSeconds() << "." << dt.getMilliSeconds();

}

//-----------------------------------------------------------------------------------

// correggere gli assert => invalid (esiste il metodo bool isValid()const;

// operazioni con

// un TTIme invalid danno un risultato invalid

//

//

TTime::TTime(int yyyy, int mm, int dd, int hh, int min, int sec, int msec) {

  if (yyyy < 10)

    yyyy += 2000;

  else if (yyyy < 99)

    yyyy += 1900;

  assert(1970 <= yyyy && yyyy <= 2038);

  m_y = yyyy;

  assert(1 <= mm && mm <= 12);

  m_m = mm;

  int table[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

  int ddlimit = mm == 2 ? (28 + (isLeap() ? 1 : 0)) : table[mm - 1];

  assert(1 <= dd && dd <= ddlimit);

  m_d = dd;

  assert(0 <= hh && hh <= 23);

  m_h = hh;

  assert(0 <= min && min <= 59);

  m_min = min;

  assert(0 <= sec && sec <= 59);

  m_sec = sec;

  assert(0 <= msec && msec <= 999);

  m_msec = msec;

}

//-----------------------------------------------------------------------------------

TTime::TTime(const TTime &t)

    : m_y(t.m_y)

    , m_m(t.m_m)

    , m_d(t.m_d)

    , m_h(t.m_h)

    , m_min(t.m_min)

    , m_sec(t.m_sec)

    , m_msec(t.m_msec) {}

//-----------------------------------------------------------------------------------

bool TTime::operator==(const TTime &time) const {

  return (m_y == time.m_y) && (m_m == time.m_m) && (m_d == time.m_d) &&

         (m_h == time.m_h) && (m_min == time.m_min) && (m_sec == time.m_sec) &&

         (m_msec == time.m_msec);

}

//-----------------------------------------------------------------------------------

bool TTime::operator>(const TTime &time) const {

  return (m_y > time.m_y) || (m_y == time.m_y && m_m > time.m_m) ||

         (m_y == time.m_y && m_m == time.m_m && m_d > time.m_d) ||

         (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

          m_h > time.m_h) ||

         (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

          m_h == time.m_h && m_min > time.m_min) ||

         (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

          m_h == time.m_h && m_min == time.m_min && m_sec > time.m_sec) ||

         (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

          m_h == time.m_h && m_min == time.m_min && m_sec == time.m_sec &&

          m_msec > time.m_msec);

}

//-----------------------------------------------------------------------------------

TDeltaTime TTime::operator-(const TTime &t) const {

  time_t t2 = makeTimeT(*this);

  assert(t2 != -1);

  time_t t1 = makeTimeT(t);

  assert(t1 != -1);

  double d = difftime(t2, t1);

  if (m_msec >= t.m_msec) {

    if (d <= -1)

      return TDeltaTime((long)(d + 1), -(long)(1000 - (m_msec - t.m_msec)));

    else

      return TDeltaTime((long)d, (long)(m_msec - t.m_msec));

  } else {

    if (d <= 0)

      return TDeltaTime((long)(d), (long)(m_msec - t.m_msec));

    else

      return TDeltaTime((long)(d - 1), (long)(1000 + m_msec - t.m_msec));

  }

}

//-----------------------------------------------------------------------------------

TTime TTime::operator+(const TDeltaTime &tdt) const {

  tm x;

  makeTm(*this, &x);

  int ms = m_msec + tdt.getMilliSeconds();

  if (ms < 0) {

    ms += 1000;

    x.tm_sec += tdt.getSeconds() - 1;

  } else

    x.tm_sec += tdt.getSeconds() + ms / 1000;

  mktime(&x);

  return makeTTime(x, ms % 1000);

}

//-----------------------------------------------------------------------------------

TTime TTime::operator-(const TDeltaTime &tdt) const {

  tm x;

  makeTm(*this, &x);

  int ms = m_msec - tdt.getMilliSeconds();

  if (ms < 0) {

    ms += 1000;

    x.tm_sec -= tdt.getSeconds() + 1;

  } else

    x.tm_sec -= tdt.getSeconds() + ms / 1000;

  mktime(&x);

  return makeTTime(x, ms % 1000);

}

//-----------------------------------------------------------------------------------

string TTime::getFormattedString(char *fmt) const {

  tm x;

  makeTm(*this, &x);

  char strDest[256];

  if (!fmt)

    // fmt="%b %d %Y %X";

    return getDate() + " " + getTime();

  strftime(strDest, 256, fmt, &x);

  return string(strDest);

}

//-----------------------------------------------------------------------------------

string TTime::getDate() const { return getFormattedString("%b %d %Y"); }

//-----------------------------------------------------------------------------------

string TTime::getTime() const {  // hh:mm:ss

  char buffer[10];

  ostrstream buff_s(buffer, sizeof(buffer));

  buff_s << "." << m_msec << '\0';

  return getFormattedString("%X") + buffer;

}

//-----------------------------------------------------------------------------------

TTime TTime::floor() const {

  return TTime(m_y, m_m, m_d, m_h, m_min, m_sec, 0);

}

//-----------------------------------------------------------------------------------

TTime TTime::ceil() const {

  if (m_msec == 0)

    return *this;

  else

    return *this + TDeltaTime(0, 1000 - m_msec);

}

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

TFileStatus::TFileStatus(const TFilePath &path) {

  int acc = ACCESS(path.getFullPath().c_str(), 00);  // 00 == solo esistenza

  m_exist = acc != -1;

  // gestire eccezioni controllando il valore di ritorno di access

  // controllare il valore di errno

  // int ret=

  STAT(path.getFullPath().c_str(),

       &m_fStatus);  // returns 0 if the file-status information is obtained

  /* if(ret!=0) ::memset(&m_fStatus,0,sizeof(m_fStatus)):*/

}

//-----------------------------------------------------------------------------------

string TFileStatus::getGroup() const {

#ifndef WIN32

  struct group *grp = getgrgid(m_fStatus.st_gid);

  if (grp) return string(grp->gr_name);

#endif

  char buffer[1024];

  ostrstream buff(buffer, sizeof(buffer));

  buff << m_fStatus.st_gid;

  return string(buffer, buff.pcount());

}

//-----------------------------------------------------------------------------------

string TFileStatus::getUser() const {

#ifndef WIN32

  struct passwd *pw = getpwuid(m_fStatus.st_uid);

  if (pw) return string(pw->pw_name);

#endif

  char buffer[1024];

  ostrstream buff(buffer, sizeof(buffer));

  buff << m_fStatus.st_uid;

  return string(buffer, buff.pcount());

}

//-----------------------------------------------------------------------------------

long TFileStatus::getSize() const { return (long)m_fStatus.st_size; }

//-----------------------------------------------------------------------------------

TTime TFileStatus::getLastAccessTime() const {

  struct tm *t = localtime(&(m_fStatus.st_atime));

  return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

               t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

TTime TFileStatus::getLastModificationTime() const {

  struct tm *t = localtime(&(m_fStatus.st_mtime));

  return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

               t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

TTime TFileStatus::getCreationTime() const {

  struct tm *t = localtime(&(m_fStatus.st_ctime));

  return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

               t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

unsigned long TFileStatus::getPermissions() const { return m_fStatus.st_mode; }

//-----------------------------------------------------------------------------------

bool TFileStatus::isDirectory() const {

  return doesExist() && (getPermissions() & TFileStatus::IfDir) != 0;

}

//-----------------------------------------------------------------------------------

string TSystem::getHostName() {

  char hostName[MaxHostNameLen];

#ifdef WIN32

  WSADATA wdata;

  int err;

  err = WSAStartup(MAKEWORD(1, 1), &wdata);

  if (!err) strcpy(hostName, "localhost");  // la rete non e' partita  ?!?

#endif

  gethostname((char *)&hostName, MaxHostNameLen);

#ifdef WIN32

  if (err) WSACleanup();

#endif

  return hostName;

}

//------------------------------------------------------------

string TSystem::getUserName() {

#ifdef WIN32

#ifndef UNLEN

#define UNLEN (256)

#endif

  const long bufSize = UNLEN;

#else

  const long bufSize                                 = L_cuserid;

#endif

  char userName[bufSize + 1];

#ifdef WIN32

  GetUserName((char *)&userName, (unsigned long *)(&bufSize));

#else

  cuserid(userName);

  if (userName[0] == 0x00) strcpy(userName, "User Unknown");

#endif

  return string(userName);

}

//------------------------------------------------------------

string TSystem::getGroupName() {

#ifdef WIN32

  return string();

#else

  struct group *currentGroup;

  currentGroup = getgrgid(getgid());

  if (currentGroup)

    return string(currentGroup->gr_name);

  else

    return string();

#endif

}

//------------------------------------------------------------

int TSystem::getProcessId() { return getpid(); }

//------------------------------------------------------------

TFilePath TSystem::getHomeDirectory() {

#ifndef WIN32

  struct passwd *pwd = getpwnam(getUserName().c_str());

  if (!pwd) {

    return TFilePath();

  }

  return TFilePath(pwd->pw_dir);

#else

  char *s = getenv("USERPROFILE");

  if (!s)

    return TFilePath();

  else

    return TFilePath(s);

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getTempDir() {

#ifdef WIN32

  // gestire eccezioni se dw==0

  DWORD dw   = GetTempPath(0, 0);  // non include il terminatore

  char *path = new char[dw + 1];

  GetTempPath(dw, path);

  TFilePath tempDir(path);

  delete[] path;

  return tempDir;

#else

  return TFilePath(tmpnam(0)).getParentDir();

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getTestDir() {

#ifdef WIN32

  return TFilePath("\\\\sirio\\toonz5.0\\TNZCORE_TEST");

#else

  return TFilePath("/ULTRA/toonz5.0/TNZCORE_TEST");

#endif

}

//------------------------------------------------------------

string TSystem::getSystemValue(const TFilePath &name) {

#ifdef WIN32

  string keyName = name.getParentDir().getFullPath();

  string varName = name.getName();

  HKEY hkey;

  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName.c_str(), 0, KEY_READ, &hkey) !=

      ERROR_SUCCESS) {

    /*key not defined*/

    return "";

  }

  unsigned char buffer[1024];

  unsigned long bufferSize = sizeof(buffer);

  string value;

  if (RegQueryValueEx(hkey, varName.c_str(), NULL, NULL, buffer, &bufferSize) ==

      ERROR_SUCCESS)

    value = string((char *)buffer);

  RegCloseKey(hkey);

  return value;

#else

  char *s = getenv(name.getFullPath().c_str());

  return string(s ? s : "");

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getBinDir() {

#ifdef WIN32

  char buf[MaxPathLen];

  GetModuleFileName(0, buf, MaxPathLen);

  return TFilePath(buf).getParentDir();

#else

  string binroot = TSystem::getSystemValue("BINROOT");

  if (binroot == "") {

    assert(!"BINROOT variable undefined");

  }

  return TFilePath(binroot) + "bin";

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getUniqueFile(string field) {

  char *tempName = TEMPNAM(getTempDir().getFullPath().c_str(), field.c_str());

  if (tempName == 0)

    throw TSystemException(TFilePath(getTempDir().getFullPath() + field), 1);

  TFilePath outPath(tempName);

  free(tempName);

  return outPath;

}

//------------------------------------------------------------

const TDeltaTime TDeltaTime::second = TDeltaTime(1, 0);

const TDeltaTime TDeltaTime::minute = 60 * TDeltaTime::second;

const TDeltaTime TDeltaTime::hour   = 60 * TDeltaTime::minute;

const TDeltaTime TDeltaTime::day    = 24 * TDeltaTime::hour;

//------------------------------------------------------------

TTime TSystem::getCurrentTime() {

#ifdef WIN32

  struct _timeb curTime;

#else

  struct timeb curTime;

#endif

  FTIME(&curTime);

  struct tm *localTime = localtime(&(curTime.time));

  return TTime(localTime->tm_year + 1900, localTime->tm_mon + 1,

               localTime->tm_mday, localTime->tm_hour, localTime->tm_min,

               localTime->tm_sec, curTime.millitm);

}

//------------------------------------------------------------

// gestire exception

void TSystem::mkDir(const TFilePath &path) {

  if (path == "") {

    throw TSystemException("mkdir: Empty argument");

  }

  if (TFileStatus(path).doesExist() || path.isRoot()) return;

  while (!TFileStatus(path.getParentDir()).doesExist() &&

         !path.getParentDir().isRoot()) {

    mkDir(path.getParentDir());

  }

#ifdef WIN32

  int ret = MKDIR(path.getFullPath().c_str());  // ret e' EEXIST o ENOENT

#else

  umask(0);

  mode_t attr = TFileStatus::UserReadable | TFileStatus::UserWritable |

                TFileStatus::UserExecutable | TFileStatus::OwnerReadWriteExec |

                TFileStatus::GroupReadWriteExec |

                TFileStatus::OtherReadWriteExec;

  int ret = MKDIR(path.getFullPath().c_str(), attr);  // ret e` EEXIST o ENOENT

#endif

  if (ret == -1) throw TSystemException(path, errno);

}

//------------------------------------------------------------

// gestire exception

void TSystem::rmDir(const TFilePath &path) {

  //  if (!TFileStatus(path).doesExist())

  //	return;

  int ret = RMDIR(path.getFullPath().c_str());

  if (ret == -1)  // ret e' ENOTEMPTY o ENOENT

    throw TSystemException(path, errno);

}

//------------------------------------------------------------

void TSystem::rmDirTree(const TFilePath &path) {

  TFilePathSet pathSet = readDirectory(path);

  for (TFilePathSet::iterator it = pathSet.begin(); it != pathSet.end(); it++) {

    TFilePath path = *it;

    if (TFileStatus(path).isDirectory())

      rmDirTree(path);

    else

      deleteFile(path);

  }

  rmDir(path);

}

//------------------------------------------------------------

void TSystem::copyDir(const TFilePath &dst, const TFilePath &src) {

  if (!TFileStatus(dst).doesExist()) mkDir(dst);

  TFilePathSet pathSet = readDirectory(src);

  for (TFilePathSet::iterator it = pathSet.begin(); it != pathSet.end(); it++) {

    TFilePath path = *it;

    if (TFileStatus(path).isDirectory())

      copyDir(path.withParentDir(dst), path);

    else

      copyFile(path.withParentDir(dst), path);

  }

}

//------------------------------------------------------------

void TSystem::touchFile(const TFilePath &path) {

  string filename = path.getFullPath();

  if (TFileStatus(path).doesExist()) {

    if (0 != UTIME(filename.c_str(), 0)) throw TSystemException(path, errno);

  } else {

    ofstream file(filename.c_str());

    if (!file) {

      throw TSystemException(path, errno);

    }

    file.close();  // altrimenti il compilatore da' un warning:

                   // variabile non utilizzata

  }

}

//------------------------------------------------------------

#ifdef WIN32

namespace {

//------------------------------------------------------------

string getFormattedMessage(DWORD lastError) {

  LPVOID lpMsgBuf;

  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |

                    FORMAT_MESSAGE_IGNORE_INSERTS,

                NULL, lastError,

                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  // Default language

                (LPTSTR)&lpMsgBuf, 0, NULL);

  return (char *)lpMsgBuf;

}

//------------------------------------------------------------

}  // namespace

#endif

//------------------------------------------------------------

void TSystem::copyFile(const TFilePath &dst, const TFilePath &src) {

  assert(dst != src);

#ifdef WIN32

  // o e' meglio usare CopyFileEx??

  BOOL res = CopyFile(

      src.getFullPath().c_str(),  // pointer to name of an existing file

      dst.getFullPath().c_str(),  // pointer to filename to copy to

      TRUE);                      // flag for operation if file exists

  if (res == 0) {

    throw TSystemException(src, getFormattedMessage(GetLastError()));

  }

#else

  ifstream fpin(src.getFullPath().c_str(), ios::in);

  ofstream fpout(dst.getFullPath().c_str(), ios::out);

  if (!fpin || !fpout) throw TSystemException(src, "unable to copy file");

  int c = fpin.get();

  while (!fpin.eof()) {

    fpout.put(c);

    c = fpin.get();

  }

#endif

}

//------------------------------------------------------------

void TSystem::renameFile(const TFilePath &dst, const TFilePath &src) {

  int ret = rename(src.getFullPath().c_str(), dst.getFullPath().c_str());

  if (ret != 0) throw TSystemException(dst, errno);

}

//------------------------------------------------------------

// gestire gli errori con GetLastError?

void TSystem::deleteFile(const TFilePath &dst) {

#ifdef WIN32

  BOOL res = DeleteFile(

      dst.getFullPath().c_str());  // pointer to name of file to delete

  // se fallisce perche' un file e' aperto chiudiamo prima il file?

  // To close an open file, use the CloseHandle function.

  if (res == 0)

    throw TSystemException(dst, getFormattedMessage(GetLastError()));

#else

  int ret = remove(dst.getFullPath().c_str());

  if (ret != 0) throw TSystemException(dst, errno);

#endif

}

//------------------------------------------------------------

void TSystem::moveFileToRecycleBin(const TFilePath &fp) {

#ifdef WIN32

  //

  // from http://msdn.microsoft.com/msdnmag/issues/01/04/c/default.aspx

  //

  // Copy pathname to double-NULL-terminated string.

  //

  char buf[_MAX_PATH + 1];                // allow one more character

  strcpy(buf, fp.getFullPath().c_str());  // copy caller's path name

  buf[strlen(buf) + 1] = 0;               // need two NULLs at end

  SHFILEOPSTRUCT data;

  memset(&data, 0, sizeof(SHFILEOPSTRUCT));

  data.fFlags |= FOF_SILENT;          // don't report progress

  data.fFlags |= FOF_NOERRORUI;       // don't report errors

  data.fFlags |= FOF_NOCONFIRMATION;  // don't confirm delete

  data.wFunc = FO_DELETE;        // REQUIRED: delete operation

  data.pFrom = buf;              // REQUIRED: which file(s)

  data.pTo   = NULL;             // MUST be NULL

  data.fFlags |= FOF_ALLOWUNDO;  // ..send to Recycle Bin

  SHFileOperation(&data);        // do it!

#else

  assert(!"Not implemented yet");

#endif

}

//------------------------------------------------------------

void TSystem::readDirectory(TFilePathSet &dst, const TFilePath &path) {

  if (!TFileStatus(path).isDirectory()) {

    throw TSystemException(path, " is not a directory");

  }

#ifdef WIN32

  WIN32_FIND_DATA findFileData;

  string search = (path + "*").getFullPath();

  HANDLE h      = FindFirstFile(search.c_str(), &findFileData);

  if (h == INVALID_HANDLE_VALUE)

    throw TSystemException(path, getFormattedMessage(GetLastError()));

  do {

    string filename(findFileData.cFileName);

    if (filename == "." || filename == "..") continue;

    TFilePath son = path + filename;

    dst.push_back(son);

  } while (FindNextFile(h, &findFileData));

  FindClose(h);