// 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.codec.language;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import org.apache.commons.codec.EncoderException;
import org.apache.commons.codec.StringEncoder;

public class DaitchMokotoffSoundex
    implements StringEncoder
{
    private static final class Branch
    {

        private final StringBuilder builder;
        private String cachedString;
        private String lastReplacement;

        public Branch createBranch()
        {
            Branch branch = new Branch();
            branch.builder.append(toString());
            branch.lastReplacement = lastReplacement;
            return branch;
        }

        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (!(obj instanceof Branch))
            {
                return false;
            } else
            {
                return toString().equals(((Branch)obj).toString());
            }
        }

        public void finish()
        {
            while (builder.length() < 6) 
            {
                builder.append('0');
                cachedString = null;
            }
        }

        public int hashCode()
        {
            return toString().hashCode();
        }

        public void processNextReplacement(String s, boolean flag)
        {
            boolean flag1;
            if (lastReplacement == null || !lastReplacement.endsWith(s) || flag)
            {
                flag1 = true;
            } else
            {
                flag1 = false;
            }
            if (flag1 && builder.length() < 6)
            {
                builder.append(s);
                if (builder.length() > 6)
                {
                    builder.delete(6, builder.length());
                }
                cachedString = null;
            }
            lastReplacement = s;
        }

        public String toString()
        {
            if (cachedString == null)
            {
                cachedString = builder.toString();
            }
            return cachedString;
        }

        private Branch()
        {
            builder = new StringBuilder();
            lastReplacement = null;
            cachedString = null;
        }

    }

    private static final class Rule
    {

        private final String pattern;
        private final String replacementAtStart[];
        private final String replacementBeforeVowel[];
        private final String replacementDefault[];

        private boolean isVowel(char c)
        {
            return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
        }

        public int getPatternLength()
        {
            return pattern.length();
        }

        public String[] getReplacements(String s, boolean flag)
        {
            if (flag)
            {
                return replacementAtStart;
            }
            int i = getPatternLength();
            if (i < s.length())
            {
                flag = isVowel(s.charAt(i));
            } else
            {
                flag = false;
            }
            if (flag)
            {
                return replacementBeforeVowel;
            } else
            {
                return replacementDefault;
            }
        }

        public boolean matches(String s)
        {
            return s.startsWith(pattern);
        }

        public String toString()
        {
            return String.format("%s=(%s,%s,%s)", new Object[] {
                pattern, Arrays.asList(replacementAtStart), Arrays.asList(replacementBeforeVowel), Arrays.asList(replacementDefault)
            });
        }


        protected Rule(String s, String s1, String s2, String s3)
        {
            pattern = s;
            replacementAtStart = s1.split("\\|");
            replacementBeforeVowel = s2.split("\\|");
            replacementDefault = s3.split("\\|");
        }
    }


    private static final String COMMENT = "//";
    private static final String DOUBLE_QUOTE = "\"";
    private static final Map FOLDINGS;
    private static final int MAX_LENGTH = 6;
    private static final String MULTILINE_COMMENT_END = "*/";
    private static final String MULTILINE_COMMENT_START = "/*";
    private static final String RESOURCE_FILE = "org/apache/commons/codec/language/dmrules.txt";
    private static final Map RULES;
    private final boolean folding;

    public DaitchMokotoffSoundex()
    {
        this(true);
    }

    public DaitchMokotoffSoundex(boolean flag)
    {
        folding = flag;
    }

    private String cleanup(String s)
    {
        StringBuilder stringbuilder = new StringBuilder();
        s = s.toCharArray();
        int j = s.length;
        int i = 0;
        while (i < j) 
        {
            char c = s[i];
            if (!Character.isWhitespace(c))
            {
                char c1 = Character.toLowerCase(c);
                c = c1;
                if (folding)
                {
                    c = c1;
                    if (FOLDINGS.containsKey(Character.valueOf(c1)))
                    {
                        c = ((Character)FOLDINGS.get(Character.valueOf(c1))).charValue();
                    }
                }
                stringbuilder.append(c);
            }
            i++;
        }
        return stringbuilder.toString();
    }

    private static void parseRules(Scanner scanner, String s, Map map, Map map1)
    {
        boolean flag;
        int i;
        i = 0;
        flag = false;
_L2:
        if (!scanner.hasNextLine())
        {
            break; /* Loop/switch isn't completed */
        }
        int j = i + 1;
        Object obj2 = scanner.nextLine();
        Object obj = obj2;
        if (flag)
        {
            i = j;
            if (((String) (obj)).endsWith("*/"))
            {
                flag = false;
                i = j;
            }
            continue; /* Loop/switch isn't completed */
        }
        if (((String) (obj)).startsWith("/*"))
        {
            flag = true;
            i = j;
            continue; /* Loop/switch isn't completed */
        }
        i = ((String) (obj)).indexOf("//");
        Object obj1 = obj;
        if (i >= 0)
        {
            obj1 = ((String) (obj)).substring(0, i);
        }
        obj = ((String) (obj1)).trim();
        i = j;
        if (((String) (obj)).length() == 0)
        {
            continue; /* Loop/switch isn't completed */
        }
        if (((String) (obj)).contains("="))
        {
            String as1[] = ((String) (obj)).split("=");
            if (as1.length != 2)
            {
                throw new IllegalArgumentException((new StringBuilder()).append("Malformed folding statement split into ").append(as1.length).append(" parts: ").append(((String) (obj2))).append(" in ").append(s).toString());
            }
            obj = as1[0];
            as1 = as1[1];
            if (((String) (obj)).length() != 1 || as1.length() != 1)
            {
                throw new IllegalArgumentException((new StringBuilder()).append("Malformed folding statement - patterns are not single characters: ").append(((String) (obj2))).append(" in ").append(s).toString());
            }
            map1.put(Character.valueOf(((String) (obj)).charAt(0)), Character.valueOf(as1.charAt(0)));
            i = j;
            continue; /* Loop/switch isn't completed */
        }
        String as[] = ((String) (obj)).split("\\s+");
        if (as.length != 4)
        {
            throw new IllegalArgumentException((new StringBuilder()).append("Malformed rule statement split into ").append(as.length).append(" parts: ").append(((String) (obj2))).append(" in ").append(s).toString());
        }
        char c;
        try
        {
            obj2 = new Rule(stripQuotes(as[0]), stripQuotes(as[1]), stripQuotes(as[2]), stripQuotes(as[3]));
            c = ((Rule) (obj2)).pattern.charAt(0);
            as1 = (List)map.get(Character.valueOf(c));
        }
        // Misplaced declaration of an exception variable
        catch (Scanner scanner)
        {
            throw new IllegalStateException((new StringBuilder()).append("Problem parsing line '").append(j).append("' in ").append(s).toString(), scanner);
        }
        as = as1;
        if (as1 != null)
        {
            break MISSING_BLOCK_LABEL_458;
        }
        as = new ArrayList();
        map.put(Character.valueOf(c), as);
        as.add(obj2);
        i = j;
        if (true) goto _L2; else goto _L1
_L1:
    }

    private String[] soundex(String s, boolean flag)
    {
        if (s != null) goto _L2; else goto _L1
_L1:
        s = null;
_L8:
        return s;
_L2:
        LinkedHashSet linkedhashset;
        String s2;
        int i;
        int l;
        s2 = cleanup(s);
        linkedhashset = new LinkedHashSet();
        linkedhashset.add(new Branch());
        l = 0;
        i = 0;
_L4:
        char c;
        int k;
        int i1;
        if (i >= s2.length())
        {
            break MISSING_BLOCK_LABEL_426;
        }
        c = s2.charAt(i);
        if (!Character.isWhitespace(c))
        {
            break; /* Loop/switch isn't completed */
        }
        i1 = l;
        k = i;
_L6:
        i = k + 1;
        l = i1;
        if (true) goto _L4; else goto _L3
_L3:
        String s1;
        Object obj;
        s1 = s2.substring(i);
        obj = (List)RULES.get(Character.valueOf(c));
        k = i;
        i1 = l;
        if (obj == null) goto _L6; else goto _L5
_L5:
        Rule rule;
        boolean flag1;
        String as1[];
        Iterator iterator1;
        String s3;
        int j1;
        if (flag)
        {
            s = new ArrayList();
        } else
        {
            s = Collections.EMPTY_LIST;
        }
        obj = ((List) (obj)).iterator();
        do
        {
            k = i;
            if (!((Iterator) (obj)).hasNext())
            {
                break MISSING_BLOCK_LABEL_420;
            }
            rule = (Rule)((Iterator) (obj)).next();
        } while (!rule.matches(s1));
        if (flag)
        {
            s.clear();
        }
        if (l == 0)
        {
            flag1 = true;
        } else
        {
            flag1 = false;
        }
        as1 = rule.getReplacements(s1, flag1);
        if (as1.length > 1 && flag)
        {
            k = 1;
        } else
        {
            k = 0;
        }
        iterator1 = linkedhashset.iterator();
        if (!iterator1.hasNext())
        {
            break MISSING_BLOCK_LABEL_388;
        }
        obj = (Branch)iterator1.next();
        j1 = as1.length;
        i1 = 0;
        do
        {
            if (i1 >= j1)
            {
                break MISSING_BLOCK_LABEL_240;
            }
            s3 = as1[i1];
            Branch branch;
            if (k != 0)
            {
                branch = ((Branch) (obj)).createBranch();
            } else
            {
                branch = ((Branch) (obj));
            }
            if (l == 109 && c == 'n' || l == 110 && c == 'm')
            {
                flag1 = true;
            } else
            {
                flag1 = false;
            }
            branch.processNextReplacement(s3, flag1);
            if (!flag)
            {
                break MISSING_BLOCK_LABEL_240;
            }
            s.add(branch);
            i1++;
        } while (true);
        if (flag)
        {
            linkedhashset.clear();
            linkedhashset.addAll(s);
        }
        k = i + (rule.getPatternLength() - 1);
        i1 = c;
          goto _L6
        String as[] = new String[linkedhashset.size()];
        int j = 0;
        Iterator iterator = linkedhashset.iterator();
        do
        {
            s = as;
            if (!iterator.hasNext())
            {
                continue;
            }
            s = (Branch)iterator.next();
            s.finish();
            as[j] = s.toString();
            j++;
        } while (true);
        if (true) goto _L8; else goto _L7
_L7:
    }

    private static String stripQuotes(String s)
    {
        String s1 = s;
        if (s.startsWith("\""))
        {
            s1 = s.substring(1);
        }
        s = s1;
        if (s1.endsWith("\""))
        {
            s = s1.substring(0, s1.length() - 1);
        }
        return s;
    }

    public Object encode(Object obj)
        throws EncoderException
    {
        if (!(obj instanceof String))
        {
            throw new EncoderException("Parameter supplied to DaitchMokotoffSoundex encode is not of type java.lang.String");
        } else
        {
            return encode((String)obj);
        }
    }

    public String encode(String s)
    {
        if (s == null)
        {
            return null;
        } else
        {
            return soundex(s, false)[0];
        }
    }

    public String soundex(String s)
    {
        s = soundex(s, true);
        StringBuilder stringbuilder = new StringBuilder();
        int j = 0;
        int k = s.length;
        for (int i = 0; i < k; i++)
        {
            stringbuilder.append(s[i]);
            j++;
            if (j < s.length)
            {
                stringbuilder.append('|');
            }
        }

        return stringbuilder.toString();
    }

    static 
    {
        RULES = new HashMap();
        FOLDINGS = new HashMap();
        Object obj = org/apache/commons/codec/language/DaitchMokotoffSoundex.getClassLoader().getResourceAsStream("org/apache/commons/codec/language/dmrules.txt");
        if (obj == null)
        {
            throw new IllegalArgumentException("Unable to load resource: org/apache/commons/codec/language/dmrules.txt");
        }
        obj = new Scanner(((java.io.InputStream) (obj)), "UTF-8");
        parseRules(((Scanner) (obj)), "org/apache/commons/codec/language/dmrules.txt", RULES, FOLDINGS);
        ((Scanner) (obj)).close();
        for (Iterator iterator = RULES.entrySet().iterator(); iterator.hasNext(); Collections.sort((List)((java.util.Map.Entry)iterator.next()).getValue(), new Comparator() {

        public volatile int compare(Object obj1, Object obj2)
        {
            return compare((Rule)obj1, (Rule)obj2);
        }

        public int compare(Rule rule, Rule rule1)
        {
            return rule1.getPatternLength() - rule.getPatternLength();
        }

    })) { }
    }
}