////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1996-2022 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <cstdlib>
#include <locale>
#include <codecvt>

#include "dir-ops.h"
#include "file-ops.h"
#include "lo-error.h"
#include "lo-sysdep.h"
#include "localcharset-wrapper.h"
#include "putenv-wrapper.h"
#include "unistd-wrappers.h"
#include "unsetenv-wrapper.h"

#if defined (OCTAVE_USE_WINDOWS_API)
#  include <windows.h>
#  include <wchar.h>

#  include "filepos-wrappers.h"
#  include "lo-hash.h"
#  include "oct-locbuf.h"
#  include "uniconv-wrappers.h"
#  include "unwind-prot.h"
#endif

OCTAVE_BEGIN_NAMESPACE(octave)

OCTAVE_BEGIN_NAMESPACE(sys)

    int
    system (const std::string& cmd_str)
    {
#if defined (OCTAVE_USE_WINDOWS_API)
      const std::wstring wcmd_str =  u8_to_wstring (cmd_str);

      return _wsystem (wcmd_str.c_str ());
#else
      return ::system (cmd_str.c_str ());
#endif
    }

    std::string
    getcwd (void)
    {
      std::string retval;

#if defined (OCTAVE_USE_WINDOWS_API)
      wchar_t *tmp = _wgetcwd (nullptr, 0);

      if (! tmp)
        (*current_liboctave_error_handler) ("unable to find current directory");

      std::wstring tmp_wstr (tmp);
      free (tmp);

      std::string tmp_str = u8_from_wstring (tmp_wstr);

      retval = tmp_str;

#else
      // Using octave_getcwd_wrapper ensures that we have a getcwd that
      // will allocate a buffer as large as necessary if buf and size are
      // both 0.

      char *tmp = octave_getcwd_wrapper (nullptr, 0);

      if (! tmp)
        (*current_liboctave_error_handler) ("unable to find current directory");

      retval = tmp;
      free (tmp);
#endif

      return retval;
    }

    int
    chdir (const std::string& path_arg)
    {
      std::string path = sys::file_ops::tilde_expand (path_arg);

#if defined (OCTAVE_USE_WINDOWS_API)
      if (path.length () == 2 && path[1] == ':')
        path += '\\';
#endif

      return octave_chdir_wrapper (path.c_str ());
    }

    bool
    get_dirlist (const std::string& dirname, string_vector& dirlist,
                 std::string& msg)
    {
      dirlist = "";
      msg = "";
#if defined (OCTAVE_USE_WINDOWS_API)
      _WIN32_FIND_DATAW ffd;

      std::string path_name (dirname);
      if (path_name.empty ())
        return true;

      if (path_name.back () == '\\' || path_name.back () == '/')
        path_name.push_back ('*');
      else
        path_name.append (R"(\*)");

      // Find first file in directory.
      std::wstring wpath_name = u8_to_wstring (path_name);
      HANDLE hFind = FindFirstFileW (wpath_name.c_str (), &ffd);
      if (INVALID_HANDLE_VALUE == hFind)
        {
          DWORD errCode = GetLastError ();
          char *errorText = nullptr;
          FormatMessageA (FORMAT_MESSAGE_FROM_SYSTEM |
                          FORMAT_MESSAGE_ALLOCATE_BUFFER |
                          FORMAT_MESSAGE_IGNORE_INSERTS,
                          nullptr, errCode,
                          MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                          reinterpret_cast <char *> (&errorText), 0, nullptr);
          if (errorText != nullptr)
            {
              msg = std::string (errorText);
              LocalFree (errorText);
            }
          return false;
        }

      std::list<std::string> dirlist_str;
      do
        dirlist_str.push_back (u8_from_wstring (ffd.cFileName));
      while (FindNextFileW (hFind, &ffd) != 0);

      FindClose(hFind);

      dirlist = string_vector (dirlist_str);

#else

      dir_entry dir (dirname);

      if (! dir)
        {
          msg = dir.error ();
          return false;
        }

      dirlist = dir.read ();

      dir.close ();
#endif

      return true;
    }

#if defined (OCTAVE_USE_WINDOWS_API)

    static bool check_fseek_ftell_workaround_needed (bool set_nonbuffered_mode)
    {
      // To check whether the workaround is needed:
      //
      //   * Create a tmp file with LF line endings only.
      //
      //   * Open that file for reading in text mode.
      //
      //   * Read a line.
      //
      //   * Use ftello to record the position of the beginning of the
      //     second line.
      //
      //   * Read and save the contents of the second line.
      //
      //   * Use fseeko to return to the saved position.
      //
      //   * Read the second line again and compare to the previously
      //     saved text.
      //
      //   * If the lines are different, we need to set non-buffered
      //     input mode for files opened in text mode.

      std::string tmpname = sys::tempnam ("", "oct-");

      if (tmpname.empty ())
        {
          (*current_liboctave_warning_handler)
            ("fseek/ftell bug check failed (tmp name creation)!");
          return false;
        }

      std::FILE *fptr = std::fopen (tmpname.c_str (), "wb");

      if (! fptr)
        {
          (*current_liboctave_warning_handler)
            ("fseek/ftell bug check failed (opening tmp file for writing)!");
          return false;
        }

      fprintf (fptr, "%s", "foo\nbar\nbaz\n");

      std::fclose (fptr);

      fptr = std::fopen (tmpname.c_str (), "rt");

      if (! fptr)
        {
          (*current_liboctave_warning_handler)
            ("fseek/ftell bug check failed (opening tmp file for reading)!");
          return false;
        }

      unwind_action act ([=] ()
                         {
                           std::fclose (fptr);
                           sys::unlink (tmpname);
                         });

      if (set_nonbuffered_mode)
        ::setvbuf (fptr, nullptr, _IONBF, 0);

      while (true)
        {
          int c = fgetc (fptr);

          if (c == EOF)
            {
              (*current_liboctave_warning_handler)
                ("fseek/ftell bug check failed (skipping first line)!");
              return false;
            }

          if (c == '\n')
            break;
        }

      off_t pos = octave_ftello_wrapper (fptr);

      char buf1[8];
      int i = 0;
      while (true)
        {
          int c = fgetc (fptr);

          if (c == EOF)
            {
              (*current_liboctave_warning_handler)
                ("fseek/ftell bug check failed (reading second line)!");
              return false;
            }

          if (c == '\n')
            break;

          buf1[i++] = static_cast<char> (c);
        }
      buf1[i] = '\0';

      octave_fseeko_wrapper (fptr, pos, SEEK_SET);

      char buf2[8];
      i = 0;
      while (true)
        {
          int c = fgetc (fptr);

          if (c == EOF)
            {
              (*current_liboctave_warning_handler)
                ("fseek/ftell bug check failed (reading after repositioning)!");
              return false;
            }

          if (c == '\n')
            break;

          buf2[i++] = static_cast<char> (c);
        }
      buf2[i] = '\0';

      return strcmp (buf1, buf2);
    }

#endif

    std::FILE *
    fopen (const std::string& filename, const std::string& mode)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      std::wstring wfilename = u8_to_wstring (filename);
      std::wstring wmode = u8_to_wstring (mode);

      std::FILE *fptr = _wfopen (wfilename.c_str (), wmode.c_str ());

      static bool fseek_ftell_bug_workaround_needed = false;
      static bool fseek_ftell_bug_checked = false;

      if (! fseek_ftell_bug_checked && mode.find ('t') != std::string::npos)
        {
          // FIXME: Is the following workaround needed for all files
          // opened in text mode, or only for files opened for reading?

          // Try to avoid fseek/ftell bug on Windows systems by setting
          // non-buffered input mode for files opened in text mode, but
          // only if it appears that the workaround is needed.  See
          // Octave bug #58055.

          // To check whether the workaround is needed:
          //
          //   * Create a tmp file with LF line endings only.
          //
          //   * Open that file for reading in text mode.
          //
          //   * Read a line.
          //
          //   * Use ftello to record the position of the beginning of
          //     the second line.
          //
          //   * Read and save the contents of the second line.
          //
          //   * Use fseeko to return to the saved position.
          //
          //   * Read the second line again and compare to the
          //     previously saved text.
          //
          //   * If the lines are different, we need to set non-buffered
          //     input mode for files opened in text mode.
          //
          //   * To verify that the workaround solves the problem,
          //     repeat the above test with non-buffered input mode.  If
          //     that fails, warn that there may be trouble with
          //     ftell/fseek when reading files opened in text mode.

          if (check_fseek_ftell_workaround_needed (false))
            {
              if (check_fseek_ftell_workaround_needed (true))
                (*current_liboctave_warning_handler)
                  ("fseek/ftell may fail for files opened in text mode");
              else
                fseek_ftell_bug_workaround_needed = true;
            }

          fseek_ftell_bug_checked = true;
        }

      if (fseek_ftell_bug_workaround_needed
          && mode.find ('t') != std::string::npos)
        ::setvbuf (fptr, nullptr, _IONBF, 0);

      return fptr;

#else
      return std::fopen (filename.c_str (), mode.c_str ());
#endif
    }

    std::FILE *
    fopen_tmp (const std::string& name, const std::string& mode)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      // Append "D" to the mode string to indicate that this is a temporary
      // file that should be deleted when the last open handle is closed.
      std::string tmp_mode = mode + "D";

      return std::fopen (name.c_str (), tmp_mode.c_str ());

#else

      std::FILE *fptr = std::fopen (name.c_str (), mode.c_str ());

      // From gnulib: This relies on the Unix semantics that a file is not
      // really removed until it is closed.
      octave_unlink_wrapper (name.c_str ());

      return fptr;

#endif
    }

    std::fstream
    fstream (const std::string& filename, const std::ios::openmode mode)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      std::wstring wfilename = u8_to_wstring (filename);

      return std::fstream (wfilename.c_str (), mode);

#else
      return std::fstream (filename.c_str (), mode);
#endif
    }

    std::ifstream
    ifstream (const std::string& filename, const std::ios::openmode mode)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      std::wstring wfilename = u8_to_wstring (filename);

      return std::ifstream (wfilename.c_str (), mode);

#else
      return std::ifstream (filename.c_str (), mode);
#endif
    }

    std::ofstream
    ofstream (const std::string& filename, const std::ios::openmode mode)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      std::wstring wfilename = u8_to_wstring (filename);

      return std::ofstream (wfilename.c_str (), mode);

#else
      return std::ofstream (filename.c_str (), mode);
#endif
    }

    void
    putenv_wrapper (const std::string& name, const std::string& value)
    {
      std::string new_env = name + "=" + value;

      // FIXME: The malloc leaks memory, but so would a call to setenv.
      // Short of extreme measures to track memory, altering the environment
      // always leaks memory, but the saving grace is that the leaks are small.

      // As far as I can see there's no way to distinguish between the
      // various errors; putenv doesn't have errno values.

#if defined (OCTAVE_USE_WINDOWS_API)
      std::wstring new_wenv = u8_to_wstring (new_env);

      int len = (new_wenv.length () + 1) * sizeof (wchar_t);

      wchar_t *new_item = static_cast<wchar_t *> (std::malloc (len));

      wcscpy (new_item, new_wenv.c_str());

      if (_wputenv (new_item) < 0)
        (*current_liboctave_error_handler)
          ("putenv (%s) failed", new_env.c_str());
#else
      int len = new_env.length () + 1;

      char *new_item = static_cast<char *> (std::malloc (len));

      std::strcpy (new_item, new_env.c_str());

      if (octave_putenv_wrapper (new_item) < 0)
        (*current_liboctave_error_handler) ("putenv (%s) failed", new_item);
#endif
    }

    std::string
    getenv_wrapper (const std::string& name)
    {
#if defined (OCTAVE_USE_WINDOWS_API)
      std::wstring wname = u8_to_wstring (name);
      wchar_t *env = _wgetenv (wname.c_str ());
      return env ? u8_from_wstring (env) : "";
#else
      char *env = ::getenv (name.c_str ());
      return env ? env : "";
#endif
    }

    int
    unsetenv_wrapper (const std::string& name)
    {
#if defined (OCTAVE_USE_WINDOWS_API)
      putenv_wrapper (name, "");

      std::wstring wname = u8_to_wstring (name);
      return (SetEnvironmentVariableW (wname.c_str (), nullptr) ? 0 : -1);
#else
      return octave_unsetenv_wrapper (name.c_str ());
#endif
    }

    std::wstring
    u8_to_wstring (const std::string& utf8_string)
    {
      // convert multibyte UTF-8 string to wide character string
      static std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>
        wchar_conv;

      std::wstring retval = L"";

      try
        {
          retval = wchar_conv.from_bytes (utf8_string);
        }
      catch (const std::range_error& e)
        {
          // What to do in case of error?
          // error ("u8_to_wstring: converting from UTF-8 to wchar_t: %s",
          //        e.what ());
        }

      return retval;
    }

    std::string
    u8_from_wstring (const std::wstring& wchar_string)
    {
      // convert wide character string to multibyte UTF-8 string
      static std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>
        wchar_conv;

      std::string retval = "";

      try
        {
          retval = wchar_conv.to_bytes (wchar_string);
        }
      catch (const std::range_error& e)
        {
          // What to do in case of error?
          // error ("u8_from_wstring: converting from wchar_t to UTF-8: %s",
          //        e.what ());
        }

      return retval;
    }

    // At quite a few places in the code we are passing file names as
    // char arrays to external library functions.

    // When these functions try to locate the corresponding file on the
    // disc, they need to use the wide character API on Windows to
    // correctly open files with non-ASCII characters.

    // But they have no way of knowing which encoding we are using for
    // the passed string.  So they have no way of reliably converting to
    // a wchar_t array.  (I.e. there is no possible fix for these
    // functions with current C or C++.)

    // To solve the dilemma, the function "get_ASCII_filename" first
    // checks whether there are any non-ASCII characters in the passed
    // file name.  If there are not, it returns the original name.

    // Otherwise, it optionally tries to convert the file name to the locale
    // charset.

    // If the file name contains characters that cannot be converted to the
    // locale charset (or that step is skipped), it tries to obtain the short
    // file name (8.3 naming scheme) which only consists of ASCII characters
    // and are safe to pass.  However, short file names can be disabled for
    // performance reasons on the file system level with NTFS and they are not
    // stored on other file systems (e.g. ExFAT).  So there is no guarantee
    // that these exist.

    // If short file names are not stored, a hard link to the file is
    // created.  For this the path to the file is split at the deepest
    // possible level that doesn't contain non-ASCII characters.  At
    // that level a hidden folder is created that holds the hard links.
    // That means we need to have write access on that location.  A path
    // to that hard link is returned.

    // If the file system is FAT32, there are no hard links.  But FAT32
    // always stores short file names.  So we are safe.

    // ExFAT that is occasionally used on USB sticks and SD cards stores
    // neither short file names nor does it support hard links.  So for
    // exFAT with this function, there is (currently) no way to generate
    // a file name that is stripped from non-ASCII characters but still
    // is valid.

    // For Unixy systems, this function does nothing.

    std::string
    get_ASCII_filename (const std::string& orig_file_name,
                        const bool allow_locale)
    {
#if defined (OCTAVE_USE_WINDOWS_API)

      // Return file name that only contains ASCII characters that can
      // be used to access the file orig_file_name.  The original file
      // must exist in the file system before calling this function.
      // This is useful for passing file names to functions that are not
      // aware of the character encoding we are using.

      // 0. Check whether filename contains non-ASCII (UTF-8) characters.

      std::string::const_iterator first_non_ASCII
        = std::find_if (orig_file_name.begin (), orig_file_name.end (),
                        [](char c) { return (c < 0 || c >= 128); });

      if (first_non_ASCII == orig_file_name.end ())
        return orig_file_name;

      // 1. Optionally, check if all characters in the path can be successfully
      // converted to the locale charset
      if (allow_locale)
        {
          const char *locale = octave_locale_charset_wrapper ();
          if (locale)
            {
              const uint8_t *name_u8 = reinterpret_cast<const uint8_t *>
                                         (orig_file_name.c_str ());
              std::size_t length = 0;
              char *name_locale = octave_u8_conv_to_encoding_strict
                                    (locale, name_u8,
                                     orig_file_name.length () + 1, &length);
              if (name_locale)
                {
                  std::string file_name_locale (name_locale, length);
                  free (name_locale);
                  return file_name_locale;
                }
            }
        }

      // 2. Check if file system stores short filenames (might be ASCII-only).

      std::wstring w_orig_file_name_str = u8_to_wstring (orig_file_name);
      const wchar_t *w_orig_file_name = w_orig_file_name_str.c_str ();

      // Get full path to file
      wchar_t w_full_file_name[_MAX_PATH];
      if (_wfullpath (w_full_file_name, w_orig_file_name, _MAX_PATH) == nullptr)
        return orig_file_name;

      std::wstring w_full_file_name_str = w_full_file_name;

      // Get short filename (8.3) from UTF-16 filename.

      long length = GetShortPathNameW (w_full_file_name, nullptr, 0);

      if (length > 0)
        {
          // Dynamically allocate the correct size (terminating null char
          // was included in length).

          OCTAVE_LOCAL_BUFFER (wchar_t, w_short_file_name, length);
          GetShortPathNameW (w_full_file_name, w_short_file_name, length);

          std::wstring w_short_file_name_str
            = std::wstring (w_short_file_name, length);

          if (w_short_file_name_str.compare (0, length-1, w_full_file_name_str) != 0)
            {
              // Check whether short file name contains non-ASCII characters
              std::string short_file_name
                = u8_from_wstring (w_short_file_name_str);
              first_non_ASCII
                = std::find_if (short_file_name.begin (),
                                short_file_name.end (),
                                [](char c) { return (c < 0 || c >= 128); });
              if (first_non_ASCII == short_file_name.end ())
                return short_file_name;
            }
        }

      // 3. Create hard link with only-ASCII characters.
      // Get longest possible part of path that only contains ASCII chars.

      std::wstring::iterator w_first_non_ASCII
        = std::find_if (w_full_file_name_str.begin (), w_full_file_name_str.end (),
                        [](wchar_t c) { return (c < 0 || c >= 128); });
      std::wstring tmp_substr
        = std::wstring (w_full_file_name_str.begin (), w_first_non_ASCII);

      std::size_t pos
        = tmp_substr.find_last_of (u8_to_wstring (file_ops::dir_sep_chars ()));

      std::string par_dir
        = u8_from_wstring (w_full_file_name_str.substr (0, pos+1));

      // Create .oct_ascii directory.
      // FIXME: We need to have write permission in this location.

      std::string oct_ascii_dir = par_dir + ".oct_ascii";
      std::string test_dir = canonicalize_file_name (oct_ascii_dir);

      if (test_dir.empty ())
        {
          std::string msg;
          int status = sys::mkdir (oct_ascii_dir, 0777, msg);

          if (status < 0)
            return orig_file_name;

          // Set hidden property.
          SetFileAttributesA (oct_ascii_dir.c_str (), FILE_ATTRIBUTE_HIDDEN);
        }

      // Create file from hash of full filename.
      std::string filename_hash
        = (oct_ascii_dir + file_ops::dir_sep_str ()
           + crypto::hash ("SHA1", orig_file_name));

      // FIXME: This is just to check if the file exists.  Use a more efficient
      // method.
      std::string abs_filename_hash = canonicalize_file_name (filename_hash);

      if (! abs_filename_hash.empty ())
        sys::unlink (filename_hash);

      // At this point, we know that we have only ASCII characters.
      // So instead of converting, just copy the characters to std::wstring.
      std::wstring w_filename_hash (filename_hash.begin (),
                                    filename_hash.end ());

      if (CreateHardLinkW (w_filename_hash.c_str (), w_orig_file_name, nullptr))
        return filename_hash;

#else

      octave_unused_parameter (allow_locale);

#endif

      return orig_file_name;
    }

OCTAVE_END_NAMESPACE(sys)
OCTAVE_END_NAMESPACE(octave)