//
// 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 com.stevesoft.pat.wrap.*;

/** Internally used class. */
class RegHolder
{
  Regex me = null;
  RegHolder prev = null;
}

/** Internally used class.
 * @see CodeRule
 */
class CodeVal
{
  int pos;
  char code;
  CodeVal(int p, char c)
  {
    pos = p;
    code = c;
  }

  public String toString()
  {
    return "(" + pos + "," + code + ")";
  }
}

/**
  To use this class, first use either the getReplacer() method from
  Transformer or Regex.  You can then use replaceAll, replaceFirst,
  etc. methods on the Replacer in the same way that you can from
  either of those two classes.
  <p>
  The only potential difference between using the methods of
  Replacer to do the replacing is that Replacer remembers changes
  to the replacing object between calls to replaceAll, replaceFirst
  etc.  For details, see the example file
  <a href="http://javaregex.com/code/trans3.java.html">trans3.java</a>.
  @see com.stevesoft.pat.Transformer
  @see com.stevesoft.pat.Regex
 */
public class Replacer
{
  boolean first;

  /** Instantiate a new Replacer. */
  public Replacer()
  {}

  public StringLike replaceFirstRegion(String s, Regex r,
                                       int start, int end)
  {
    return replaceFirstRegion(new StringWrap(s), r, start, end);
  }

  /** This method replaces the first occurence of the Regex in the
      String starting with position pos
      according to the Replacer rule of this object. */
  public StringLike replaceFirstRegion(StringLike s, Regex r,
                                       int start, int end)
  {
    first = true;
    rh.me = r;
    rh.prev = null;
    return dorep(s, start, end);
  }

  public StringLike replaceFirst(StringLike s)
  {
    return replaceFirstRegion(s, 0, s.length());
  }

  public StringLike replaceFirstFrom(StringLike s, int start)
  {
    return replaceFirstRegion(s, start, s.length());
  }

  public StringLike replaceFirstRegion(StringLike s, int start, int end)
  {
    first = true;
    return dorep(s, start, end);
  }

  RegHolder rh = new RegHolder();

  public StringLike replaceAllRegion(String s, Regex r,
                                     int start, int end)
  {
    return replaceAllRegion(new StringWrap(s), r, start, end);
  }

  /** This method replaces all occurences of the Regex in the
      String starting with postition pos
      according to the Replacer rule of this object. */
  public StringLike replaceAllRegion(StringLike s, Regex r,
                                     int start, int end)
  {
    first = false;
    // reset
    rh.me = r;
    rh.prev = null;
    return dorep(s, start, end);
  }

  public StringLike replaceAll(StringLike s)
  {
    return replaceAllRegion(s, 0, s.length());
  }

  public StringLike replaceAllFrom(StringLike s, int start)
  {
    return replaceAllRegion(s, start, s.length());
  }

  public StringLike replaceAllRegion(StringLike s, int start, int end)
  {
    first = false;
    return dorep(s, start, end);
  }

  public String replaceAll(String s)
  {
    return replaceAllRegion(new StringWrap(s), 0, s.length()).toString();
  }

  public String replaceAllFrom(String s, int start)
  {
    return replaceAllRegion(new StringWrap(s), start, s.length()).toString();
  }

  public String replaceAllRegion(String s, int start, int end)
  {
    first = false;
    return dorep(new StringWrap(s), start, end).toString();
  }

  final public boolean isSpecial(ReplaceRule x)
  {
    while (x != null)
    {
      if (x instanceof SpecialRule
          ||
          (x instanceof RuleHolder && ( (RuleHolder) x).held instanceof SpecialRule))
      {
        return true;
      }
      x = x.next;
    }
    return false;
  }

  final public void apply1(RegRes rr)
  {
    rr.charsMatched_++;
    apply(rr, null);
    rr.charsMatched_--;
  }

  final StringLike dorep(StringLike s, int start, int end)
  {
    StringLike ret = s;
    want_more_text = false;
    lastMatchedTo = 0;
    if (rh.me == null)
    {
      throw new NullPointerException("Replacer has null Regex pointer");
    }
    if (rh.me._search(s, start, end))
    {
      int rmn = rh.me.matchedTo();
      if (rh.me.charsMatched() == 0 && !isSpecial(rh.me.getReplaceRule()))
      {
        apply1(rh.me);
        rmn++;
      }
      apply(rh.me);
      if (!first)
      {
        for (int i = rmn;
             !want_more_text && rh.me._search(s, i, end); i = rmn)
        {
          rmn = rh.me.matchedTo();
          if (rh.me.charsMatched() == 0)
          {
            if (!isSpecial(rh.me.getReplaceRule()))
            {
              apply1(rh.me);
            }
            rmn++;
          }
          apply(rh.me);
        }
      }
      ret = finish();
      ret = ret == null ? s : ret;
    }
    return ret;
  }

  StringBufferLike sb = null;
  StringLike src = null;
  int pos = 0;
  /** This method allows you to apply the results of several
      matches in a sequence to modify a String of text.  Each
      call in the sequence must operate on the same piece of
      text and the matchedFrom() of each RegRes given to this
      method must be greater in value than the preceeding
      RegRes's matchedTo() value.
   */
  public void apply(RegRes r, ReplaceRule rp)
  {
    if (rp == null || (rp.next == null && rp instanceof AmpersandRule))
    {
      return;
    }
    if (r.didMatch())
    {
      if (src == null)
      {
        src = r.getStringLike();
      }
      if (sb == null)
      {
        sb = new StringBufferLike(src.newStringBufferLike());
      }
      int rmf = r.matchedFrom();
      for (int ii = pos; ii < rmf; ii++)
      {
        sb.append(src.charAt(ii));
      }

      for (ReplaceRule x = rp; x != null; x = x.next)
      {
        x.apply(sb, r);
        if (x instanceof SpecialRule)
        {
          if (x instanceof WantMoreTextReplaceRule
              && want_more_text_enable)
          {
            want_more_text = true;
          }
          else if (x instanceof PushRule)
          {
            RegHolder rh2 = new RegHolder();
            rh2.me = ( (PushRule) x).NewRule;
            rh2.prev = rh;
            rh = rh2;
          }
          else if (x instanceof PopRule)
          {
            if (rh.prev != null)
            {
              rh = rh.prev;
            }
          }
          else if (x instanceof ChangeRule)
          {
            rh.me = ( (ChangeRule) x).NewRule;
          }
        }
      }
      if (!want_more_text)
      {
        pos = r.matchedTo();
      }
    }
  }

  boolean want_more_text = false, want_more_text_enable = false;
  public boolean WantMoreText()
  {
    return want_more_text;
  }

  /** Another form of apply, it is the same as
      apply(r,r.getReplaceRule()). */
  public void apply(Regex r)
  {
    apply(r, r.getReplaceRule());
  }

  /** This finishes the replacement, appending the right() part of
      the last RegRes given to substitute(RegRes).  After this method
      is called, the Replace object is reset to perform another
      substitution. If no RegRes objects with a true didMatch are
      applied, this returns null. */
  public StringLike finish()
  {
    if (src == null)
    {
      return null;
    }
    //sb.append(src.substring(pos,src.length()));
    int s_end = src.length();
    for (int ii = pos; ii < s_end; ii++)
    {
      sb.append(src.charAt(ii));
    }
    src = null;
    lastMatchedTo = pos;
    pos = 0;
    StringLike retstr = sb.toStringLike();
    sb = null;
    return retstr;
  }

  int lastMatchedTo = 0;
  public Object clone()
  {
    Replacer r = new Replacer();
    r.first = first;
    r.src = src;
    r.sb = sb;
    r.pos = pos;
    r.lastMatchedTo = lastMatchedTo;
    r.want_more_text = want_more_text;
    r.want_more_text_enable = want_more_text_enable;
    r.rh.me = rh.me;
    r.rh.prev = rh.prev;
    return r;
  }

  public int lastMatchedTo()
  {
    return lastMatchedTo;
  }

  public Regex getRegex()
  {
    return rh.me;
  }

  public void setSource(StringLike sl)
  {
    src = sl;
  }

  public void setBuffer(StringBufferLike sbl)
  {
    sb = sbl;
  }

  public void setPos(int pos)
  {
    this.pos = pos;
  }
}