//--------This file shamelessly stolen from Jeremy Friesner's excellent MUSCLE---------
/* This file is Copyright 2000 Level Control Systems.  See the included LICENSE.txt file for details. */

#include <new>
#include <stdio.h>

#include "StringMatcher.h"

#include <string.h>
#include <String.h>

StringMatcher::StringMatcher() : _regExpValid(false)
{
   // empty
}

StringMatcher :: StringMatcher(const char * str) : _regExpValid(false)
{
   SetPattern(str);
}

StringMatcher::~StringMatcher()
{
   if (_regExpValid) regfree(&_regExp);
}

bool StringMatcher::SetPattern(const char * str, bool isSimple)
{
   PortableString pattern;

   if (isSimple)
   {
      pattern = "^\\(";

      bool escapeMode = false;
      for (const char * ptr = str; *ptr != '\0'; ptr++)
      {
         if (escapeMode)
         {
            escapeMode = false;
            switch(*ptr)
            {
               case ',': case '|': case '(': case ')': case '?':
                  pattern += *ptr;
               break;

               default:
                  pattern += '\\';
                  pattern += *ptr;
               break;
            }
         }
         else
         {
            switch(*ptr)
            {
               case ',': case '|':
                  pattern += "\\|";
               break;

               case '.': case '(': case ')':
                  pattern += '\\';
                  pattern += *ptr;
               break;

               case '*':
                  pattern += ".*";
               break;

               case '?':
                  pattern += '.';
               break;

               case '\\':
                  escapeMode = true;
               break;

               break;

               default:
                  pattern += *ptr;
               break;
            }
         }
      }
      pattern += "\\)$";
      //printf("OUTPUT: pattern became '%s'.\n", pattern.Cstr());
   }

   // Free the old regular expression, if any
   if (_regExpValid)
   {
     regfree(&_regExp);
     _regExpValid = false;
   }

   // And compile the new one
   _regExpValid = (regcomp(&_regExp, (pattern.Length() > 0) ? pattern.String() : str, 0) == 0);
   return _regExpValid;
}


bool
StringMatcher::Match(const char *str) const
{
        if (_regExpValid == false)
                return false;

        int regExpStat = regexec(&_regExp, str, 0, NULL, 0);

        return (regExpStat != REG_NOMATCH);
}


bool IsRegexToken(char c)
{
   switch(c)
   {
     case '[': case ']': case '*': case '?': case '\\': case ',': case '|': case '(': case ')':
        return true;

     default:
        return false;
   }
}

void EscapeRegexTokens(PortableString & s)
{
   const char * str = s.String();

   PortableString ret;
   while(*str)
   {
     if (IsRegexToken(*str)) ret += '\\';
     ret += *str;
     str++;
   }
   s = ret;
}

bool HasRegexTokens(const char * str)
{
   while(*str)
   {
     if (IsRegexToken(*str)) return true;
                        else str++;
   }
   return false;
}

bool MakeRegexCaseInsensitive(PortableString & str)
{
   bool changed = false;
   PortableString ret;
   for (uint32 i=0; i<(unsigned)str.Length(); i++)
   {
     char next = str[i];
     if ((next >= 'A')&&(next <= 'Z'))
     {
        char buf[5];
        sprintf(buf, "[%c%c]", next, next+('a'-'A'));
        ret += buf;
        changed = true;
     }
     else if ((next >= 'a')&&(next <= 'z'))
     {
        char buf[5];
        sprintf(buf, "[%c%c]", next, next+('A'-'a'));
        ret += buf;
        changed = true;
     }
     else ret += next;
   }
   if (changed) str = ret;
   return changed;
}