/*
 * Copyright © 2025 Luca Bacci
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Luca Bacci <luca.bacci@outlook.com>
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>

#include "gtypes.h"
#include "gunicodeprivate.h"
#include "gprintprivate.h"
#include "gprintfint.h"

#ifndef _WIN32
#include <unistd.h>
#else
#include "gwin32private.h"
#include <io.h>
#endif

#define CHAR_IS_SAFE(wc) (!((wc < 0x20 && wc != '\t' && wc != '\n' && wc != '\r') || \
                            (wc == 0x7f) || \
                            (wc >= 0x80 && wc < 0xa0)))

char *
g_print_convert (const char *string,
                 const char *charset)
{
  if (!g_utf8_validate (string, -1, NULL))
    {
      GString *gstring = g_string_new ("[Invalid UTF-8] ");
      guchar *p;

      for (p = (guchar *)string; *p; p++)
        {
          if (CHAR_IS_SAFE(*p) &&
              !(*p == '\r' && *(p + 1) != '\n') &&
              *p < 0x80)
            g_string_append_c (gstring, *p);
          else
            g_string_append_printf (gstring, "\\x%02x", (guint)(guchar)*p);
        }

      return g_string_free (gstring, FALSE);
    }
  else
    {
      GError *err = NULL;

      gchar *result = g_convert_with_fallback (string, -1, charset, "UTF-8", "?", NULL, NULL, &err);
      if (result)
        return result;
      else
        {
          /* Not thread-safe, but doesn't matter if we print the warning twice
           */
          static gboolean warned = FALSE;
          if (!warned)
            {
              warned = TRUE;
              _g_fprintf (stderr, "GLib: Cannot convert message: %s\n", err->message);
            }
          g_error_free (err);

          return g_strdup (string);
        }
    }
}

#ifdef _WIN32

static int
print_console_nolock (const char *string,
                      FILE       *stream)
{
  HANDLE handle = (HANDLE) _get_osfhandle (_fileno (stream));
  size_t size = strlen (string);
  DWORD written = 0;

  if (size > INT_MAX)
    return 0;

  /* WriteFile are WriteConsole are limited to DWORD lengths,
   * but int and DWORD should are of the same size, so we don't
   * care.
   */
  G_STATIC_ASSERT (INT_MAX <= MAXDWORD);

  /* We might also check if the source string is ASCII */
  if (GetConsoleOutputCP () == CP_UTF8)
    {
      /* If the output codepage is UTF-8, we can just call WriteFile,
       * avoiding a conversion to UTF-16 (which probably will be done
       * by ConDrv).
       */
      /* Note: we cannot use fputs() here. When outputting to the
       * console, the UCRT converts the passed string to the console
       * charset, which is UTF-8, but interprets the string in the
       * LC_CTYPE charset, which can be anything.
       */

      if (!WriteFile (handle, string, size, &written, NULL))
        WIN32_API_FAILED ("WriteFile");
    }
  else
    {
      /* Convert to UTF-16 and output using WriteConsole */

      /* Note: we can't use fputws() with mode _O_U16TEXT because:
       *
       * - file descriptors cannot be locked, unlike FILE streams, so
       *   we cannot set a custom mode on the file descriptor.
       * - the fputws() implementation is not very good: it outputs codeunit
       *   by codeunit in a loop, so it's slow [1] and breaks UTF-16 surrogate
       *   pairs [2].
       *
       * [1] https://github.com/microsoft/terminal/issues/18124#issuecomment-2451987873
       * [2] https://developercommunity.visualstudio.com/t/wprintf-with-_setmode-_O_U16TEXT-or-_O_U/10447076
       */

      wchar_t buffer[1024];
      wchar_t *utf16 = NULL;
      size_t utf16_len = 0;
      DWORD utf16_written = 0;

      g_utf8_to_utf16_make_valid (string,
                                  buffer, G_N_ELEMENTS (buffer),
                                  &utf16, &utf16_len);

      /* The length of the UTF-16 string (in count of gunichar2) cannot be
       * greater than the length of the UTF-8 string (in count of bytes).
       * So utf16_len <= size <= INT_MAX <= MAXDWORD.
       */
      g_assert (utf16_len <= size);

      if (!WriteConsole (handle, utf16, utf16_len, &utf16_written, NULL))
        WIN32_API_FAILED ("WriteConsole");

      if (utf16_written < utf16_len)
        {
          written = g_utf8_to_utf16_make_valid_backtrack (string, utf16_written);
        }
      else
        {
          written = size;
        }

      if (utf16 != buffer)
        g_free (utf16);
    }

  if (written > INT_MAX)
    written = INT_MAX;

  return (int) written;
}

static int
print_console (const char *string,
               FILE       *stream)
{
  int ret;

  /* Locking the stream is not important, but leads
   * to nicer output in case of concurrent writes.
   */
  _lock_file (stream);

#if defined (_MSC_VER) || defined (_UCRT)
  _fflush_nolock (stream);
#else
  fflush (stream);
#endif

  ret = print_console_nolock (string, stream);

  _unlock_file (stream);

  return ret;
}

#endif /* _WIN32 */

static int
print_string (char const *string,
              FILE       *stream)
{
  size_t written = fwrite (string, 1, strlen (string), stream);

  return MIN (written, INT_MAX);
}

int
g_fputs (char const *string,
         FILE       *stream)
{
  int ret;

#ifdef _WIN32
  if (g_win32_file_stream_is_console_output (stream))
    {
      ret = print_console (string, stream);

      if (string[ret] != '\0')
        ret += print_string (&string[ret], stream);
    }
  else
    {
      ret = print_string (string, stream);
    }
#else
  const char *charset;

  if (isatty (fileno (stream)) &&
      !g_get_charset (&charset))
    {
      char *converted = g_print_convert (string, charset);
      ret = print_string (converted, stream);
      g_free (converted);
    }
  else
    {
      ret = print_string (string, stream);
    }
#endif

  return ret;
}