//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;

import java.util.Hashtable;

/**
 * A special case of Multi, implemented when minChars().equals(maxChars()), and
 * some other conditions spelled out in RegOpt.safe4fm "Safe for FastMulti." It
 * avoids stack growth problems as well as being slightly faster.
 */
class FastMulti extends PatternSub
{
  patInt fewestMatches, mostMatches;

  public patInt minChars()
  {
    return sub.countMinChars().mul(fewestMatches);
  }

  public patInt maxChars()
  {
    return sub.countMaxChars().mul(mostMatches);
  }

  public boolean matchFewest = false;

  FastMulti(patInt a, patInt b, Pattern p) throws RegSyntax
  {
    if (p == null)
    {
      RegSyntaxError.endItAll(
              "Null length pattern " + "followed by *, +, or other Multi.");
    }
    fewestMatches = a;
    mostMatches = b;
    sub = p;
    step = p.countMinChars().intValue();
    sub.setParent(null);
  }

  public String toString()
  {
    return sub.toString() + "{" + fewestMatches + "," + mostMatches + "}"
            + (matchFewest ? "?" : "") + "(?# <= fast multi)"
            + nextString();
  }

  int step = -1;

  public int matchInternal(int pos, Pthings pt)
  {
    int m = -1;
    int i = pos;
    int endstr = pt.src.length() - step;
    patInt matches = new patInt(0);
    if (matchFewest)
    {
      if (fewestMatches.lessEq(matches))
      {
        int ii = nextMatch(i, pt);
        if (ii >= 0)
        {
          return ii;
        }
      }
      while (i >= 0 && i <= endstr)
      {
        i = sub.matchInternal(i, pt);
        if (i >= 0)
        {
          matches.inc();
          if (fewestMatches.lessEq(matches))
          {
            int ii = nextMatch(i, pt);
            if (ii >= 0)
            {
              return ii;
            }
          }
          if (matches.equals(mostMatches))
          {
            return -1;
          }
        }
      }
      return -1;
    }
    int nMatches = 0;
    while (fewestMatches.intValue() > nMatches)
    {
      i = sub.matchInternal(i, pt);
      if (i >= 0)
      {
        nMatches++;
      }
      else
      {
        return -1;
      }
    }
    m = i;
    if (mostMatches.finite())
    {
      while (nMatches < mostMatches.intValue())
      {
        i = sub.matchInternal(i, pt);
        if (i >= 0)
        {
          m = i;
          nMatches++;
        }
        else
        {
          break;
        }
      }
    }
    else
    {
      while (true)
      {
        i = sub.matchInternal(i, pt);
        if (i >= 0)
        {
          m = i;
          nMatches++;
        }
        else
        {
          break;
        }
      }
    }
    while (m >= pos)
    {
      int r = nextMatch(m, pt);
      if (r >= 0)
      {
        return r;
      }
      m -= step;
      nMatches--;
      if (nMatches < fewestMatches.intValue())
      {
        return -1;
      }
    }
    return -1;
  }

  public Pattern clone1(Hashtable h)
  {
    try
    {
      FastMulti fm = new FastMulti(fewestMatches, mostMatches,
              sub.clone(h));
      fm.matchFewest = matchFewest;
      return fm;
    } catch (RegSyntax rs)
    {
      return null;
    }
  }
}
