// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package org.apache.commons.lang3.text;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.lang3.StringUtils;

// Referenced classes of package org.apache.commons.lang3.text:
//            StrMatcher, StrLookup, StrBuilder

public class StrSubstitutor
{

    public static final char DEFAULT_ESCAPE = 36;
    public static final StrMatcher DEFAULT_PREFIX = StrMatcher.stringMatcher("${");
    public static final StrMatcher DEFAULT_SUFFIX = StrMatcher.stringMatcher("}");
    public static final StrMatcher DEFAULT_VALUE_DELIMITER = StrMatcher.stringMatcher(":-");
    private boolean enableSubstitutionInVariables;
    private char escapeChar;
    private StrMatcher prefixMatcher;
    private StrMatcher suffixMatcher;
    private StrMatcher valueDelimiterMatcher;
    private StrLookup variableResolver;

    public StrSubstitutor()
    {
        this((StrLookup)null, DEFAULT_PREFIX, DEFAULT_SUFFIX, '$');
    }

    public StrSubstitutor(Map map)
    {
        this(StrLookup.mapLookup(map), DEFAULT_PREFIX, DEFAULT_SUFFIX, '$');
    }

    public StrSubstitutor(Map map, String s, String s1)
    {
        this(StrLookup.mapLookup(map), s, s1, '$');
    }

    public StrSubstitutor(Map map, String s, String s1, char c)
    {
        this(StrLookup.mapLookup(map), s, s1, c);
    }

    public StrSubstitutor(Map map, String s, String s1, char c, String s2)
    {
        this(StrLookup.mapLookup(map), s, s1, c, s2);
    }

    public StrSubstitutor(StrLookup strlookup)
    {
        this(strlookup, DEFAULT_PREFIX, DEFAULT_SUFFIX, '$');
    }

    public StrSubstitutor(StrLookup strlookup, String s, String s1, char c)
    {
        setVariableResolver(strlookup);
        setVariablePrefix(s);
        setVariableSuffix(s1);
        setEscapeChar(c);
        setValueDelimiterMatcher(DEFAULT_VALUE_DELIMITER);
    }

    public StrSubstitutor(StrLookup strlookup, String s, String s1, char c, String s2)
    {
        setVariableResolver(strlookup);
        setVariablePrefix(s);
        setVariableSuffix(s1);
        setEscapeChar(c);
        setValueDelimiter(s2);
    }

    public StrSubstitutor(StrLookup strlookup, StrMatcher strmatcher, StrMatcher strmatcher1, char c)
    {
        this(strlookup, strmatcher, strmatcher1, c, DEFAULT_VALUE_DELIMITER);
    }

    public StrSubstitutor(StrLookup strlookup, StrMatcher strmatcher, StrMatcher strmatcher1, char c, StrMatcher strmatcher2)
    {
        setVariableResolver(strlookup);
        setVariablePrefixMatcher(strmatcher);
        setVariableSuffixMatcher(strmatcher1);
        setEscapeChar(c);
        setValueDelimiterMatcher(strmatcher2);
    }

    private void checkCyclicSubstitution(String s, List list)
    {
        if (!list.contains(s))
        {
            return;
        } else
        {
            s = new StrBuilder(256);
            s.append("Infinite loop in property interpolation of ");
            s.append((String)list.remove(0));
            s.append(": ");
            s.appendWithSeparators(list, "->");
            throw new IllegalStateException(s.toString());
        }
    }

    public static String replace(Object obj, Map map)
    {
        return (new StrSubstitutor(map)).replace(obj);
    }

    public static String replace(Object obj, Map map, String s, String s1)
    {
        return (new StrSubstitutor(map, s, s1)).replace(obj);
    }

    public static String replace(Object obj, Properties properties)
    {
        if (properties == null)
        {
            return obj.toString();
        }
        HashMap hashmap = new HashMap();
        String s;
        for (Enumeration enumeration = properties.propertyNames(); enumeration.hasMoreElements(); hashmap.put(s, properties.getProperty(s)))
        {
            s = (String)enumeration.nextElement();
        }

        return replace(obj, ((Map) (hashmap)));
    }

    public static String replaceSystemProperties(Object obj)
    {
        return (new StrSubstitutor(StrLookup.systemPropertiesLookup())).replace(obj);
    }

    private int substitute(StrBuilder strbuilder, int i, int j, List list)
    {
        Object obj2;
        StrMatcher strmatcher;
        StrMatcher strmatcher1;
        StrMatcher strmatcher2;
        int l;
        int i1;
        int j1;
        boolean flag;
        boolean flag1;
        int l1;
        int i2;
        char c;
        boolean flag2;
        strmatcher = getVariablePrefixMatcher();
        strmatcher1 = getVariableSuffixMatcher();
        c = getEscapeChar();
        strmatcher2 = getValueDelimiterMatcher();
        flag2 = isEnableSubstitutionInVariables();
        char ac[];
        if (list == null)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        flag = false;
        j1 = 0;
        ac = strbuilder.buffer;
        i1 = i + j;
        l = i;
        obj2 = list;
        list = ac;
_L14:
        l1 = l;
        if (l1 >= i1) goto _L2; else goto _L1
_L1:
        int k;
        int k1;
        i2 = strmatcher.isMatch(list, l1, i, i1);
        if (i2 == 0)
        {
            l = l1 + 1;
            continue; /* Loop/switch isn't completed */
        }
        if (l1 > i && list[l1 - 1] == c)
        {
            strbuilder.deleteCharAt(l1 - 1);
            list = strbuilder.buffer;
            j1--;
            flag = true;
            i1--;
            l = l1;
            continue; /* Loop/switch isn't completed */
        }
        k = l1 + i2;
        k1 = 0;
_L12:
        l = k;
        if (k >= i1)
        {
            continue; /* Loop/switch isn't completed */
        }
        if (flag2)
        {
            l = strmatcher.isMatch(list, k, i, i1);
            if (l != 0)
            {
                k1++;
                k += l;
                continue; /* Loop/switch isn't completed */
            }
        }
        l = strmatcher1.isMatch(list, k, i, i1);
        if (l == 0)
        {
            k++;
            continue; /* Loop/switch isn't completed */
        }
        if (k1 != 0) goto _L4; else goto _L3
_L3:
        Object obj;
        Object obj1;
        Object obj3;
        Object obj4;
        Object obj5;
        obj = new String(list, l1 + i2, k - l1 - i2);
        obj1 = obj;
        if (flag2)
        {
            obj = new StrBuilder(((String) (obj)));
            substitute(((StrBuilder) (obj)), 0, ((StrBuilder) (obj)).length());
            obj1 = ((StrBuilder) (obj)).toString();
        }
        i2 = k + l;
        obj4 = obj1;
        obj5 = null;
        obj = obj5;
        obj3 = obj4;
        if (strmatcher2 == null) goto _L6; else goto _L5
_L5:
        char ac1[];
        ac1 = ((String) (obj1)).toCharArray();
        k = 0;
_L11:
        obj = obj5;
        obj3 = obj4;
        if (k >= ac1.length) goto _L6; else goto _L7
_L7:
        if (flag2 || strmatcher.isMatch(ac1, k, k, ac1.length) == 0) goto _L9; else goto _L8
_L8:
        obj3 = obj4;
        obj = obj5;
_L6:
        obj1 = obj2;
        if (obj2 == null)
        {
            obj1 = new ArrayList();
            ((List) (obj1)).add(new String(list, i, j));
        }
        checkCyclicSubstitution(((String) (obj3)), ((List) (obj1)));
        ((List) (obj1)).add(obj3);
        obj3 = resolveVariable(((String) (obj3)), strbuilder, l1, i2);
        obj2 = obj3;
        if (obj3 == null)
        {
            obj2 = obj;
        }
        k1 = i1;
        k = j1;
        l = i2;
        if (obj2 != null)
        {
            k = ((String) (obj2)).length();
            strbuilder.replace(l1, i2, ((String) (obj2)));
            flag = true;
            k = (substitute(strbuilder, l1, k, ((List) (obj1))) + k) - (i2 - l1);
            l = i2 + k;
            k1 = i1 + k;
            k = j1 + k;
            list = strbuilder.buffer;
        }
        ((List) (obj1)).remove(((List) (obj1)).size() - 1);
        i1 = k1;
        j1 = k;
        obj2 = obj1;
        continue; /* Loop/switch isn't completed */
_L9:
        l = strmatcher2.isMatch(ac1, k);
        if (l == 0)
        {
            break; /* Loop/switch isn't completed */
        }
        obj3 = ((String) (obj1)).substring(0, k);
        obj = ((String) (obj1)).substring(k + l);
        if (true) goto _L6; else goto _L10
_L10:
        k++;
        if (true) goto _L11; else goto _L4
_L4:
        k1--;
        k += l;
        if (true) goto _L12; else goto _L2
_L2:
        if (flag1)
        {
            return !flag ? 0 : 1;
        }
        return j1;
        if (true) goto _L14; else goto _L13
_L13:
    }

    public char getEscapeChar()
    {
        return escapeChar;
    }

    public StrMatcher getValueDelimiterMatcher()
    {
        return valueDelimiterMatcher;
    }

    public StrMatcher getVariablePrefixMatcher()
    {
        return prefixMatcher;
    }

    public StrLookup getVariableResolver()
    {
        return variableResolver;
    }

    public StrMatcher getVariableSuffixMatcher()
    {
        return suffixMatcher;
    }

    public boolean isEnableSubstitutionInVariables()
    {
        return enableSubstitutionInVariables;
    }

    public String replace(CharSequence charsequence)
    {
        if (charsequence == null)
        {
            return null;
        } else
        {
            return replace(charsequence, 0, charsequence.length());
        }
    }

    public String replace(CharSequence charsequence, int i, int j)
    {
        if (charsequence == null)
        {
            return null;
        } else
        {
            charsequence = (new StrBuilder(j)).append(charsequence, i, j);
            substitute(charsequence, 0, j);
            return charsequence.toString();
        }
    }

    public String replace(Object obj)
    {
        if (obj == null)
        {
            return null;
        } else
        {
            obj = (new StrBuilder()).append(obj);
            substitute(((StrBuilder) (obj)), 0, ((StrBuilder) (obj)).length());
            return ((StrBuilder) (obj)).toString();
        }
    }

    public String replace(String s)
    {
        String s1;
        if (s == null)
        {
            s1 = null;
        } else
        {
            StrBuilder strbuilder = new StrBuilder(s);
            s1 = s;
            if (substitute(strbuilder, 0, s.length()))
            {
                return strbuilder.toString();
            }
        }
        return s1;
    }

    public String replace(String s, int i, int j)
    {
        if (s == null)
        {
            return null;
        }
        StrBuilder strbuilder = (new StrBuilder(j)).append(s, i, j);
        if (!substitute(strbuilder, 0, j))
        {
            return s.substring(i, i + j);
        } else
        {
            return strbuilder.toString();
        }
    }

    public String replace(StringBuffer stringbuffer)
    {
        if (stringbuffer == null)
        {
            return null;
        } else
        {
            stringbuffer = (new StrBuilder(stringbuffer.length())).append(stringbuffer);
            substitute(stringbuffer, 0, stringbuffer.length());
            return stringbuffer.toString();
        }
    }

    public String replace(StringBuffer stringbuffer, int i, int j)
    {
        if (stringbuffer == null)
        {
            return null;
        } else
        {
            stringbuffer = (new StrBuilder(j)).append(stringbuffer, i, j);
            substitute(stringbuffer, 0, j);
            return stringbuffer.toString();
        }
    }

    public String replace(StrBuilder strbuilder)
    {
        if (strbuilder == null)
        {
            return null;
        } else
        {
            strbuilder = (new StrBuilder(strbuilder.length())).append(strbuilder);
            substitute(strbuilder, 0, strbuilder.length());
            return strbuilder.toString();
        }
    }

    public String replace(StrBuilder strbuilder, int i, int j)
    {
        if (strbuilder == null)
        {
            return null;
        } else
        {
            strbuilder = (new StrBuilder(j)).append(strbuilder, i, j);
            substitute(strbuilder, 0, j);
            return strbuilder.toString();
        }
    }

    public String replace(char ac[])
    {
        if (ac == null)
        {
            return null;
        } else
        {
            StrBuilder strbuilder = (new StrBuilder(ac.length)).append(ac);
            substitute(strbuilder, 0, ac.length);
            return strbuilder.toString();
        }
    }

    public String replace(char ac[], int i, int j)
    {
        if (ac == null)
        {
            return null;
        } else
        {
            ac = (new StrBuilder(j)).append(ac, i, j);
            substitute(ac, 0, j);
            return ac.toString();
        }
    }

    public boolean replaceIn(StringBuffer stringbuffer)
    {
        if (stringbuffer == null)
        {
            return false;
        } else
        {
            return replaceIn(stringbuffer, 0, stringbuffer.length());
        }
    }

    public boolean replaceIn(StringBuffer stringbuffer, int i, int j)
    {
        StrBuilder strbuilder;
        if (stringbuffer != null)
        {
            if (substitute(strbuilder = (new StrBuilder(j)).append(stringbuffer, i, j), 0, j))
            {
                stringbuffer.replace(i, i + j, strbuilder.toString());
                return true;
            }
        }
        return false;
    }

    public boolean replaceIn(StringBuilder stringbuilder)
    {
        if (stringbuilder == null)
        {
            return false;
        } else
        {
            return replaceIn(stringbuilder, 0, stringbuilder.length());
        }
    }

    public boolean replaceIn(StringBuilder stringbuilder, int i, int j)
    {
        StrBuilder strbuilder;
        if (stringbuilder != null)
        {
            if (substitute(strbuilder = (new StrBuilder(j)).append(stringbuilder, i, j), 0, j))
            {
                stringbuilder.replace(i, i + j, strbuilder.toString());
                return true;
            }
        }
        return false;
    }

    public boolean replaceIn(StrBuilder strbuilder)
    {
        if (strbuilder == null)
        {
            return false;
        } else
        {
            return substitute(strbuilder, 0, strbuilder.length());
        }
    }

    public boolean replaceIn(StrBuilder strbuilder, int i, int j)
    {
        if (strbuilder == null)
        {
            return false;
        } else
        {
            return substitute(strbuilder, i, j);
        }
    }

    protected String resolveVariable(String s, StrBuilder strbuilder, int i, int j)
    {
        strbuilder = getVariableResolver();
        if (strbuilder == null)
        {
            return null;
        } else
        {
            return strbuilder.lookup(s);
        }
    }

    public void setEnableSubstitutionInVariables(boolean flag)
    {
        enableSubstitutionInVariables = flag;
    }

    public void setEscapeChar(char c)
    {
        escapeChar = c;
    }

    public StrSubstitutor setValueDelimiter(char c)
    {
        return setValueDelimiterMatcher(StrMatcher.charMatcher(c));
    }

    public StrSubstitutor setValueDelimiter(String s)
    {
        if (StringUtils.isEmpty(s))
        {
            setValueDelimiterMatcher(null);
            return this;
        } else
        {
            return setValueDelimiterMatcher(StrMatcher.stringMatcher(s));
        }
    }

    public StrSubstitutor setValueDelimiterMatcher(StrMatcher strmatcher)
    {
        valueDelimiterMatcher = strmatcher;
        return this;
    }

    public StrSubstitutor setVariablePrefix(char c)
    {
        return setVariablePrefixMatcher(StrMatcher.charMatcher(c));
    }

    public StrSubstitutor setVariablePrefix(String s)
    {
        if (s == null)
        {
            throw new IllegalArgumentException("Variable prefix must not be null!");
        } else
        {
            return setVariablePrefixMatcher(StrMatcher.stringMatcher(s));
        }
    }

    public StrSubstitutor setVariablePrefixMatcher(StrMatcher strmatcher)
    {
        if (strmatcher == null)
        {
            throw new IllegalArgumentException("Variable prefix matcher must not be null!");
        } else
        {
            prefixMatcher = strmatcher;
            return this;
        }
    }

    public void setVariableResolver(StrLookup strlookup)
    {
        variableResolver = strlookup;
    }

    public StrSubstitutor setVariableSuffix(char c)
    {
        return setVariableSuffixMatcher(StrMatcher.charMatcher(c));
    }

    public StrSubstitutor setVariableSuffix(String s)
    {
        if (s == null)
        {
            throw new IllegalArgumentException("Variable suffix must not be null!");
        } else
        {
            return setVariableSuffixMatcher(StrMatcher.stringMatcher(s));
        }
    }

    public StrSubstitutor setVariableSuffixMatcher(StrMatcher strmatcher)
    {
        if (strmatcher == null)
        {
            throw new IllegalArgumentException("Variable suffix matcher must not be null!");
        } else
        {
            suffixMatcher = strmatcher;
            return this;
        }
    }

    protected boolean substitute(StrBuilder strbuilder, int i, int j)
    {
        return substitute(strbuilder, i, j, null) > 0;
    }

}