// 
// Decompiled by Procyon v0.6.0
// 

package ch.randelshofer.fastdoubleparser.bte;

import java.util.Iterator;
import java.util.HashSet;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashSet;
import java.util.Set;

public interface ByteTrie
{
    default int match(final byte[] str) {
        return this.match(str, 0, str.length);
    }
    
    int match(final byte[] p0, final int p1, final int p2);
    
    default ByteTrie copyOf(final Set<String> set, final boolean ignoreCase) {
        switch (set.size()) {
            case 0: {
                return new ByteTrieOfNone();
            }
            case 1: {
                final String str = set.iterator().next();
                if (ignoreCase) {
                    switch (str.length()) {
                        case 0: {
                            return new ByteTrieOfNone();
                        }
                        case 1: {
                            final LinkedHashSet<String> newSet = new LinkedHashSet<String>();
                            newSet.add(str.toLowerCase());
                            newSet.add(str.toUpperCase());
                            if (newSet.size() != 1) {
                                return new ByteTrieOfFew(newSet);
                            }
                            if (newSet.iterator().next().getBytes(StandardCharsets.UTF_8).length == 1) {
                                return new ByteTrieOfOneSingleByte(newSet);
                            }
                            return new ByteTrieOfOne(newSet);
                        }
                        default: {
                            return new ByteTrieOfFewIgnoreCase(set);
                        }
                    }
                }
                else {
                    if (set.iterator().next().getBytes(StandardCharsets.UTF_8).length == 1) {
                        return new ByteTrieOfOneSingleByte(set);
                    }
                    return new ByteTrieOfOne(set);
                }
                break;
            }
            default: {
                if (ignoreCase) {
                    return new ByteTrieOfFewIgnoreCase(set);
                }
                return new ByteTrieOfFew(set);
            }
        }
    }
    
    default ByteTrie copyOfChars(final Set<Character> set, final boolean ignoreCase) {
        final Set<String> strSet = new HashSet<String>(set.size() * 2);
        if (ignoreCase) {
            for (final char ch : set) {
                final String string = new String(new char[] { ch });
                strSet.add(string.toLowerCase());
                strSet.add(string.toUpperCase());
            }
            return copyOf(strSet, false);
        }
        for (final char ch : set) {
            strSet.add(new String(new char[] { ch }));
        }
        return copyOf(strSet, ignoreCase);
    }
}