#ifndef __DW_HYPHENATOR_HH__
#define __DW_HYPHENATOR_HH__

#include "../lout/object.hh"
#include "../lout/container.hh"
#include "../dw/core.hh"

namespace dw {

class Trie {
   public:
      struct TrieNode {
         unsigned char c;
         uint16_t next;
         const char *data;
      };

   private:
      TrieNode *array;
      int size;
      bool freeArray;
      lout::misc::ZoneAllocator *dataZone;

   public:
      Trie (TrieNode *array = NULL, int size = 0, bool freeArray = false,
            lout::misc::ZoneAllocator *dataZone = NULL);
      ~Trie ();

      static const int root = 0;
      inline bool validState (int state) { return state >= 0 && state < size; };
      inline const char *getData (unsigned char c, int *state)
      {
         if (!validState (*state))
            return NULL;

         TrieNode *tn = array + *state + c;

         if (tn->c == c) {
            *state = tn->next > 0 ? tn->next : -1;
            return tn->data;
         } else {
            *state = -1;
            return NULL;
         }
      };
      void save (FILE *file);
      int load (FILE *file);
};

class TrieBuilder {
   private:
      struct StackEntry {
         unsigned char c;
         int count;
         int next[256];
         const char *data[256];
         const char *data1;
      };

      struct DataEntry {
         unsigned char *key;
         const char *value;
      };

      int pack;
      static Trie::TrieNode trieNodeNull;
      lout::misc::SimpleVector <Trie::TrieNode> *tree;
      lout::misc::SimpleVector <DataEntry> *dataList;
      lout::misc::SimpleVector <StackEntry> *stateStack;
      lout::misc::ZoneAllocator *dataZone;

      static int keyCompare (const void *p1, const void *p2);
      void stateStackPush (unsigned char c);
      int stateStackPop ();
      int insertState (StackEntry *state, bool root);
      void insertSorted (unsigned char *key, const char *value);

   public:
      TrieBuilder (int pack);
      ~TrieBuilder ();

      void insert (const char *key, const char *value);
      Trie *createTrie();
};

class Hyphenator: public lout::object::Object
{
   static lout::container::typed::HashTable
      <lout::object::String, Hyphenator> *hyphenators;
   Trie *trie;

   lout::container::typed::HashTable <lout::object::ConstString,
                                      lout::container::typed::Vector
                                      <lout::object::Integer> > *exceptions;

   void insertPattern (TrieBuilder *trieBuilder, char *s);
   void insertException (char *s);

   void hyphenateSingleWord(core::Platform *platform, char *wordLc, int offset,
                            lout::misc::SimpleVector <int> *breakPos);
   bool isCharPartOfActualWord (char *s);

public:
   Hyphenator (const char *patFile, const char *excFile, int pack = 256);
   ~Hyphenator();

   static Hyphenator *getHyphenator (const char *language);
   static bool isHyphenationCandidate (const char *word);
   int *hyphenateWord(core::Platform *platform, const char *word, int *numBreaks);
   void saveTrie (FILE *fp) { trie->save (fp); };
};

} // namespace dw

#endif // __DW_HYPHENATOR_HH__