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

package org.bouncycastle.util;

import java.util.ArrayList;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Vector;
import java.io.IOException;
import java.io.OutputStream;
import java.io.ByteArrayOutputStream;
import org.bouncycastle.util.encoders.UTF8;

public final class Strings
{
    private static String LINE_SEPARATOR;
    
    public static String fromUTF8ByteArray(final byte[] array) {
        return fromUTF8ByteArray(array, 0, array.length);
    }
    
    public static String fromUTF8ByteArray(final byte[] array, final int n, final int n2) {
        final char[] value = new char[n2];
        final int transcodeToUTF16 = UTF8.transcodeToUTF16(array, n, n2, value);
        if (transcodeToUTF16 < 0) {
            throw new IllegalArgumentException("Invalid UTF-8 input");
        }
        return new String(value, 0, transcodeToUTF16);
    }
    
    public static byte[] toUTF8ByteArray(final String s) {
        return toUTF8ByteArray(s.toCharArray());
    }
    
    public static byte[] toUTF8ByteArray(final char[] array) {
        return toUTF8ByteArray(array, 0, array.length);
    }
    
    public static byte[] toUTF8ByteArray(final char[] array, final int n, final int n2) {
        final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            toUTF8ByteArray(array, n, n2, byteArrayOutputStream);
        }
        catch (final IOException ex) {
            throw new IllegalStateException("cannot encode string to byte array!");
        }
        return byteArrayOutputStream.toByteArray();
    }
    
    public static void toUTF8ByteArray(final char[] array, final OutputStream outputStream) throws IOException {
        toUTF8ByteArray(array, 0, array.length, outputStream);
    }
    
    public static void toUTF8ByteArray(final char[] array, final int n, final int n2, final OutputStream outputStream) throws IOException {
        if (n2 < 1) {
            return;
        }
        final byte[] array2 = new byte[64];
        int n3 = 0;
        int i = 0;
        do {
            final char c = array[n + i++];
            if (c < '\u0080') {
                array2[n3++] = (byte)c;
            }
            else if (c < '\u0800') {
                array2[n3++] = (byte)(0xC0 | c >> 6);
                array2[n3++] = (byte)(0x80 | (c & '?'));
            }
            else if (c >= '\ud800' && c <= '\udfff') {
                final char c2 = c;
                if (c2 > '\udbff') {
                    throw new IllegalStateException("invalid UTF-16 high surrogate");
                }
                if (i >= n2) {
                    throw new IllegalStateException("invalid UTF-16 codepoint (truncated surrogate pair)");
                }
                final char c3 = array[n + i++];
                if (c3 < '\udc00' || c3 > '\udfff') {
                    throw new IllegalStateException("invalid UTF-16 low surrogate");
                }
                final int n4 = ((c2 & '\u03ff') << 10 | (c3 & '\u03ff')) + 65536;
                array2[n3++] = (byte)(0xF0 | n4 >> 18);
                array2[n3++] = (byte)(0x80 | (n4 >> 12 & 0x3F));
                array2[n3++] = (byte)(0x80 | (n4 >> 6 & 0x3F));
                array2[n3++] = (byte)(0x80 | (n4 & 0x3F));
            }
            else {
                array2[n3++] = (byte)(0xE0 | c >> 12);
                array2[n3++] = (byte)(0x80 | (c >> 6 & 0x3F));
                array2[n3++] = (byte)(0x80 | (c & '?'));
            }
            if (n3 + 4 > array2.length) {
                outputStream.write(array2, 0, n3);
                n3 = 0;
            }
        } while (i < n2);
        if (n3 > 0) {
            outputStream.write(array2, 0, n3);
        }
    }
    
    public static String toUpperCase(final String s) {
        boolean b = false;
        final char[] charArray = s.toCharArray();
        for (int i = 0; i != charArray.length; ++i) {
            final char c = charArray[i];
            if ('a' <= c && 'z' >= c) {
                b = true;
                charArray[i] = (char)(c - 'a' + 65);
            }
        }
        if (b) {
            return new String(charArray);
        }
        return s;
    }
    
    public static String toLowerCase(final String s) {
        boolean b = false;
        final char[] charArray = s.toCharArray();
        for (int i = 0; i != charArray.length; ++i) {
            final char c = charArray[i];
            if ('A' <= c && 'Z' >= c) {
                b = true;
                charArray[i] = (char)(c - 'A' + 97);
            }
        }
        if (b) {
            return new String(charArray);
        }
        return s;
    }
    
    public static byte[] toByteArray(final char[] array) {
        final byte[] array2 = new byte[array.length];
        for (int i = 0; i != array2.length; ++i) {
            array2[i] = (byte)array[i];
        }
        return array2;
    }
    
    public static byte[] toByteArray(final String s) {
        final byte[] array = new byte[s.length()];
        for (int i = 0; i != array.length; ++i) {
            array[i] = (byte)s.charAt(i);
        }
        return array;
    }
    
    public static int toByteArray(final String s, final byte[] array, final int n) {
        final int length = s.length();
        for (int i = 0; i < length; ++i) {
            array[n + i] = (byte)s.charAt(i);
        }
        return length;
    }
    
    public static boolean constantTimeAreEqual(final String s, final String s2) {
        boolean b = s.length() == s2.length();
        final int length = s.length();
        if (b) {
            for (int i = 0; i != length; ++i) {
                b &= (s.charAt(i) == s2.charAt(i));
            }
        }
        else {
            for (int j = 0; j != length; ++j) {
                b &= (s.charAt(j) == ' ');
            }
        }
        return b;
    }
    
    public static String fromByteArray(final byte[] array) {
        return new String(asCharArray(array));
    }
    
    public static char[] asCharArray(final byte[] array) {
        final char[] array2 = new char[array.length];
        for (int i = 0; i != array2.length; ++i) {
            array2[i] = (char)(array[i] & 0xFF);
        }
        return array2;
    }
    
    public static String[] split(String substring, final char ch) {
        final Vector vector = new Vector();
        int i = 1;
        while (i != 0) {
            final int index = substring.indexOf(ch);
            if (index > 0) {
                vector.addElement(substring.substring(0, index));
                substring = substring.substring(index + 1);
            }
            else {
                i = 0;
                vector.addElement(substring);
            }
        }
        final String[] array = new String[vector.size()];
        for (int j = 0; j != array.length; ++j) {
            array[j] = (String)vector.elementAt(j);
        }
        return array;
    }
    
    public static StringList newList() {
        return new StringListImpl();
    }
    
    public static String lineSeparator() {
        return Strings.LINE_SEPARATOR;
    }
    
    static {
        try {
            Strings.LINE_SEPARATOR = AccessController.doPrivileged((PrivilegedAction<String>)new PrivilegedAction<String>() {
                @Override
                public String run() {
                    return System.getProperty("line.separator");
                }
            });
        }
        catch (final Exception ex) {
            try {
                Strings.LINE_SEPARATOR = String.format("%n", new Object[0]);
            }
            catch (final Exception ex2) {
                Strings.LINE_SEPARATOR = "\n";
            }
        }
    }
    
    private static class StringListImpl extends ArrayList<String> implements StringList
    {
        @Override
        public boolean add(final String e) {
            return super.add(e);
        }
        
        @Override
        public String set(final int index, final String element) {
            return super.set(index, element);
        }
        
        @Override
        public void add(final int index, final String element) {
            super.add(index, element);
        }
        
        @Override
        public String[] toStringArray() {
            final String[] array = new String[this.size()];
            for (int i = 0; i != array.length; ++i) {
                array[i] = this.get(i);
            }
            return array;
        }
        
        @Override
        public String[] toStringArray(final int n, final int n2) {
            final String[] array = new String[n2 - n];
            for (int index = n; index != this.size() && index != n2; ++index) {
                array[index - n] = this.get(index);
            }
            return array;
        }
    }
}