/*  phonetic.c - generic replacement aglogithms for phonetic transformation
    Copyright (C) 2000 Bjoern Jacke

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License version 2.1 as published by the Free Software Foundation;

    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/>.

    Changelog:

    2000-01-05  Bjoern Jacke <bjoern at j3e.de>
                Initial Release insprired by the article about phonetic
                transformations out of c't 25/1999

    2007-07-26  Bjoern Jacke <bjoern at j3e.de>
                Released under MPL/GPL/LGPL tri-license for Hunspell

    2007-08-23  Laszlo Nemeth <nemeth at OOo>
                Porting from Aspell to Hunspell using C-like structs
*/

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

#include "csutil.hxx"
#include "phonet.hxx"

void init_phonet_hash(phonetable& parms) {
  for (int i = 0; i < HASHSIZE; i++) {
    parms.hash[i] = -1;
  }

  for (int i = 0; parms.rules[i][0] != '\0'; i += 2) {
    /**  set hash value  **/
    int k = (unsigned char)parms.rules[i][0];

    if (parms.hash[k] < 0) {
      parms.hash[k] = i;
    }
  }
}

// like strcpy but safe if the strings overlap
//   but only if dest < src
static inline void strmove(char* dest, char* src) {
  while (*src)
    *dest++ = *src++;
  *dest = '\0';
}

static int myisalpha(char ch) {
  if ((unsigned char)ch < 128)
    return isalpha(ch);
  return 1;
}

/*  Do phonetic transformation.                        */
/*  phonetic transcription algorithm                   */
/*  see: http://aspell.net/man-html/Phonetic-Code.html */
/*  convert string to uppercase before this call       */
std::string phonet(const std::string& inword, phonetable& parms) {

  int i, k = 0, p, z;
  int k0, n0, p0 = -333;
  char c;
  typedef unsigned char uchar;

  size_t len = inword.size();
  if (len > MAXPHONETUTF8LEN)
    return std::string();
  char word[MAXPHONETUTF8LEN + 1];
  strncpy(word, inword.c_str(), MAXPHONETUTF8LEN);
  word[MAXPHONETUTF8LEN] = '\0';

  std::string target;
  /**  check word  **/
  i = z = 0;
  while ((c = word[i]) != '\0') {
    int n = parms.hash[(uchar)c];
    int z0 = 0;

    if (n >= 0 && !parms.rules[n].empty()) {
      /**  check all rules for the same letter  **/
      while (parms.rules[n][0] == c) {
        /**  check whole string  **/
        k = 1; /** number of found letters  **/
        p = 5; /** default priority  **/
        const char*s = parms.rules[n].c_str();
        s++; /**  important for (see below)  "*(s-1)"  **/

        while (*s != '\0' && word[i + k] == *s && !isdigit((unsigned char)*s) &&
               strchr("(-<^$", *s) == NULL) {
          k++;
          s++;
        }
        if (*s == '(') {
          /**  check letters in "(..)"  **/
          if (myisalpha(word[i + k])  // ...could be implied?
              && strchr(s + 1, word[i + k]) != NULL) {
            k++;
            while (*s != ')')
              s++;
            s++;
          }
        }
        p0 = (int)*s;
        k0 = k;
        while (*s == '-' && k > 1) {
          k--;
          s++;
        }
        if (*s == '<')
          s++;
        if (isdigit((unsigned char)*s)) {
          /**  determine priority  **/
          p = *s - '0';
          s++;
        }
        if (*s == '^' && *(s + 1) == '^')
          s++;

        if (*s == '\0' || (*s == '^' && (i == 0 || !myisalpha(word[i - 1])) &&
                           (*(s + 1) != '$' || (!myisalpha(word[i + k0])))) ||
            (*s == '$' && i > 0 && myisalpha(word[i - 1]) &&
             (!myisalpha(word[i + k0])))) {
          /**  search for followup rules, if:     **/
          /**  parms.followup and k > 1  and  NO '-' in searchstring **/
          char c0 = word[i + k - 1];
          n0 = parms.hash[(uchar)c0];

          //            if (parms.followup  &&  k > 1  &&  n0 >= 0
          if (k > 1 && n0 >= 0 && p0 != (int)'-' && word[i + k] != '\0' && !parms.rules[n0].empty()) {
            /**  test follow-up rule for "word[i+k]"  **/
            while (parms.rules[n0][0] == c0) {
              /**  check whole string  **/
              k0 = k;
              p0 = 5;
              s = parms.rules[n0].c_str();
              s++;
              while (*s != '\0' && word[i + k0] == *s &&
                     !isdigit((unsigned char)*s) &&
                     strchr("(-<^$", *s) == NULL) {
                k0++;
                s++;
              }
              if (*s == '(') {
                /**  check letters  **/
                if (myisalpha(word[i + k0]) &&
                    strchr(s + 1, word[i + k0]) != NULL) {
                  k0++;
                  while (*s != ')' && *s != '\0')
                    s++;
                  if (*s == ')')
                    s++;
                }
              }
              while (*s == '-') {
                /**  "k0" gets NOT reduced   **/
                /**  because "if (k0 == k)"  **/
                s++;
              }
              if (*s == '<')
                s++;
              if (isdigit((unsigned char)*s)) {
                p0 = *s - '0';
                s++;
              }

              if (*s == '\0'
                  /**  *s == '^' cuts  **/
                  || (*s == '$' && !myisalpha(word[i + k0]))) {
                if (k0 == k) {
                  /**  this is just a piece of the string  **/
                  n0 += 2;
                  continue;
                }

                if (p0 < p) {
                  /**  priority too low  **/
                  n0 += 2;
                  continue;
                }
                /**  rule fits; stop search  **/
                break;
              }
              n0 += 2;
            } /**  End of "while (parms.rules[n0][0] == c0)"  **/

            if (p0 >= p && parms.rules[n0][0] == c0) {
              n += 2;
              continue;
            }
          } /** end of follow-up stuff **/

          /**  replace string  **/
          s = parms.rules[n + 1].c_str();
          p0 = (!parms.rules[n].empty() &&
                strchr(parms.rules[n].c_str() + 1, '<') != NULL)
                   ? 1
                   : 0;
          if (p0 == 1 && z == 0) {
            /**  rule with '<' is used  **/
            if (!target.empty() && *s != '\0' &&
                (target[target.size()-1] == c || target[target.size()-1] == *s)) {
              target.erase(target.size() - 1);
            }
            z0 = 1;
            z = 1;
            k0 = 0;
            while (*s != '\0' && word[i + k0] != '\0') {
              word[i + k0] = *s;
              k0++;
              s++;
            }
            if (k > k0)
              strmove(&word[0] + i + k0, &word[0] + i + k);

            /**  new "actual letter"  **/
            c = word[i];
          } else { /** no '<' rule used **/
            i += k - 1;
            z = 0;
            while (*s != '\0' && *(s + 1) != '\0' && target.size() < len) {
              if (target.empty() || target[target.size()-1] != *s) {
                target.push_back(*s);
              }
              s++;
            }
            /**  new "actual letter"  **/
            c = *s;
            if (!parms.rules[n].empty() &&
                strstr(parms.rules[n].c_str() + 1, "^^") != NULL) {
              if (c != '\0') {
                target.push_back(c);
              }
              strmove(&word[0], &word[0] + i + 1);
              i = 0;
              z0 = 1;
            }
          }
          break;
        } /** end of follow-up stuff **/
        n += 2;
      } /**  end of while (parms.rules[n][0] == c)  **/
    }   /**  end of if (n >= 0)  **/
    if (z0 == 0) {
      if (k && !p0 && target.size() < len && c != '\0') {
        /**  condense only double letters  **/
        target.push_back(c);
        /// printf("\n setting \n");
      }

      i++;
      z = 0;
      k = 0;
    }
  } /**  end of   while ((c = word[i]) != '\0')  **/

  return target;
} /**  end of function "phonet"  **/