/* Unicode CLDR plural rule parser and converter
   Copyright (C) 2015, 2018-2020 Free Software Foundation, Inc.

   This file was written by Daiki Ueno <ueno@gnu.org>, 2015.

   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

#include "basename-lgpl.h"
#include "cldr-plural-exp.h"
#include "closeout.h"
#include "c-ctype.h"
#include <errno.h>
#include <error.h>
#include <getopt.h>
#include "gettext.h"
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <locale.h>
#include "progname.h"
#include "propername.h"
#include "relocatable.h"
#include <stdlib.h>
#include <string.h>
#include "xalloc.h"

#define _(s) gettext(s)


static char *
extract_rules (FILE *fp,
               const char *real_filename, const char *logical_filename,
               const char *locale)
{
  xmlDocPtr doc;
  xmlNodePtr node, n;
  size_t locale_length;
  char *buffer = NULL, *p;
  size_t bufmax = 0;
  size_t buflen = 0;

  doc = xmlReadFd (fileno (fp), logical_filename, NULL,
                   XML_PARSE_NONET
                   | XML_PARSE_NOWARNING
                   | XML_PARSE_NOBLANKS);
  if (doc == NULL)
    error (EXIT_FAILURE, 0, _("Could not parse file %s as XML"), logical_filename);

  node = xmlDocGetRootElement (doc);
  if (!node || !xmlStrEqual (node->name, BAD_CAST "supplementalData"))
    {
      error_at_line (0, 0,
                     logical_filename,
                     xmlGetLineNo (node),
                     _("The root element must be <%s>"),
                     "supplementalData");
      goto out;
    }

  for (n = node->children; n; n = n->next)
    {
      if (n->type == XML_ELEMENT_NODE
          && xmlStrEqual (n->name, BAD_CAST "plurals"))
        break;
    }
  if (!n)
    {
      error (0, 0, _("The element <%s> does not contain a <%s> element"),
             "supplementalData", "plurals");
      goto out;
    }

  locale_length = strlen (locale);
  for (n = n->children; n; n = n->next)
    {
      xmlChar *locales;
      xmlChar *cp;
      xmlNodePtr n2;
      bool found = false;

      if (n->type != XML_ELEMENT_NODE
          || !xmlStrEqual (n->name, BAD_CAST "pluralRules"))
        continue;

      if (!xmlHasProp (n, BAD_CAST "locales"))
        {
          error_at_line (0, 0,
                         logical_filename,
                         xmlGetLineNo (n),
                         _("The element <%s> does not have attribute <%s>"),
                         "pluralRules", "locales");
          continue;
        }

      cp = locales = xmlGetProp (n, BAD_CAST "locales");
      while (*cp != '\0')
        {
          while (c_isspace (*cp))
            cp++;
          if (xmlStrncmp (cp, BAD_CAST locale, locale_length) == 0
              && (*(cp + locale_length) == '\0'
                  || c_isspace (*(cp + locale_length))))
            {
              found = true;
              break;
            }
          while (*cp && !c_isspace (*cp))
            cp++;
        }
      xmlFree (locales);

      if (!found)
        continue;

      for (n2 = n->children; n2; n2 = n2->next)
        {
          xmlChar *count;
          xmlChar *content;
          size_t length;

          if (n2->type != XML_ELEMENT_NODE
              || !xmlStrEqual (n2->name, BAD_CAST "pluralRule"))
            continue;

          if (!xmlHasProp (n2, BAD_CAST "count"))
            {
              error_at_line (0, 0,
                             logical_filename,
                             xmlGetLineNo (n2),
                             _("The element <%s> does not have attribute <%s>"),
                             "pluralRule", "count");
              break;
            }

          count = xmlGetProp (n2, BAD_CAST "count");
          content = xmlNodeGetContent (n2);
          length = xmlStrlen (count) + strlen (": ")
            + xmlStrlen (content) + strlen ("; ");

          if (buflen + length + 1 > bufmax)
            {
              bufmax *= 2;
              if (bufmax < buflen + length + 1)
                bufmax = buflen + length + 1;
              buffer = (char *) xrealloc (buffer, bufmax);
            }

          sprintf (buffer + buflen, "%s: %s; ", count, content);
          xmlFree (count);
          xmlFree (content);

          buflen += length;
        }
    }

  if (buffer)
    {
      /* Scrub the last semicolon, if any.  */
      p = strrchr (buffer, ';');
      if (p)
        *p = '\0';
    }

 out:
  xmlFreeDoc (doc);
  return buffer;
}

/* Display usage information and exit.  */
static void
usage (int status)
{
  if (status != EXIT_SUCCESS)
    fprintf (stderr, _("Try '%s --help' for more information.\n"),
             program_name);
  else
    {
      printf (_("\
Usage: %s [OPTION...] [LOCALE RULES]...\n\
"), program_name);
      printf ("\n");
      /* xgettext: no-wrap */
      printf (_("\
Extract or convert Unicode CLDR plural rules.\n\
\n\
If both LOCALE and RULES are specified, it reads CLDR plural rules for\n\
LOCALE from RULES and print them in a form suitable for gettext use.\n\
If no argument is given, it reads CLDR plural rules from the standard input.\n\
"));
      printf ("\n");
      /* xgettext: no-wrap */
      printf (_("\
Mandatory arguments to long options are mandatory for short options too.\n\
Similarly for optional arguments.\n\
"));
      printf ("\n");
      printf (_("\
  -c, --cldr                  print plural rules in the CLDR format\n"));
      printf (_("\
  -h, --help                  display this help and exit\n"));
      printf (_("\
  -V, --version               output version information and exit\n"));
      printf ("\n");
      /* TRANSLATORS: The first placeholder is the web address of the Savannah
         project of this package.  The second placeholder is the bug-reporting
         email address for this package.  Please add _another line_ saying
         "Report translation bugs to <...>\n" with the address for translation
         bugs (typically your translation team's web or email address).  */
      printf(_("\
Report bugs in the bug tracker at <%s>\n\
or by email to <%s>.\n"),
             "https://savannah.gnu.org/projects/gettext",
             "bug-gettext@gnu.org");
    }
  exit (status);
}

/* Long options.  */
static const struct option long_options[] =
{
  { "cldr", no_argument, NULL, 'c' },
  { "help", no_argument, NULL, 'h' },
  { "version", no_argument, NULL, 'V' },
  { NULL, 0, NULL, 0 }
};

int
main (int argc, char **argv)
{
  bool opt_cldr_format = false;
  bool do_help = false;
  bool do_version = false;
  int optchar;

  /* Set program name for messages.  */
  set_program_name (argv[0]);

  /* Set locale via LC_ALL.  */
  setlocale (LC_ALL, "");

  /* Set the text message domain.  */
  bindtextdomain (PACKAGE, relocate (LOCALEDIR));
  bindtextdomain ("bison-runtime", relocate (BISON_LOCALEDIR));
  textdomain (PACKAGE);

  /* Ensure that write errors on stdout are detected.  */
  atexit (close_stdout);

  while ((optchar = getopt_long (argc, argv, "chV", long_options, NULL)) != EOF)
    switch (optchar)
      {
      case '\0':                /* Long option.  */
        break;

      case 'c':
        opt_cldr_format = true;
        break;

      case 'h':
        do_help = true;
        break;

      case 'V':
        do_version = true;
        break;

      default:
        usage (EXIT_FAILURE);
        /* NOTREACHED */
      }

  /* Version information requested.  */
  if (do_version)
    {
      printf ("%s (GNU %s) %s\n", last_component (program_name),
              PACKAGE, VERSION);
      /* xgettext: no-wrap */
      printf (_("Copyright (C) %s Free Software Foundation, Inc.\n\
License GPLv3+: GNU GPL version 3 or later <%s>\n\
This is free software: you are free to change and redistribute it.\n\
There is NO WARRANTY, to the extent permitted by law.\n\
"),
              "2015-2020", "https://gnu.org/licenses/gpl.html");
      printf (_("Written by %s.\n"), proper_name ("Daiki Ueno"));
      exit (EXIT_SUCCESS);
    }

  /* Help is requested.  */
  if (do_help)
    usage (EXIT_SUCCESS);

  if (argc == optind + 2)
    {
      /* Two arguments: Read CLDR rules from a file.  */
      const char *locale = argv[optind];
      const char *logical_filename = argv[optind + 1];
      char *extracted_rules;
      FILE *fp;

      LIBXML_TEST_VERSION

      fp = fopen (logical_filename, "r");
      if (fp == NULL)
        error (1, 0, _("%s cannot be read"), logical_filename);

      extracted_rules = extract_rules (fp, logical_filename, logical_filename,
                                       locale);
      fclose (fp);
      if (extracted_rules == NULL)
        error (1, 0, _("cannot extract rules for %s"), locale);

      if (opt_cldr_format)
        printf ("%s\n", extracted_rules);
      else
        {
          struct cldr_plural_rule_list_ty *result;

          result = cldr_plural_parse (extracted_rules);
          if (result == NULL)
            error (1, 0, _("cannot parse CLDR rule"));

          cldr_plural_rule_list_print (result, stdout);
          cldr_plural_rule_list_free (result);
        }
      free (extracted_rules);
    }
  else if (argc == optind)
    {
      /* No argument: Read CLDR rules from standard input.  */
      char *line = NULL;
      size_t line_size = 0;
      for (;;)
        {
          int line_len;
          struct cldr_plural_rule_list_ty *result;

          line_len = getline (&line, &line_size, stdin);
          if (line_len < 0)
            break;
          if (line_len > 0 && line[line_len - 1] == '\n')
            line[--line_len] = '\0';

          result = cldr_plural_parse (line);
          if (result)
            {
              cldr_plural_rule_list_print (result, stdout);
              cldr_plural_rule_list_free (result);
            }
        }

      free (line);
    }
  else
    {
      error (1, 0, _("extra operand %s"), argv[optind]);
    }

  return 0;
}