/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.imaging.util;

import java.io.UnsupportedEncodingException;

import org.apache.commons.imaging.common.BinaryConstants;

public abstract class UnicodeUtils implements BinaryConstants
{
    /**
     * This class should never be instantiated.
     */
    private UnicodeUtils()
    {
    }

    public static class UnicodeException extends Exception
    {
        public UnicodeException(String message)
        {
            super(message);
        }
    }

    // A default single-byte charset.
    public static final int CHAR_ENCODING_CODE_ISO_8859_1 = 0;
    public static final int CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_WITH_BOM = 1;
    public static final int CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_WITH_BOM = 2;
    public static final int CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_NO_BOM = 3;
    public static final int CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_NO_BOM = 4;
    public static final int CHAR_ENCODING_CODE_UTF_8 = 5;
    public static final int CHAR_ENCODING_CODE_AMBIGUOUS = -1;

    // /*
    // * Guess the character encoding of arbitrary character data in a data
    // * buffer.
    // *
    // * The data may not run to the end of the buffer; it may be terminated.
    // This
    // * makes the problem much harder, since the character data may be followed
    // * by arbitrary data.
    // */
    // public static int guessCharacterEncoding(byte bytes[], int index)
    // {
    // int length = bytes.length - index;
    //
    // if (length < 1)
    // return CHAR_ENCODING_CODE_AMBIGUOUS;
    //
    // if (length >= 2)
    // {
    // // look for BOM.
    //
    // int c1 = 0xff & bytes[index];
    // int c2 = 0xff & bytes[index + 1];
    // if (c1 == 0xFF && c2 == 0xFE)
    // return CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_WITH_BOM;
    // else if (c1 == 0xFE && c2 == 0xFF)
    // return CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_WITH_BOM;
    // }
    //
    // }
    //
    // /*
    // * Guess the character encoding of arbitrary character data in a data
    // * buffer.
    // *
    // * The data fills the entire buffer. If it is terminated, the terminator
    // * byte(s) will be the last bytes in the buffer.
    // *
    // * This makes the problem a bit easier.
    // */
    // public static int guessCharacterEncodingSimple(byte bytes[], int index)
    // throws UnicodeException
    // {
    // int length = bytes.length - index;
    //
    // if (length < 1)
    // return CHAR_ENCODING_CODE_AMBIGUOUS;
    //
    // if (length >= 2)
    // {
    // // identify or eliminate UTF-16 with a BOM.
    //
    // int c1 = 0xff & bytes[index];
    // int c2 = 0xff & bytes[index + 1];
    // if (c1 == 0xFF && c2 == 0xFE)
    // return CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_WITH_BOM;
    // else if (c1 == 0xFE && c2 == 0xFF)
    // return CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_WITH_BOM;
    // }
    //
    // if (length >= 2)
    // {
    // // look for optional double-byte terminator.
    //
    // int c1 = 0xff & bytes[bytes.length - 2];
    // int c2 = 0xff & bytes[bytes.length - 1];
    // if (c1 == 0 && c2 == 0)
    // {
    // // definitely a flavor of UTF-16.
    // if (length % 2 != 0)
    // throw new UnicodeException(
    // "Character data with double-byte terminator has an odd length.");
    //
    // boolean mayHaveTerminator = true;
    // boolean mustHaveTerminator = false;
    // boolean possibleBigEndian = new UnicodeMetricsUTF16NoBOM(
    // BYTE_ORDER_BIG_ENDIAN).isValid(bytes, index,
    // mayHaveTerminator, mustHaveTerminator);
    // boolean possibleLittleEndian = new UnicodeMetricsUTF16NoBOM(
    // BYTE_ORDER_LITTLE_ENDIAN).isValid(bytes, index,
    // mayHaveTerminator, mustHaveTerminator);
    // if ((!possibleBigEndian) && (!possibleLittleEndian))
    // throw new UnicodeException(
    // "Invalid character data, possibly UTF-16.");
    // if (possibleBigEndian && possibleLittleEndian)
    // return CHAR_ENCODING_CODE_AMBIGUOUS;
    // if (possibleBigEndian)
    // return CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_NO_BOM;
    // if (possibleLittleEndian)
    // return CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_NO_BOM;
    // }
    // }
    //
    // List possibleEncodings = new ArrayList();
    // if (length % 2 == 0)
    // {
    // boolean mayHaveTerminator = true;
    // boolean mustHaveTerminator = false;
    // boolean possibleBigEndian = new UnicodeMetricsUTF16NoBOM(
    // BYTE_ORDER_BIG_ENDIAN).isValid(bytes, index,
    // mayHaveTerminator, mustHaveTerminator);
    // boolean possibleLittleEndian = new UnicodeMetricsUTF16NoBOM(
    // BYTE_ORDER_LITTLE_ENDIAN).isValid(bytes, index,
    // mayHaveTerminator, mustHaveTerminator);
    //
    // if (possibleBigEndian)
    // return CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_NO_BOM;
    // if (possibleLittleEndian)
    // return CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_NO_BOM;
    // }
    //
    // }

    public static final boolean isValidISO_8859_1(String s)
    {
        try
        {
            String roundtrip = new String(s.getBytes("ISO-8859-1"),
                    "ISO-8859-1");
            return s.equals(roundtrip);
        } catch (UnsupportedEncodingException e)
        {
            // should never be thrown.
            throw new RuntimeException("Error parsing string.", e);
        }
    }

    /*
     * Return the index of the first utf-16 terminator (ie. two even-aligned
     * nulls). If not found, return -1.
     */
    private static int findFirstDoubleByteTerminator(byte bytes[], int index)
    {
        for (int i = index; i < bytes.length - 1; i += 2)
        {
            int c1 = 0xff & bytes[index];
            int c2 = 0xff & bytes[index + 1];
            if (c1 == 0 && c2 == 0)
                return i;
        }
        return -1;
    }

    public final int findEndWithTerminator(byte bytes[], int index)
            throws UnicodeException
    {
        return findEnd(bytes, index, true);
    }

    public final int findEndWithoutTerminator(byte bytes[], int index)
            throws UnicodeException
    {
        return findEnd(bytes, index, false);
    }

    protected abstract int findEnd(byte bytes[], int index,
            boolean includeTerminator) throws UnicodeException;

    public static UnicodeUtils getInstance(int charEncodingCode)
            throws UnicodeException
    {
        switch (charEncodingCode)
        {
        case CHAR_ENCODING_CODE_ISO_8859_1:
            return new UnicodeMetricsASCII();
        case CHAR_ENCODING_CODE_UTF_8:
            // Debug.debug("CHAR_ENCODING_CODE_UTF_8");
            return new UnicodeMetricsUTF8();
        case CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_WITH_BOM:
        case CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_WITH_BOM:
            // Debug.debug("CHAR_ENCODING_CODE_UTF_16_WITH_BOM");
            return new UnicodeMetricsUTF16WithBOM();
        case CHAR_ENCODING_CODE_UTF_16_BIG_ENDIAN_NO_BOM:
            return new UnicodeMetricsUTF16NoBOM(BYTE_ORDER_BIG_ENDIAN);
        case CHAR_ENCODING_CODE_UTF_16_LITTLE_ENDIAN_NO_BOM:
            return new UnicodeMetricsUTF16NoBOM(BYTE_ORDER_LITTLE_ENDIAN);
        default:
            throw new UnicodeException("Unknown char encoding code: "
                    + charEncodingCode);
        }
    }

    private static class UnicodeMetricsASCII extends UnicodeUtils
    {
        @Override
        public int findEnd(byte bytes[], int index, boolean includeTerminator)
                throws UnicodeException
        {
            for (int i = index; i < bytes.length; i++)
            {
                if (bytes[i] == 0)
                    return includeTerminator ? i + 1 : i;
            }
            return bytes.length;
            // throw new UnicodeException("Terminator not found.");
        }
    }

    // private static class UnicodeMetricsISO_8859_1 extends UnicodeUtils
    // {
    // public int findEnd(byte bytes[], int index, boolean includeTerminator)
    // throws UnicodeException
    // {
    // for (int i = index; i < bytes.length; i++)
    // {
    // if (bytes[i] == 0)
    // return includeTerminator ? i + 1 : i;
    // }
    // return bytes.length;
    // // throw new UnicodeException("Terminator not found.");
    // }
    // }

    private static class UnicodeMetricsUTF8 extends UnicodeUtils
    {

        @Override
        public int findEnd(byte bytes[], int index, boolean includeTerminator)
                throws UnicodeException
        {
            // http://en.wikipedia.org/wiki/UTF-8

            while (true)
            {
                if (index == bytes.length)
                    return bytes.length;
                if (index > bytes.length)
                    throw new UnicodeException("Terminator not found.");

                int c1 = 0xff & bytes[index++];
                if (c1 == 0)
                    return includeTerminator ? index : index - 1;
                else if (c1 <= 0x7f)
                    continue;
                else if (c1 <= 0xDF)
                {
                    if (index >= bytes.length)
                        throw new UnicodeException("Invalid unicode.");

                    int c2 = 0xff & bytes[index++];
                    if (c2 < 0x80 || c2 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                } else if (c1 <= 0xEF)
                {
                    if (index >= bytes.length - 1)
                        throw new UnicodeException("Invalid unicode.");

                    int c2 = 0xff & bytes[index++];
                    if (c2 < 0x80 || c2 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                    int c3 = 0xff & bytes[index++];
                    if (c3 < 0x80 || c3 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                } else if (c1 <= 0xF4)
                {
                    if (index >= bytes.length - 2)
                        throw new UnicodeException("Invalid unicode.");

                    int c2 = 0xff & bytes[index++];
                    if (c2 < 0x80 || c2 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                    int c3 = 0xff & bytes[index++];
                    if (c3 < 0x80 || c3 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                    int c4 = 0xff & bytes[index++];
                    if (c4 < 0x80 || c4 > 0xBF)
                        throw new UnicodeException("Invalid code point.");
                } else
                    throw new UnicodeException("Invalid code point.");
            }
        }
    }

    private abstract static class UnicodeMetricsUTF16 extends UnicodeUtils
    {
        protected int byteOrder = BYTE_ORDER_BIG_ENDIAN;

        public UnicodeMetricsUTF16(int byteOrder)
        {
            this.byteOrder = byteOrder;
        }

        public boolean isValid(byte bytes[], int index,
                boolean mayHaveTerminator, boolean mustHaveTerminator)
        {
            // http://en.wikipedia.org/wiki/UTF-16/UCS-2

            while (true)
            {
                if (index == bytes.length)
                {
                    // end of buffer, no terminator found.
                    return !mustHaveTerminator;
                }

                if (index >= bytes.length - 1)
                {
                    // end of odd-length buffer, no terminator found.
                    return false;
                }

                int c1 = 0xff & bytes[index++];
                int c2 = 0xff & bytes[index++];
                int msb1 = byteOrder == BYTE_ORDER_BIG_ENDIAN ? c1 : c2;

                if (c1 == 0 && c2 == 0)
                {
                    // terminator found.
                    return mayHaveTerminator;
                }

                if (msb1 >= 0xD8)
                {
                    // Surrogate pair found.

                    if (msb1 >= 0xDC)
                    {
                        // invalid first surrogate.
                        return false;
                    }

                    if (index >= bytes.length - 1)
                    {
                        // missing second surrogate.
                        return false;
                    }

                    // second word.
                    int c3 = 0xff & bytes[index++];
                    int c4 = 0xff & bytes[index++];
                    int msb2 = byteOrder == BYTE_ORDER_BIG_ENDIAN ? c3 : c4;
                    if (msb2 < 0xDC)
                    {
                        // invalid second surrogate.
                        return false;
                    }
                }
            }
        }

        @Override
        public int findEnd(byte bytes[], int index, boolean includeTerminator)
                throws UnicodeException
        {
            // http://en.wikipedia.org/wiki/UTF-16/UCS-2

            while (true)
            {
                if (index == bytes.length)
                    return bytes.length;
                if (index > bytes.length - 1)
                    throw new UnicodeException("Terminator not found.");

                int c1 = 0xff & bytes[index++];
                int c2 = 0xff & bytes[index++];
                int msb1 = byteOrder == BYTE_ORDER_BIG_ENDIAN ? c1 : c2;

                if (c1 == 0 && c2 == 0)
                {
                    return includeTerminator ? index : index - 2;
                } else if (msb1 >= 0xD8)
                {
                    if (index > bytes.length - 1)
                        throw new UnicodeException("Terminator not found.");

                    // second word.
                    int c3 = 0xff & bytes[index++];
                    int c4 = 0xff & bytes[index++];
                    int msb2 = byteOrder == BYTE_ORDER_BIG_ENDIAN ? c3 : c4;
                    if (msb2 < 0xDC)
                        throw new UnicodeException("Invalid code point.");
                }
            }
        }
    }

    private static class UnicodeMetricsUTF16NoBOM extends UnicodeMetricsUTF16
    {

        public UnicodeMetricsUTF16NoBOM(final int byteOrder)
        {
            super(byteOrder);
        }

    }

    private static class UnicodeMetricsUTF16WithBOM extends UnicodeMetricsUTF16
    {

        public UnicodeMetricsUTF16WithBOM()
        {
            super(BYTE_ORDER_BIG_ENDIAN);
        }

        @Override
        public int findEnd(byte bytes[], int index, boolean includeTerminator)
                throws UnicodeException
        {
            // http://en.wikipedia.org/wiki/UTF-16/UCS-2

            if (index >= bytes.length - 1)
                throw new UnicodeException("Missing BOM.");

            int c1 = 0xff & bytes[index++];
            int c2 = 0xff & bytes[index++];
            if (c1 == 0xFF && c2 == 0xFE)
                byteOrder = BYTE_ORDER_LITTLE_ENDIAN;
            else if (c1 == 0xFE && c2 == 0xFF)
                byteOrder = BYTE_ORDER_BIG_ENDIAN;
            else
                throw new UnicodeException("Invalid byte order mark.");

            return super.findEnd(bytes, index, includeTerminator);
        }
    }

}