/* Writing Qt .qm files.
   Copyright (C) 2003-2025 Free Software Foundation, Inc.
   Written by Bruno Haible <bruno@clisp.org>, 2003.

   This program 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.

   This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

/* Specification.  */
#include "write-qt.h"

#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <error.h>
#include "attribute.h"
#include "xerror.h"
#include "message.h"
#include "next-prime.h"
#include "po-charset.h"
#include "msgl-iconv.h"
#include "xerror-handler.h"
#include "msgl-header.h"
#include "hash-string.h"
#include "unistr.h"
#include "xalloc.h"
#include "obstack.h"
#include "mem-hash-map.h"
#include "binary-io.h"
#include "fwriteerror.h"
#include "gettext.h"

#define _(str) gettext (str)

/* Qt .qm files are read by the QTranslator::load() function and written
   by the Qt QTranslator::save() function.

   The Qt tool 'msg2qm' uses the latter function and can convert PO files
   to .qm files. But since 'msg2qm' is marked as an "old" tool in Qt 3.0.5's
   i18n.html documentation and therefore likely to disappear, we provide the
   same functionality here.

   The format of .qm files, as reverse engineered from the functions
     QTranslator::save(const QString& filename, SaveMode mode)
     QTranslator::squeeze(SaveMode mode)
     QTranslatorMessage::write(QDataStream& stream, bool strip, Prefix prefix)
     elfHash(const char* name)
   in qt-3.0.5, is as follows:

     It's a binary data format. Elements are u8 (byte), u16, u32. They are
     written in big-endian order.

     The file starts with a magic string of 16 bytes:
       3C B8 64 18 CA EF 9C 95 CD 21 1C BF 60 A1 BD DD

     Then come three sections. Each of the three sections is optional. Each
     has this structure:
       struct {
         u8 section_type; // 0x42 = hashes, 0x69 = messages, 0x2f = contexts
         u32 length; // number of bytes of the data
         u8 data[length];
       };

     In the first section, the hashes section, the data has the following
     structure:
       It's a sorted array of
         struct {
           u32 hashcode; // elfHash of the concatenation of msgid and
                         // disambiguating-comment
           u32 offset; // offset within the data[] of the messages section
         };
       It's sorted in ascending order by hashcode as primary sorting criteria
       and - when the hashcodes are the same - by offset as secondary criteria.

     In the second section, the messages section, the data has the following
     structure:
       It's a sequence of records, each representing a message, in no
       particular order. Each record is a sequence of subsections, each
       introduced by a particular subsection tag. The possible subsection tags
       are (and they usually occur in this order):
         - 03: Translation. Followed by the msgstr in UCS-2 or UTF-16 format:
               struct {
                 u32 length;
                 u16 chars[length/2];
               };
         - 08: Disambiguating-comment. Followed by the NUL-terminated,
               ISO-8859-1 encoded, disambiguating-comment string:
               struct {
                 u32 length;    // number of bytes including the NUL at the end
                 u8 chars[length];
               };
         - 06: SourceText, i.e. msgid. Followed by the NUL-terminated,
               ISO-8859-1 encoded, msgid:
               struct {
                 u32 length;    // number of bytes including the NUL at the end
                 u8 chars[length];
               };
         - 02: SourceText16, i.e. msgid. Encoded as UCS-2, but must actually
               be ISO-8859-1.
               struct {
                 u32 length;
                 u16 chars[length/2];
               };
               This subsection tag is obsoleted by SourceText.
         - 07: Context. Followed by the NUL-terminated, ISO-8859-1 encoded,
               context string (usually a C++ class name or empty):
               struct {
                 u32 length;    // number of bytes including the NUL at the end
                 u8 chars[length];
               };
         - 04: Context16. Encoded as UCS-2, but must actually be ISO-8859-1.
               struct {
                 u32 length;
                 u16 chars[length/2];
               };
               This subsection tag is obsoleted by Context.
         - 05: Hash. Followed by
               struct {
                 u32 hashcode; // elfHash of the concatenation of msgid and
                               // disambiguating-comment
               };
         - 01: End. Designates the end of the record. No further data.
       Usually the following subsections are written, but some of them are
       optional:
         - 03: Translation.
         - 08: Disambiguating-comment (optional).
         - 06: SourceText (optional).
         - 07: Context (optional).
         - 05: Hash.
         - 01: End.
       A subsection can be omitted if the value to be output is the same as
       for the previous record.

     The third section, the contexts section, contains the set of all occurring
     context strings. This section is optional; it is used to speed up the
     search. The data is a hash table with the following structure:
       struct {
         u16 table_size;
         u16 buckets[table_size];
         u8 pool[...];
       };
     pool[...] contains:
       u16 zero;
       for i = 0, ..., table_size:
         if there are context strings with elfHash(context)%table_size == i:
           for all context strings with elfHash(context)%table_size == i:
             len := min(length(context),255); // truncated to length 255
             struct {
               u8 len;
               u8 chars[len];
             };
           struct {
             u8 zero[1]; // signals the end of this bucket
             u8 padding[0 or 1]; // padding for even number of bytes
           };
     buckets[i] is 0 for an empty bucket, or the offset in pool[] where
     the context strings for this bucket start, divided by 2.
     This context section must not be used
       - if the empty context is used, or
       - if a context of length > 255 is used, or
       - if the context pool's size would be > 2^17.

     The elfHash function is the same as our hash_string function, except that
     at the end it maps a hash code of 0x00000000 to 0x00000001.

   When we convert from PO file format, all disambiguating-comments and
   contexts are empty, and therefore the contexts section can be omitted.  */


/* Write a u8 (a single byte) to the output stream.  */
static inline void
write_u8 (FILE *output_file, unsigned char value)
{
  putc (value, output_file);
}

/* Write a u16 (two bytes) to the output stream.  */
MAYBE_UNUSED static inline void
write_u16 (FILE *output_file, unsigned short value)
{
  unsigned char data[2];

  data[0] = (value >> 8) & 0xff;
  data[1] = value & 0xff;

  fwrite (data, 2, 1, output_file);
}

/* Write a u32 (four bytes) to the output stream.  */
static inline void
write_u32 (FILE *output_file, unsigned int value)
{
  unsigned char data[4];

  data[0] = (value >> 24) & 0xff;
  data[1] = (value >> 16) & 0xff;
  data[2] = (value >> 8) & 0xff;
  data[3] = value & 0xff;

  fwrite (data, 4, 1, output_file);
}


#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free

/* Add a u8 (a single byte) to an obstack.  */
static void
append_u8 (struct obstack *mempool, unsigned char value)
{
  unsigned char data[1];

  data[0] = value;

  obstack_grow (mempool, data, 1);
}

/* Add a u16 (two bytes) to an obstack.  */
static void
append_u16 (struct obstack *mempool, unsigned short value)
{
  unsigned char data[2];

  data[0] = (value >> 8) & 0xff;
  data[1] = value & 0xff;

  obstack_grow (mempool, data, 2);
}

/* Add a u32 (four bytes) to an obstack.  */
static void
append_u32 (struct obstack *mempool, unsigned int value)
{
  unsigned char data[4];

  data[0] = (value >> 24) & 0xff;
  data[1] = (value >> 16) & 0xff;
  data[2] = (value >> 8) & 0xff;
  data[3] = value & 0xff;

  obstack_grow (mempool, data, 4);
}

/* Add an ISO-8859-1 encoded string to an obstack.  */
static void
append_base_string (struct obstack *mempool, const char *string)
{
  size_t length = strlen (string) + 1;
  append_u32 (mempool, length);
  obstack_grow (mempool, string, length);
}

/* Add an UTF-16 encoded string to an obstack.  */
static void
append_unicode_string (struct obstack *mempool, const unsigned short *string,
                       size_t length)
{
  append_u32 (mempool, length * 2);
  for (; length > 0; string++, length--)
    append_u16 (mempool, *string);
}

/* Retrieve a 4-byte integer from memory.  */
static inline unsigned int
peek_u32 (const unsigned char *p)
{
  return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
}

/* Convert an UTF-8 string to ISO-8859-1, without error checking.  */
static char *
conv_to_iso_8859_1 (const char *string)
{
  size_t length = strlen (string);
  const char *str = string;
  const char *str_limit = string + length;
  /* Conversion to ISO-8859-1 can only reduce the number of bytes.  */
  char *result = XNMALLOC (length + 1, char);
  char *q = result;

  while (str < str_limit)
    {
      ucs4_t uc;
      str += u8_mbtouc (&uc, (const unsigned char *) str, str_limit - str);
      /* It has already been verified that the string fits in ISO-8859-1.  */
      if (!(uc < 0x100))
        abort ();
      /* Store as ISO-8859-1.  */
      *q++ = (unsigned char) uc;
    }
  *q = '\0';
  assert (q - result <= length);

  return result;
}

/* Convert an UTF-8 string to UTF-16, returning its size (number of UTF-16
   codepoints) in *SIZEP.  */
static unsigned short *
conv_to_utf16 (const char *string, size_t *sizep)
{
  size_t length = strlen (string);
  const char *str = string;
  const char *str_limit = string + length;
  /* Conversion to UTF-16 can at most double the number of bytes.  */
  unsigned short *result = XNMALLOC (length, unsigned short);
  unsigned short *q = result;

  while (str < str_limit)
    {
      ucs4_t uc;
      str += u8_mbtouc (&uc, (const unsigned char *) str, str_limit - str);
      if (uc < 0x10000)
        /* UCS-2 character.  */
        *q++ = (unsigned short) uc;
      else
        {
          /* UTF-16 surrogate.  */
          *q++ = 0xd800 + ((uc - 0x10000) >> 10);
          *q++ = 0xdc00 + ((uc - 0x10000) & 0x3ff);
        }
    }
  assert (q - result <= 2 * length);

  *sizep = q - result;
  return result;
}

/* Return the Qt hash code of a string.  */
static unsigned int
string_hashcode (const char *str)
{
  unsigned int h;

  h = hash_string (str);
  if (h == 0)
    h = 1;
  return h;
}

/* Compare two entries of the hashes section.  */
static int
cmp_hashes (const void *va, const void *vb)
{
  const unsigned char *a = (const unsigned char *) va;
  const unsigned char *b = (const unsigned char *) vb;
  unsigned int a_hashcode = peek_u32 (a);
  unsigned int b_hashcode = peek_u32 (b);

  if (a_hashcode != b_hashcode)
    return (a_hashcode >= b_hashcode ? 1 : -1);
  else
    {
      unsigned int a_offset = peek_u32 (a + 4);
      unsigned int b_offset = peek_u32 (b + 4);

      if (a_offset != b_offset)
        return (a_offset >= b_offset ? 1 : -1);
      else
        return 0;
    }
}


/* Write a section to the output stream.  */
static void
write_section (FILE *output_file, unsigned char tag, void *data, size_t size)
{
  /* A section can be omitted if it is empty.  */
  if (size > 0)
    {
      write_u8 (output_file, tag);
      write_u32 (output_file, size);
      fwrite (data, size, 1, output_file);
    }
}


/* Write an entire .qm file.  */
static void
write_qm (FILE *output_file, message_list_ty *mlp)
{
  static unsigned char magic[16] =
    {
      0x3C, 0xB8, 0x64, 0x18, 0xCA, 0xEF, 0x9C, 0x95,
      0xCD, 0x21, 0x1C, 0xBF, 0x60, 0xA1, 0xBD, 0xDD
    };
  struct obstack hashes_pool;
  struct obstack messages_pool;
  size_t j;

  obstack_init (&hashes_pool);
  obstack_init (&messages_pool);

  /* Prepare the hashes section and the messages section.  */
  for (j = 0; j < mlp->nitems; j++)
    {
      message_ty *mp = mlp->item[j];

      /* No need to emit the header entry, it's not needed at runtime.  */
      if (!is_header (mp))
        {
          char *msgctxt_as_iso_8859_1 =
            conv_to_iso_8859_1 (mp->msgctxt != NULL ? mp->msgctxt : "");
          char *msgid_as_iso_8859_1 = conv_to_iso_8859_1 (mp->msgid);
          size_t msgstr_len;
          unsigned short *msgstr_as_utf16 =
            conv_to_utf16 (mp->msgstr, &msgstr_len);
          unsigned int hashcode = string_hashcode (msgid_as_iso_8859_1);
          unsigned int offset = obstack_object_size (&messages_pool);

          /* Add a record to the hashes section.  */
          append_u32 (&hashes_pool, hashcode);
          append_u32 (&hashes_pool, offset);

          /* Add a record to the messages section.  */

          append_u8 (&messages_pool, 0x03);
          append_unicode_string (&messages_pool, msgstr_as_utf16, msgstr_len);

          append_u8 (&messages_pool, 0x08);
          append_base_string (&messages_pool, "");

          append_u8 (&messages_pool, 0x06);
          append_base_string (&messages_pool, msgid_as_iso_8859_1);

          append_u8 (&messages_pool, 0x07);
          append_base_string (&messages_pool, msgctxt_as_iso_8859_1);

          append_u8 (&messages_pool, 0x05);
          append_u32 (&messages_pool, hashcode);

          append_u8 (&messages_pool, 0x01);

          free (msgstr_as_utf16);
          free (msgid_as_iso_8859_1);
          free (msgctxt_as_iso_8859_1);
        }
    }

  /* Sort the hashes section.  */
  {
    size_t nstrings = obstack_object_size (&hashes_pool) / 8;
    if (nstrings > 0)
      qsort (obstack_base (&hashes_pool), nstrings, 8, cmp_hashes);
  }

  /* Write the magic number.  */
  fwrite (magic, sizeof (magic), 1, output_file);

  /* Write the hashes section.  */
  write_section (output_file, 0x42, obstack_base (&hashes_pool),
                 obstack_object_size (&hashes_pool));

  /* Write the messages section.  */
  write_section (output_file, 0x69, obstack_base (&messages_pool),
                 obstack_object_size (&messages_pool));

  /* Decide whether to write a contexts section.  */
  {
    bool can_write_contexts = true;

    for (j = 0; j < mlp->nitems; j++)
      {
        message_ty *mp = mlp->item[j];

        if (!is_header (mp))
          if (mp->msgctxt == NULL || mp->msgctxt[0] == '\0'
              || strlen (mp->msgctxt) > 255)
            {
              can_write_contexts = false;
              break;
            }
      }

    if (can_write_contexts)
      {
        hash_table all_contexts;
        size_t num_contexts;
        unsigned long table_size;

        /* Collect the contexts, removing duplicates.  */
        hash_init (&all_contexts, 10);
        for (j = 0; j < mlp->nitems; j++)
          {
            message_ty *mp = mlp->item[j];

            if (!is_header (mp))
              hash_insert_entry (&all_contexts,
                                 mp->msgctxt, strlen (mp->msgctxt) + 1,
                                 NULL);
          }

        /* Compute the number of different contexts.  */
        num_contexts = all_contexts.size;

        /* Compute a suitable hash table size.  */
        table_size = next_prime (num_contexts * 1.7);
        if (table_size >= 0x10000)
          table_size = 65521;

        /* Put the contexts into a hash table of size table_size.  */
        {
          struct list_cell { const char *context; struct list_cell *next; };
          struct list_cell *list_memory =
            XNMALLOC (table_size, struct list_cell);
          struct list_cell *freelist;
          struct bucket { struct list_cell *head; struct list_cell **tail; };
          struct bucket *buckets = XNMALLOC (table_size, struct bucket);
          size_t i;

          freelist = list_memory;

          for (i = 0; i < table_size; i++)
            {
              buckets[i].head = NULL;
              buckets[i].tail = &buckets[i].head;
            }

          {
            void *iter;
            const void *key;
            size_t keylen;
            void *null;

            iter = NULL;
            while (hash_iterate (&all_contexts, &iter, &key, &keylen, &null)
                   == 0)
              {
                const char *context = (const char *)key;
                i = string_hashcode (context) % table_size;
                freelist->context = context;
                freelist->next = NULL;
                *buckets[i].tail = freelist;
                buckets[i].tail = &freelist->next;
                freelist++;
              }
          }

          /* Determine the total context pool size.  */
          {
            size_t pool_size;

            pool_size = 2;
            for (i = 0; i < table_size; i++)
              if (buckets[i].head != NULL)
                {
                  const struct list_cell *p;

                  for (p = buckets[i].head; p != NULL; p = p->next)
                    pool_size += 1 + strlen (p->context);
                  pool_size++;
                  if ((pool_size % 2) != 0)
                    pool_size++;
                }
            if (pool_size <= 0x20000)
              {
                /* Prepare the contexts section.  */
                struct obstack contexts_pool;
                size_t pool_offset;

                obstack_init (&contexts_pool);

                append_u16 (&contexts_pool, table_size);
                pool_offset = 2;
                for (i = 0; i < table_size; i++)
                  if (buckets[i].head != NULL)
                    {
                      const struct list_cell *p;

                      append_u16 (&contexts_pool, pool_offset / 2);
                      for (p = buckets[i].head; p != NULL; p = p->next)
                        pool_offset += 1 + strlen (p->context);
                      pool_offset++;
                      if ((pool_offset % 2) != 0)
                        pool_offset++;
                    }
                  else
                    append_u16 (&contexts_pool, 0);
                if (!(pool_offset == pool_size))
                  abort ();

                append_u16 (&contexts_pool, 0);
                pool_offset = 2;
                for (i = 0; i < table_size; i++)
                  if (buckets[i].head != NULL)
                    {
                      const struct list_cell *p;

                      for (p = buckets[i].head; p != NULL; p = p->next)
                        {
                          append_u8 (&contexts_pool, strlen (p->context));
                          obstack_grow (&contexts_pool,
                                        p->context, strlen (p->context));
                          pool_offset += 1 + strlen (p->context);
                        }
                      append_u8 (&contexts_pool, 0);
                      pool_offset++;
                      if ((pool_offset % 2) != 0)
                        {
                          append_u8 (&contexts_pool, 0);
                          pool_offset++;
                        }
                    }
                if (!(pool_offset == pool_size))
                  abort ();

                if (!(obstack_object_size (&contexts_pool)
                      == 2 + 2 * table_size + pool_size))
                  abort ();

                /* Write the contexts section.  */
                write_section (output_file, 0x2f, obstack_base (&contexts_pool),
                               obstack_object_size (&contexts_pool));

                obstack_free (&contexts_pool, NULL);
              }
          }

          free (buckets);
          free (list_memory);
        }

        hash_destroy (&all_contexts);
      }
  }

  obstack_free (&messages_pool, NULL);
  obstack_free (&hashes_pool, NULL);
}


int
msgdomain_write_qt (message_list_ty *mlp, const char *canon_encoding,
                    const char *domain_name, const char *file_name)
{
  /* If no entry for this domain don't even create the file.  */
  if (mlp->nitems != 0)
    {
      FILE *output_file;

      /* Determine whether mlp has plural entries.  */
      {
        bool has_plural;
        size_t j;

        has_plural = false;
        for (j = 0; j < mlp->nitems; j++)
          if (mlp->item[j]->msgid_plural != NULL)
            has_plural = true;
        if (has_plural)
          {
            multiline_error (xstrdup (""),
                             xstrdup (_("\
message catalog has plural form translations\n\
but the Qt message catalog format doesn't support plural handling\n")));
            return 1;
          }
      }

      /* Convert the messages to Unicode.  */
      iconv_message_list (mlp, canon_encoding, po_charset_utf8, NULL,
                          textmode_xerror_handler);

      /* Determine whether mlp has non-ISO-8859-1 msgctxt entries.  */
      {
        size_t j;

        for (j = 0; j < mlp->nitems; j++)
          {
            const char *string = mlp->item[j]->msgctxt;

            if (string != NULL)
              {
                /* An UTF-8 encoded string fits in ISO-8859-1 if and only if
                   all its bytes are < 0xc4.  */
                for (; *string; string++)
                  if ((unsigned char) *string >= 0xc4)
                    {
                      multiline_error (xstrdup (""),
                                       xstrdup (_("\
message catalog has msgctxt strings containing characters outside ISO-8859-1\n\
but the Qt message catalog format supports Unicode only in the translated\n\
strings, not in the context strings\n")));
                      return 1;
                    }
              }
          }
      }

      /* Determine whether mlp has non-ISO-8859-1 msgid entries.  */
      {
        size_t j;

        for (j = 0; j < mlp->nitems; j++)
          {
            const char *string = mlp->item[j]->msgid;

            /* An UTF-8 encoded string fits in ISO-8859-1 if and only if all
               its bytes are < 0xc4.  */
            for (; *string; string++)
              if ((unsigned char) *string >= 0xc4)
                {
                  multiline_error (xstrdup (""),
                                   xstrdup (_("\
message catalog has msgid strings containing characters outside ISO-8859-1\n\
but the Qt message catalog format supports Unicode only in the translated\n\
strings, not in the untranslated strings\n")));
                  return 1;
                }
          }
      }

      /* Support for "reproducible builds": Delete information that may vary
         between builds in the same conditions.  */
      message_list_delete_header_field (mlp, "POT-Creation-Date:");

      if (strcmp (domain_name, "-") == 0)
        {
          output_file = stdout;
          SET_BINARY (fileno (output_file));
        }
      else
        {
          output_file = fopen (file_name, "wb");
          if (output_file == NULL)
            {
              error (0, errno, _("error while opening \"%s\" for writing"),
                     file_name);
              return 1;
            }
        }

      write_qm (output_file, mlp);

      /* Make sure nothing went wrong.  */
      if (fwriteerror (output_file))
        error (EXIT_FAILURE, errno, _("error while writing \"%s\" file"),
               file_name);
    }

  return 0;
}
