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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

// Referenced classes of package org.apache.commons.codec.language.bm:
//            NameType, RuleType, Lang, Rule

public class PhoneticEngine
{
    static final class PhonemeBuilder
    {

        private final Set phonemes;

        public static PhonemeBuilder empty(Languages.LanguageSet languageset)
        {
            return new PhonemeBuilder(new Rule.Phoneme("", languageset));
        }

        public void append(CharSequence charsequence)
        {
            for (Iterator iterator = phonemes.iterator(); iterator.hasNext(); ((Rule.Phoneme)iterator.next()).append(charsequence)) { }
        }

        public void apply(Rule.PhonemeExpr phonemeexpr, int i)
        {
            LinkedHashSet linkedhashset;
            Iterator iterator;
            linkedhashset = new LinkedHashSet(i);
            iterator = phonemes.iterator();
_L2:
            Rule.Phoneme phoneme;
            Iterator iterator1;
            if (!iterator.hasNext())
            {
                break; /* Loop/switch isn't completed */
            }
            phoneme = (Rule.Phoneme)iterator.next();
            iterator1 = phonemeexpr.getPhonemes().iterator();
_L4:
            if (!iterator1.hasNext()) goto _L2; else goto _L1
_L1:
            Rule.Phoneme phoneme1;
            Languages.LanguageSet languageset;
            phoneme1 = (Rule.Phoneme)iterator1.next();
            languageset = phoneme.getLanguages().restrictTo(phoneme1.getLanguages());
            if (languageset.isEmpty()) goto _L4; else goto _L3
_L3:
            phoneme1 = new Rule.Phoneme(phoneme, phoneme1, languageset);
            if (linkedhashset.size() >= i) goto _L4; else goto _L5
_L5:
            linkedhashset.add(phoneme1);
            if (linkedhashset.size() < i) goto _L4; else goto _L6
_L6:
            phonemes.clear();
            phonemes.addAll(linkedhashset);
            return;
        }

        public Set getPhonemes()
        {
            return phonemes;
        }

        public String makeString()
        {
            StringBuilder stringbuilder = new StringBuilder();
            Rule.Phoneme phoneme;
            for (Iterator iterator = phonemes.iterator(); iterator.hasNext(); stringbuilder.append(phoneme.getPhonemeText()))
            {
                phoneme = (Rule.Phoneme)iterator.next();
                if (stringbuilder.length() > 0)
                {
                    stringbuilder.append("|");
                }
            }

            return stringbuilder.toString();
        }

        private PhonemeBuilder(Set set)
        {
            phonemes = set;
        }


        private PhonemeBuilder(Rule.Phoneme phoneme)
        {
            phonemes = new LinkedHashSet();
            phonemes.add(phoneme);
        }
    }

    private static final class RulesApplication
    {

        private final Map finalRules;
        private boolean found;
        private int i;
        private final CharSequence input;
        private final int maxPhonemes;
        private PhonemeBuilder phonemeBuilder;

        public int getI()
        {
            return i;
        }

        public PhonemeBuilder getPhonemeBuilder()
        {
            return phonemeBuilder;
        }

        public RulesApplication invoke()
        {
            int j;
label0:
            {
                found = false;
                j = 1;
                int k = 1;
                Object obj = (List)finalRules.get(input.subSequence(i, i + 1));
                if (obj == null)
                {
                    break label0;
                }
                obj = ((List) (obj)).iterator();
                j = k;
                Rule rule;
                do
                {
                    if (!((Iterator) (obj)).hasNext())
                    {
                        break label0;
                    }
                    rule = (Rule)((Iterator) (obj)).next();
                    k = rule.getPattern().length();
                    j = k;
                } while (!rule.patternAndContextMatches(input, i));
                phonemeBuilder.apply(rule.getPhoneme(), maxPhonemes);
                found = true;
                j = k;
            }
            if (!found)
            {
                j = 1;
            }
            i = i + j;
            return this;
        }

        public boolean isFound()
        {
            return found;
        }

        public RulesApplication(Map map, CharSequence charsequence, PhonemeBuilder phonemebuilder, int j, int k)
        {
            if (map == null)
            {
                throw new NullPointerException("The finalRules argument must not be null");
            } else
            {
                finalRules = map;
                phonemeBuilder = phonemebuilder;
                input = charsequence;
                i = j;
                maxPhonemes = k;
                return;
            }
        }
    }


    private static final int DEFAULT_MAX_PHONEMES = 20;
    private static final Map NAME_PREFIXES;
    private final boolean concat;
    private final Lang lang;
    private final int maxPhonemes;
    private final NameType nameType;
    private final RuleType ruleType;

    public PhoneticEngine(NameType nametype, RuleType ruletype, boolean flag)
    {
        this(nametype, ruletype, flag, 20);
    }

    public PhoneticEngine(NameType nametype, RuleType ruletype, boolean flag, int i)
    {
        if (ruletype == RuleType.RULES)
        {
            throw new IllegalArgumentException((new StringBuilder()).append("ruleType must not be ").append(RuleType.RULES).toString());
        } else
        {
            nameType = nametype;
            ruleType = ruletype;
            concat = flag;
            lang = Lang.instance(nametype);
            maxPhonemes = i;
            return;
        }
    }

    private PhonemeBuilder applyFinalRules(PhonemeBuilder phonemebuilder, Map map)
    {
        if (map == null)
        {
            throw new NullPointerException("finalRules can not be null");
        }
        if (map.isEmpty())
        {
            return phonemebuilder;
        }
        TreeMap treemap = new TreeMap(Rule.Phoneme.COMPARATOR);
        for (Iterator iterator = phonemebuilder.getPhonemes().iterator(); iterator.hasNext();)
        {
            Object obj = (Rule.Phoneme)iterator.next();
            phonemebuilder = PhonemeBuilder.empty(((Rule.Phoneme) (obj)).getLanguages());
            obj = ((Rule.Phoneme) (obj)).getPhonemeText().toString();
            RulesApplication rulesapplication;
            for (int i = 0; i < ((String) (obj)).length(); i = rulesapplication.getI())
            {
                rulesapplication = (new RulesApplication(map, ((CharSequence) (obj)), phonemebuilder, i, maxPhonemes)).invoke();
                boolean flag = rulesapplication.isFound();
                phonemebuilder = rulesapplication.getPhonemeBuilder();
                if (!flag)
                {
                    phonemebuilder.append(((String) (obj)).subSequence(i, i + 1));
                }
            }

            phonemebuilder = phonemebuilder.getPhonemes().iterator();
            while (phonemebuilder.hasNext()) 
            {
                Rule.Phoneme phoneme = (Rule.Phoneme)phonemebuilder.next();
                if (treemap.containsKey(phoneme))
                {
                    phoneme = ((Rule.Phoneme)treemap.remove(phoneme)).mergeWithLanguage(phoneme.getLanguages());
                    treemap.put(phoneme, phoneme);
                } else
                {
                    treemap.put(phoneme, phoneme);
                }
            }
        }

        return new PhonemeBuilder(treemap.keySet());
    }

    private static String join(Iterable iterable, String s)
    {
        StringBuilder stringbuilder = new StringBuilder();
        iterable = iterable.iterator();
        if (iterable.hasNext())
        {
            stringbuilder.append((String)iterable.next());
        }
        for (; iterable.hasNext(); stringbuilder.append(s).append((String)iterable.next())) { }
        return stringbuilder.toString();
    }

    public String encode(String s)
    {
        return encode(s, lang.guessLanguages(s));
    }

    public String encode(String s, Languages.LanguageSet languageset)
    {
        Map map1;
        Map map2;
        Object obj;
        Map map;
label0:
        {
            map = Rule.getInstanceMap(nameType, RuleType.RULES, languageset);
            map1 = Rule.getInstanceMap(nameType, ruleType, "common");
            map2 = Rule.getInstanceMap(nameType, ruleType, languageset);
            obj = s.toLowerCase(Locale.ENGLISH).replace('-', ' ').trim();
            if (nameType != NameType.GENERIC)
            {
                break label0;
            }
            if (((String) (obj)).length() >= 2 && ((String) (obj)).substring(0, 2).equals("d'"))
            {
                s = ((String) (obj)).substring(2);
                languageset = (new StringBuilder()).append("d").append(s).toString();
                return (new StringBuilder()).append("(").append(encode(s)).append(")-(").append(encode(((String) (languageset)))).append(")").toString();
            }
            Iterator iterator = ((Set)NAME_PREFIXES.get(nameType)).iterator();
            do
            {
                if (!iterator.hasNext())
                {
                    break label0;
                }
                s = (String)iterator.next();
            } while (!((String) (obj)).startsWith((new StringBuilder()).append(s).append(" ").toString()));
            languageset = ((String) (obj)).substring(s.length() + 1);
            s = (new StringBuilder()).append(s).append(languageset).toString();
            return (new StringBuilder()).append("(").append(encode(((String) (languageset)))).append(")-(").append(encode(s)).append(")").toString();
        }
        obj = Arrays.asList(((String) (obj)).split("\\s+"));
        s = new ArrayList();
        static class _cls1
        {

            static final int $SwitchMap$org$apache$commons$codec$language$bm$NameType[];

            static 
            {
                $SwitchMap$org$apache$commons$codec$language$bm$NameType = new int[NameType.values().length];
                try
                {
                    $SwitchMap$org$apache$commons$codec$language$bm$NameType[NameType.SEPHARDIC.ordinal()] = 1;
                }
                catch (NoSuchFieldError nosuchfielderror2) { }
                try
                {
                    $SwitchMap$org$apache$commons$codec$language$bm$NameType[NameType.ASHKENAZI.ordinal()] = 2;
                }
                catch (NoSuchFieldError nosuchfielderror1) { }
                try
                {
                    $SwitchMap$org$apache$commons$codec$language$bm$NameType[NameType.GENERIC.ordinal()] = 3;
                }
                catch (NoSuchFieldError nosuchfielderror)
                {
                    return;
                }
            }
        }

        int i;
        switch (_cls1..SwitchMap.org.apache.commons.codec.language.bm.NameType[nameType.ordinal()])
        {
        default:
            throw new IllegalStateException((new StringBuilder()).append("Unreachable case: ").append(nameType).toString());

        case 1: // '\001'
            String as[];
            for (Iterator iterator1 = ((List) (obj)).iterator(); iterator1.hasNext(); s.add(as[as.length - 1]))
            {
                as = ((String)iterator1.next()).split("'");
            }

            s.removeAll((Collection)NAME_PREFIXES.get(nameType));
            break;

        case 2: // '\002'
            s.addAll(((Collection) (obj)));
            s.removeAll((Collection)NAME_PREFIXES.get(nameType));
            continue;

        case 3: // '\003'
            s.addAll(((Collection) (obj)));
            continue;
        }
        break;
        do
        {
            if (concat)
            {
                s = join(s, " ");
            } else
            if (s.size() == 1)
            {
                s = (String)((List) (obj)).iterator().next();
            } else
            {
                languageset = new StringBuilder();
                String s1;
                for (s = s.iterator(); s.hasNext(); languageset.append("-").append(encode(s1)))
                {
                    s1 = (String)s.next();
                }

                return languageset.substring(1);
            }
            languageset = PhonemeBuilder.empty(languageset);
            for (i = 0; i < s.length();)
            {
                languageset = (new RulesApplication(map, s, languageset, i, maxPhonemes)).invoke();
                i = languageset.getI();
                languageset = languageset.getPhonemeBuilder();
            }

            return applyFinalRules(applyFinalRules(languageset, map1), map2).makeString();
        } while (true);
    }

    public Lang getLang()
    {
        return lang;
    }

    public int getMaxPhonemes()
    {
        return maxPhonemes;
    }

    public NameType getNameType()
    {
        return nameType;
    }

    public RuleType getRuleType()
    {
        return ruleType;
    }

    public boolean isConcat()
    {
        return concat;
    }

    static 
    {
        NAME_PREFIXES = new EnumMap(org/apache/commons/codec/language/bm/NameType);
        NAME_PREFIXES.put(NameType.ASHKENAZI, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[] {
            "bar", "ben", "da", "de", "van", "von"
        }))));
        NAME_PREFIXES.put(NameType.SEPHARDIC, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[] {
            "al", "el", "da", "dal", "de", "del", "dela", "de la", "della", "des", 
            "di", "do", "dos", "du", "van", "von"
        }))));
        NAME_PREFIXES.put(NameType.GENERIC, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[] {
            "da", "dal", "de", "del", "dela", "de la", "della", "des", "di", "do", 
            "dos", "du", "van", "von"
        }))));
    }
}