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

/**
 * Replacement rule used by the Transformer.
 * 
 * @see com.stevesoft.pat.Transformer
 */
class TransRepRule extends ReplaceRule
{
  Transformer t;

  TransRepRule(Transformer t)
  {
    this.t = t;
  }

  public String toString1()
  {
    return "";
  }

  public Object clone1()
  {
    return new TransRepRule(t);
  }

  public void apply(StringBufferLike sb, RegRes rr)
  {
    // get the ReplaceRule of the Regex that matched.
    next = t.tp.ra[t.tp.pn].getReplaceRule();
  }
}

/**
 * Sometimes you want to replace a whole bunch of things that might occur within
 * a single line of text. One efficient way to do this, both in terms of
 * performance and programming ease, is with Transformer. The Transformer
 * contains an array of Regex's and uses the Regex that matches earliest within
 * the text to do the replacing, if two Regex's match at the same time it uses
 * the one put in the Transformer first.
 * <p>
 * This feature can be used to prevent transformations from occurring in certain
 * regions. For example, if I add the rule s'//.*'$&' and then add the rule
 * s/hello/goodbye/ the Transformer will replace "hello" with "goodbye" except
 * when it occurs inside a double-slash style of comment. The transformation on
 * the comment goes first, does nothing, and precludes transformation on the
 * same region of text as the s/hello/goodbye/ rule.
 * <p>
 * So far, at least, this class does not have the capability of turning into a
 * giant robot :-)
 */
public class Transformer
{
  TransPat tp;

  Regex rp = new Regex();

  boolean auto_optimize;

  /**
   * Get a replacer to that works with the current Regex.
   * 
   * @see com.stevesoft.pat.Replacer
   */
  public Replacer getReplacer()
  {
    return rp.getReplacer();
  }

  /** Instantiate a new Transformer object. */
  public Transformer(boolean auto)
  {
    auto_optimize = auto;
    tp = new TransPat();
    rp.setReplaceRule(new TransRepRule(this));
    rp.thePattern = tp;
  }

  /** Add a new Regex to the set of Regex's. */
  public void add(Regex r)
  {
    if (auto_optimize)
    {
      r.optimize();
    }
    tp.ra[tp.ra_len++] = r;
    if (tp.ra.length == tp.ra_len)
    {
      Regex[] ra2 = new Regex[tp.ra_len + 10];
      for (int i = 0; i < tp.ra_len; i++)
      {
        ra2[i] = tp.ra[i];
      }
      tp.ra = ra2;
    }
    rp.numSubs_ = r.numSubs_ > rp.numSubs_ ? r.numSubs_ : rp.numSubs_;
  }

  /** Returns the number of Regex's in this Transformer. */
  public int patterns()
  {
    return tp.ra_len;
  }

  /** Get the Regex at position i in this Transformer. */
  public Regex getRegexAt(int i)
  {
    if (i >= tp.ra_len)
    {
      throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
    }
    if (i < 0)
    {
      throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
    }
    return tp.ra[i];
  }

  /** Set the Regex at position i in this Transformer. */
  public void setRegexAt(Regex rx, int i)
  {
    if (i >= tp.ra_len)
    {
      throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
    }
    if (i < 0)
    {
      throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
    }
    tp.ra[i] = rx;
  }

  /**
   * Add a new Regex by calling Regex.perlCode
   * 
   * @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
   */
  public void add(String rs)
  {
    Regex r = Regex.perlCode(rs);
    if (r == null)
    {
      throw new NullPointerException("bad pattern to Regex.perlCode: " + rs);
    }
    add(r);
  }

  /**
   * Add an array of Strings (which will be converted to Regex's via the
   * Regex.perlCode method.
   * 
   * @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
   */
  public void add(String[] array)
  {
    for (int i = 0; i < array.length; i++)
    {
      add(array[i]);
    }
  }

  /** Replace all matches in the current String. */
  public String replaceAll(String s)
  {
    return dorep(s, 0, s.length());
  }

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

  /** Replace all matching patterns beginning at position start. */
  public String replaceAllFrom(String s, int start)
  {
    return dorep(s, start, s.length());
  }

  /**
   * Replace all matching patterns beginning between the positions start and end
   * inclusive.
   */
  public String replaceAllRegion(String s, int start, int end)
  {
    return dorep(s, start, end);
  }

  Replacer repr = new Replacer();

  final StringLike dorep(StringLike s, int start, int end)
  {
    StringLike tfmd = repr.replaceAllRegion(s, rp, start, end);
    tp.lastMatchedTo = repr.lastMatchedTo;
    return tfmd;
  }

  final String dorep(String s, int start, int end)
  {
    return dorep(new StringWrap(s), start, end).toString();
  }

  /** Replace the first matching pattern in String s. */
  public String replaceFirst(String s)
  {
    return dorep(s, 0, s.length());
  }

  /**
   * Replace the first matching pattern after position start in String s.
   */
  public String replaceFirstFrom(String s, int start)
  {
    return dorep(s, start, s.length());
  }

  /**
   * Replace the first matching pattern that begins between start and end
   * inclusive.
   */
  public String replaceFirstRegion(String s, int start, int end)
  {
    return dorep(s, start, end);
  }
}
