#include <stdlib.h>

#include <ctype.h>

#if defined(_WIN32) && !defined(__CYGWIN__)

#undef UNICODE

#define _WIN32_DCOM

#include <windows.h>

#else

#include <unistd.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <errno.h>

extern char **environ;

#endif

#include <qglobal.h>

#include <qdatetime.h>

#if defined(_MSC_VER) || defined(__BORLANDC__)

#define popen _popen

#define pclose _pclose

#endif

#include "portable.h"

#ifndef NODEBUG

#include "debug.h"

#endif

//#include "doxygen.h"

static double  g_sysElapsedTime;

static QTime   g_time;

int portable_system(const char *command,const char *args,bool commandHasConsole)

{

  if (command==0) return 1;

  QCString fullCmd=command;

  fullCmd=fullCmd.stripWhiteSpace();

  if (fullCmd.at(0)!='"' && fullCmd.find(' ')!=-1)

  {

    // add quotes around command as it contains spaces and is not quoted already

    fullCmd="\""+fullCmd+"\"";

  }

  fullCmd += " ";

  fullCmd += args;

#ifndef NODEBUG

  Debug::print(Debug::ExtCmd,0,"Executing external command `%s`\n",qPrint(fullCmd));

#endif

#if !defined(_WIN32) || defined(__CYGWIN__)

  (void)commandHasConsole;

  /*! taken from the system() manpage on my Linux box */

  int pid,status=0;

#ifdef _OS_SOLARIS // for Solaris we use vfork since it is more memory efficient

  // on Solaris fork() duplicates the memory usage

  // so we use vfork instead

  // spawn shell

  if ((pid=vfork())<0)

  {

    status=-1;

  }

  else if (pid==0)

  {

     execl("/bin/sh","sh","-c",fullCmd.data(),(char*)0);

     _exit(127);

  }

  else

  {

    while (waitpid(pid,&status,0 )<0)

    {

      if (errno!=EINTR)

      {

        status=-1;

        break;

      }

    }

  }

  return status;

#else  // Other Unices just use fork

  pid = fork();

  if (pid==-1)

  {

    perror("fork error");

	  return -1;

  }

  if (pid==0)

  {

    const char * argv[4];

    argv[0] = "sh";

    argv[1] = "-c";

    argv[2] = fullCmd.data();

    argv[3] = 0;

    execve("/bin/sh",(char * const *)argv,environ);

    exit(127);

  }

  for (;;)

  {

    if (waitpid(pid,&status,0)==-1)

    {

      if (errno!=EINTR) return -1;

    }

    else

    {

      if (WIFEXITED(status))

      {

        return WEXITSTATUS(status);

      }

      else

      {

        return status;

      }

    }

  }

#endif // !_OS_SOLARIS

#else // Win32 specific

  if (commandHasConsole)

  {

    return system(fullCmd);

  }

  else

  {

    // Because ShellExecuteEx can delegate execution to Shell extensions 

    // (data sources, context menu handlers, verb implementations) that 

    // are activated using Component Object Model (COM), COM should be 

    // initialized before ShellExecuteEx is called. Some Shell extensions 

    // require the COM single-threaded apartment (STA) type. 

    // For that case COM is initialized as follows

    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);

    QString commandw = QString::fromUtf8( command );

    QString argsw = QString::fromUtf8( args );

    // gswin32 is a GUI api which will pop up a window and run

    // asynchronously. To prevent both, we use ShellExecuteEx and

    // WaitForSingleObject (thanks to Robert Golias for the code)

    SHELLEXECUTEINFOW sInfo = {

      sizeof(SHELLEXECUTEINFOW),   /* structure size */

      SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI,  /* tell us the process

                                                       *  handle so we can wait till it's done | 

                                                       *  do not display msg box if error 

                                                       */

      NULL,                       /* window handle */

      NULL,                       /* action to perform: open */

      (LPCWSTR)commandw.ucs2(),   /* file to execute */

      (LPCWSTR)argsw.ucs2(),      /* argument list */ 

      NULL,                       /* use current working dir */

      SW_HIDE,                    /* minimize on start-up */

      0,                          /* application instance handle */

      NULL,                       /* ignored: id list */

      NULL,                       /* ignored: class name */

      NULL,                       /* ignored: key class */

      0,                          /* ignored: hot key */

      NULL,                       /* ignored: icon */

      NULL                        /* resulting application handle */

    };

    if (!ShellExecuteExW(&sInfo))

    {

      return -1;

    }

    else if (sInfo.hProcess)      /* executable was launched, wait for it to finish */

    {

      WaitForSingleObject(sInfo.hProcess,INFINITE); 

      /* get process exit code */

      DWORD exitCode;

      if (!GetExitCodeProcess(sInfo.hProcess,&exitCode))

      {

        exitCode = -1;

      }

      CloseHandle(sInfo.hProcess);

      return exitCode;

    }

  }

#endif

  return 1; // we should never get here

}

uint portable_pid()

{

  uint pid;

#if !defined(_WIN32) || defined(__CYGWIN__)

  pid = (uint)getpid();

#else

  pid = (uint)GetCurrentProcessId();

#endif

  return pid;

}

#if defined(_WIN32) && !defined(__CYGWIN__)

#else

  static char **last_environ;

#endif

void portable_setenv(const char *name,const char *value)

{

    if (value==0) value="";

#if defined(_WIN32) && !defined(__CYGWIN__)

    SetEnvironmentVariable(name,value);

#else

    register char **ep = 0;

    register size_t size;

    const size_t namelen=qstrlen(name);

    const size_t vallen=qstrlen(value) + 1;

    size = 0;

    if (environ!=0)

    {

      for (ep = environ; *ep; ++ep)

      {

        if (!qstrncmp (*ep, name, (uint)namelen) &&

            (*ep)[namelen] == '=')

          break;

        else

          ++size;

      }

    }

    if (environ==0 || *ep==0) /* add new string */

    {

      char **new_environ;

      if (environ == last_environ && environ!=0)

      {

        // We allocated this space; we can extend it. 

        new_environ = (char **) realloc (last_environ, (size + 2) * sizeof (char *));

      }

      else

      {

        new_environ = (char **) malloc ((size + 2) * sizeof (char *));

      }

      if (new_environ==0) // no more memory 

      {

        return;

      }

      new_environ[size] = (char *)malloc (namelen + 1 + vallen);

      if (new_environ[size]==0)

      {

        free (new_environ);

        return;

      }

      if (environ != last_environ)

      {

        memcpy ((char *) new_environ, environ, size * sizeof (char *));

      }

      memcpy(new_environ[size], name, namelen);

      new_environ[size][namelen] = '=';

      memcpy(&new_environ[size][namelen + 1], value, vallen);

      new_environ[size + 1] = 0;

      last_environ = environ = new_environ;

    }

    else /* replace existing string */

    {

      size_t len = qstrlen (*ep);

      if (len + 1 < namelen + 1 + vallen)

      {

        /* The existing string is too short; malloc a new one.  */

        char *newString = (char *)malloc(namelen + 1 + vallen);

        if (newString==0)

        {

          return;

        }

        *ep = newString;

      }

      memcpy(*ep, name, namelen);

      (*ep)[namelen] = '=';

      memcpy(&(*ep)[namelen + 1], value, vallen);

    }

#endif

}

void portable_unsetenv(const char *variable)

{

#if defined(_WIN32) && !defined(__CYGWIN__)

    SetEnvironmentVariable(variable,0);

#else

    /* Some systems don't have unsetenv(), so we do it ourselves */

    size_t len;

    char **ep;

    if (variable == NULL || *variable == '\0' || strchr (variable, '=') != NULL)

    {

      return; // not properly formatted

    }

    len = qstrlen(variable);

    ep = environ;

    while (*ep != NULL)

    {

      if (!qstrncmp(*ep, variable, (uint)len) && (*ep)[len]=='=')

      {

        /* Found it.  Remove this pointer by moving later ones back.  */

        char **dp = ep;

        do dp[0] = dp[1]; while (*dp++);

        /* Continue the loop in case NAME appears again.  */

      }

      else

      {

        ++ep;

      }

    }

#endif

}

const char *portable_getenv(const char *variable)

{

  return getenv(variable);

}

portable_off_t portable_fseek(FILE *f,portable_off_t offset, int whence)

{

#if defined(__MINGW32__)

  return fseeko64(f,offset,whence);

#elif defined(_WIN32) && !defined(__CYGWIN__)

  return _fseeki64(f,offset,whence);

#else

  return fseeko(f,offset,whence);

#endif

}

portable_off_t portable_ftell(FILE *f)

{

#if defined(__MINGW32__)

  return ftello64(f);  

#elif defined(_WIN32) && !defined(__CYGWIN__)

  return _ftelli64(f);

#else

  return ftello(f);

#endif

}

FILE *portable_fopen(const char *fileName,const char *mode)

{

#if defined(_WIN32) && !defined(__CYGWIN__)

  QString fn(fileName);

  QString m(mode);

  return _wfopen((wchar_t*)fn.ucs2(),(wchar_t*)m.ucs2());

#else

  return fopen(fileName,mode);

#endif

}

char  portable_pathSeparator()

{

#if defined(_WIN32) && !defined(__CYGWIN__)

  return '\\';

#else

  return '/';

#endif

}

char  portable_pathListSeparator()

{

#if defined(_WIN32) && !defined(__CYGWIN__)

  return ';';

#else

  return ':';

#endif

}

const char *portable_ghostScriptCommand()

{

#if defined(_WIN32) && !defined(__CYGWIN__)

    return "gswin32c.exe";

#else

    return "gs";

#endif

}

const char *portable_commandExtension()

{

#if defined(_WIN32) && !defined(__CYGWIN__)

    return ".exe";

#else

    return "";

#endif

}

bool portable_fileSystemIsCaseSensitive()

{

#if defined(_WIN32) || defined(macintosh) || defined(__MACOSX__) || defined(__APPLE__)

  return FALSE;

#else

  return TRUE;

#endif

}

FILE * portable_popen(const char *name,const char *type)

{

  return popen(name,type);

}

int portable_pclose(FILE *stream)

{

  return pclose(stream);

}

void portable_sysTimerStart()

{

  g_time.start();

}

void portable_sysTimerStop()

{

  g_sysElapsedTime+=((double)g_time.elapsed())/1000.0;

}

double portable_getSysElapsedTime()

{

  return g_sysElapsedTime;

}

void portable_sleep(int ms)

{

#if defined(_WIN32) && !defined(__CYGWIN__)

  Sleep(ms);

#else

  usleep(1000*ms);

#endif

}

bool portable_isAbsolutePath(const char *fileName)

{

# ifdef _WIN32

  if (isalpha (fileName [0]) && fileName[1] == ':')

    fileName += 2;

# endif

  char const fst = fileName [0];

  if (fst == '/')  {

    return true;

  }

# ifdef _WIN32

  if (fst == '\\')

    return true;

# endif

  return false;

}

/**

 * Correct a possible wrong PATH variable

 *

 * This routine was inspired by the cause for bug 766059 was that in the Windows path there were forward slahes.

 */

void portable_correct_path(void)

{

#if defined(_WIN32) && !defined(__CYGWIN__)

  const char *p = portable_getenv("PATH");

  char *q = (char *)malloc(strlen(p) + 1);

  strcpy(q, p);

  bool found = false;

  for (int i = 0 ; i < strlen(q); i++)

  {

    if (q[i] == '/')

    {

      q[i] = '\\';

      found = true;

    }

  }

  if (found) portable_setenv("PATH",q);

  free(q);

#endif

}