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

/** ReplaceRule is a singly linked list of Objects which describe how
    to replace the matched portion of a String.  The only member method
    that you absolutely need to define to use this class is apply(StringBuffer,RegRes) --
    although you may want define toString1() and clone1() (if you are
    unhappy with the default methods) that are needed by
    the clone() or toString() methods on this class.
    During the replacement process, each ReplaceRule tells the replacer
    what to add to StringBuffer and uses the contents of the Regular
    expression result to get the information it needs to
    do this.  Here is an <a href="http://javaregex.com/code/fancy.java.html">example</a>

    @see com.stevesoft.pat.NullRule
    @see com.stevesoft.pat.AmpersandRule
    @see com.stevesoft.pat.BackRefRule
    @see com.stevesoft.pat.LeftRule
    @see com.stevesoft.pat.RightRule
    @see com.stevesoft.pat.StringRule
 */
public abstract class ReplaceRule
{
  /** points to the next ReplaceRule in the linked list. */
  protected ReplaceRule next = null;
  /** This function appends to the StringBufferLike the text you want
      to replaced the portion of the String last matched. */
  public abstract void apply(StringBufferLike sb, RegRes r);

  /** A rule describing how to clone only the current ReplaceRule,
      and none of the others in this linked list.  It is called by
      clone() for each item in the list. */
  public Object clone1()
  {
    return new RuleHolder(this);
  }

  public final Object clone()
  {
    ReplaceRule x = (ReplaceRule) clone1();
    ReplaceRule xsav = x;
    ReplaceRule y = this;
    while (y.next != null)
    {
      x.next = (ReplaceRule) y.next.clone1();
      x.name = y.name;
      x = x.next;
      y = y.next;
    }
    return xsav;
  }

  static ReplaceRule add(ReplaceRule head, ReplaceRule adding)
  {
    if (head == null)
    {
      return head = adding;
    }
    head.addRule(adding);
    return head;
  }

  public ReplaceRule add(ReplaceRule adding)
  {
    return add(this, adding);
  }

  /** Add another ReplaceRule to the linked list. */
  public void addRule(ReplaceRule r)
  {
    if (next == null)
    {
      next = r;
    }
    else
    {
      next.addRule(r);
    }
  }

  static Regex getvar = null;
  final static Regex getv()
  {
    // Thanks to Michael Jimenez for pointing out the need
    // to clone getvar rather than simply returning it.
    // Previously this was not thread safe.
    //if(getvar != null) return getvar;
    if (getvar != null)
    {
      return (Regex) getvar.clone();
    }
    getvar =
        new Regex(
            "(?:\\\\(\\d+)|" + // ref 1
            "\\$(?:" +
            "(\\d+)|" + // ref 2
            "(\\w+)|" + // ref 3
            "([&'`])|" + // ref 4
            "\\{(?:(\\d+)|" + // ref 5
            "([^\n}\\\\]+))}" + // ref 6
            ")|" +
            "\\\\([nrbtaef])|" + // ref 7
            "\\\\c([\u0000-\uFFFF])|" + // ref 8
            "\\\\x([A-Fa-f0-9]{2})|" + // ref 9
            "\\\\([\u0000-\uFFFF])" + // ref 10
            ")");
    getvar.optimize();
    return getvar;
  }

  /** Compile a ReplaceRule using the text that would go between
      the second and third /'s in a typical substitution pattern
      in Perl: s/ ... / <i>The argument to ReplaceRule.perlCode</i> /.
   */
  public static ReplaceRule perlCode(String s)
  {
    //String sav_backGs = Regex.backGs;
    //int sav_backGto = Regex.backGto;
    try
    {
      int mf = 0, mt = 0;
      Regex gv = getv();
      ReplaceRule head = null;
      Object tmp = null;
      while (gv.searchFrom(s, mt))
      {
        int off = Regex.BackRefOffset - 1;
        mf = gv.matchedFrom();
        if (mf > mt)
        {
          head = add(head,
                     new StringRule(s.substring(mt, mf)));
        }
        String var = null;
        if ( (var = gv.stringMatched(1 + off)) != null
            || (var = gv.stringMatched(2 + off)) != null
            || (var = gv.stringMatched(5 + off)) != null)
        {
          int d = 0;
          for (int i = 0; i < var.length(); i++)
          {
            d = 8 * d + (var.charAt(i) - '0');
          }
          if (var.length() == 1)
          {
            head = add(head, new BackRefRule(d));
          }
          else
          {
            head = new StringRule("" + (char) d);
          }
        }
        else if (
            (var = gv.stringMatched(10 + off)) != null)
        {
          if ("QELlUu".indexOf(var) >= 0)
          {
            head = add(head, new CodeRule(var.charAt(0)));
          }
          else
          {
            head = add(head, new StringRule(var));
          }
        }
        else if (
            (var = gv.stringMatched(3 + off)) != null
            || (var = gv.stringMatched(4 + off)) != null
            || (var = gv.stringMatched(6 + off)) != null)
        {
          String arg = "";
          int pc;
          if ( (pc = var.indexOf(':')) > 0)
          {
            arg = var.substring(pc + 1);
            var = var.substring(0, pc);
          }
          if (var.equals("&") || var.equals("MATCH"))
          {
            head = add(head, new AmpersandRule());
          }
          else if (var.equals("`") || var.equals("PREMATCH"))
          {
            head = add(head, new LeftRule());
          }
          else if (var.equals("'") || var.equals("POSTMATCH"))
          {
            head = add(head, new RightRule());
          }
          else if (var.equals("WANT_MORE_TEXT"))
          {
            head = add(head, new WantMoreTextReplaceRule());
          }
          else if (var.equals("POP"))
          {
            head = add(head, new PopRule());
          }
          else if (var.startsWith("+") && (tmp = defs.get(var.substring(1))) != null)
          {
            if (tmp instanceof Regex)
            {
              head = add(head, new PushRule(var.substring(1), (Regex) tmp));
            }
            else if (tmp instanceof Transformer)
            {
              head = add(head, new PushRule(var.substring(1), (Transformer) tmp));
            }
            else
            {
              head = add(head, new StringRule("${" + var + "}"));
            }
          }
          else if (var.startsWith("=") && (tmp = defs.get(var.substring(1))) != null)
          {
            if (tmp instanceof Regex)
            {
              head = add(head, new ChangeRule(var.substring(1), (Regex) tmp));
            }
            else if (tmp instanceof Transformer)
            {
              head = add(head,
                         new ChangeRule(var.substring(1), (Transformer) tmp));
            }
            else
            {
              head = add(head, new StringRule("${" + var + "}"));
            }
          }
          else if ( (tmp = defs.get(var)) != null)
          {
            if (tmp instanceof ReplaceRule)
            {
              ReplaceRule alt = ( (ReplaceRule) tmp).arg(arg);
              if (alt == null)
              {
                alt = ( (ReplaceRule) tmp);
              }
              head = add(head, (ReplaceRule) (alt.clone()));
            }
          }
          else // can't figure out how to transform this thing...
          {
            head = add(head, new StringRule("${" + var + "}"));
          }
        }
        else if (
            (var = gv.stringMatched(7 + off)) != null)
        {
          char c = var.charAt(0);
          if (c == 'n')
          {
            head = add(head, new StringRule("\n"));
          }
          else if (c == 't')
          {
            head = add(head, new StringRule("\t"));
          }
          else if (c == 'r')
          {
            head = add(head, new StringRule("\r"));
          }
          else if (c == 'b')
          {
            head = add(head, new StringRule("\r"));
          }
          else if (c == 'a')
          {
            head = add(head, new StringRule("" + (char) 7));
          }
          else if (c == 'e')
          {
            head = add(head, new StringRule("" + (char) 27));
          }
          else if (c == 'f')
          {
            head = add(head, new StringRule("" + (char) 12));
          }
        }
        else if (
            (var = gv.stringMatched(8 + off)) != null)
        {
          char c = var.charAt(0);
          if (c < Ctrl.cmap.length)
          {
            c = Ctrl.cmap[c];
          }
          head = add(head, new StringRule("" + c));
        }
        else if (
            (var = gv.stringMatched(9 + off)) != null)
        {
          int d =
              16 * getHexDigit(var.charAt(0)) +
              getHexDigit(var.charAt(1));
          head = add(head, new StringRule("" + (char) d));
        }
        mt = gv.matchedTo();
      }
      if (mt <= s.length())
      {
        head = add(head, new StringRule(s.substring(mt)));
      }
      return head;
    }
    finally
    {
      //Regex.backGs = sav_backGs;
      //Regex.backGto = sav_backGto;
    }
  }

  static Hashtable defs = new Hashtable();
  public static boolean isDefined(String s)
  {
    return defs.get(s) != null;
  }

  public static void define(String s, Regex r)
  {
    defs.put(s, r);
  }

  public static void define(String s, ReplaceRule r)
  {
    defs.put(s, r);
    r.name = s;
  }

  String name = getClass().getName();

  public static void define(String s, Transformer t)
  {
    defs.put(s, t);
  }

  public static void undefine(String s)
  {
    defs.remove(s);
  }

  /** This tells how to convert just the current element (and none
      of the other items in the linked list) to a String. This
      method is called by toString() for each item in the linked
      list. */
  public String toString1()
  {
    return "${" + name + "}";
  }

  /** Convert to a String. */
  public final String toString()
  {
    StringBuffer sb = new StringBuffer();
    sb.append(toString1());
    ReplaceRule rr = this.next;
    while (rr != null)
    {
      sb.append(rr.toString1());
      rr = rr.next;
    }
    return sb.toString();
  }

  /** Modified the behavior of a ReplaceRule by supplying
      an argument.  If a ReplaceRule named "foo" is defined
      and the pattern "s/x/${foo:5}/" is given to Regex.perlCode,
      then the "foo" the definition of "foo" will be retrieved
      and arg("5") will be called.  If the result is non-null,
      that is the ReplaceRule that will be used.  If the result
      is null, then the pattern works just as if it were
      "s/x/${foo}/".
      @see com.stevesoft.pat.Validator#arg(java.lang.String)
   */
  public ReplaceRule arg(String s)
  {
    return null;
  }

  static int getHexDigit(char c)
  {
    if (c >= '0' && c <= '9')
    {
      return c - '0';
    }
    if (c >= 'a' && c <= 'f')
    {
      return c - 'a' + 10;
    }
    return c - 'A' + 10;
  }
}