/* 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 tests.api.java.nio.charset;

import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

import junit.framework.TestCase;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CodingErrorAction;
import java.util.Arrays;

/**
 * Super class for concrete charset test suites.
 */
public class Charset_AbstractTest extends TestCase {

    static String charsetName;
    static private Charset charset;
    static CharsetDecoder decoder;
    static CharsetEncoder encoder;

    static final int[] codes = Charset_TestGenerator.codes;

    static final char[] chars = new char[codes.length]; // Is filled with
                                                        // contents of codes.

    static char[] testChars;
    static byte[] testBytes;

    static char[] theseChars (int[] codes) {
        char[] chars = new char[codes.length];
        for (int i = 0; i < codes.length; i++) chars[i] = (char) codes[i];
        return chars;
    }

    static byte[] theseBytes (int[] codes) {
        byte[] bytes = new byte[codes.length];
        for (int i = 0; i < codes.length; i++) bytes[i] = (byte) codes[i];
        return bytes;
    }


    @Override
    protected void setUp() throws Exception {
        charset = charset.forName(charsetName);
        decoder = charset.newDecoder();
        encoder = charset.newEncoder();
        super.setUp();
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_nameMatch () {
        assertEquals("Name of charset must match!", charsetName, charset.name());
    }

    @TestTargetNew(
        level = TestLevel.ADDITIONAL,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_dumpEncodableChars () {
        if (testChars == null) return;
        if (testChars.length > 0) return;
        System.out.format("\ntest_dumpEncodableChars() for name %s => %s (class = %s)\n",
                charsetName, charset.name(), getClass().getName());
        Charset_TestGenerator.Dumper out = new Charset_TestGenerator.Dumper1(16);
        int code = 0;
        while (code < 256) {
            while (!encoder.canEncode((char) code)) code ++;
            if (code < 65536) {
                out.consume(code);
                code += 1;
            }
        }
        while (code < 65536) {
            while (!encoder.canEncode((char) code)) code ++;
            if (code < 65536) {
                out.consume(code);
                code += 20;
            }
        }
        System.out.println();
        System.out.println("Encodable Chars dumped for Test Class " + getClass().getName());
        fail("Encodable Chars dumped for Test Class " + getClass().getName());
    }

    @TestTargetNew(
        level = TestLevel.ADDITIONAL,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_dumpEncoded () throws CharacterCodingException {
        if (testChars == null) return;
        if (testChars.length == 0) return;
        if (testBytes.length > 0) return;
        System.out.format("\ntest_dumpEncoded() for name %s => %s (class = %s)\n",
                charsetName, charset.name(), getClass().getName());
        Charset_TestGenerator.Dumper out = new Charset_TestGenerator.Dumper1();
        CharBuffer inputCB = CharBuffer.wrap(testChars);
        ByteBuffer outputBB;
        encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        outputBB = encoder.encode(inputCB);
        outputBB.rewind();
        while (outputBB.hasRemaining()) {
            out.consume(outputBB.get() & 0xff);
        }
        System.out.println();
        System.out.println("Encoded Bytes dumped for Test Class " + getClass().getName());
        fail("Encoded Bytes dumped for Test Class " + getClass().getName());
    }


    static void decode (byte[] input, char[] expectedOutput) throws CharacterCodingException {
        ByteBuffer inputBB = ByteBuffer.wrap(input);
        CharBuffer outputCB;
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        outputCB = decoder.decode(inputBB);
        outputCB.rewind();

//        assertTrue("Decoded charactes must match!",
//                Arrays.equals(expectedOutput, outputCB.array()));
        assertEqualChars("Decoded charactes must match!",
                expectedOutput, outputCB);

//        assertEqualChars2("Decoded charactes must match!",
//                expectedOutput,
//                outputCB.array(),
//                input);
//        assertTrue("Decoded charactes (REPLACEed ones INCLUSIVE) must match!",
//                Arrays.equals(expectedOutput, outputCB.array()));

//        assertEqualChars("Decoded charactes (REPLACEed ones INCLUSIVE) must match!",
//                expectedOutput,
//                outputCB.array());

//        assertEquals("Decoded charactes must match!",
//                String.valueOf(allChars),
//                outputCB.toString());
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_Decode () throws CharacterCodingException {
        decode(testBytes, testChars);
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_Encode () throws CharacterCodingException {
        CharBuffer inputCB = CharBuffer.wrap(testChars);
        ByteBuffer outputBB;
        encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        outputBB = encoder.encode(inputCB);
        outputBB.rewind();
//        assertTrue("Encoded bytes must match!",
//                Arrays.equals(testBytes, outputBB.array()));
        assertEqualBytes("Encoded bytes must match!", testBytes, outputBB);
    }


    public void NNtest_CodecDynamicIndividuals () throws CharacterCodingException {
        encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        decoder.onMalformedInput(CodingErrorAction.REPORT);

        for (int code = 32; code <= 65533; code ++) {
            if (encoder.canEncode((char) code)) {
//                inputCB.rewind();
                CharBuffer inputCB = CharBuffer.allocate(1);
                inputCB.put((char) code);
                inputCB.rewind();
                ByteBuffer intermediateBB = encoder.encode(inputCB);
                inputCB.rewind();
                intermediateBB.rewind();
                try {
                    CharBuffer outputCB = decoder.decode(intermediateBB);
                    outputCB.rewind();
                    assertEqualCBs("decode(encode(A)) must be identical with A = " + code,
                            inputCB, outputCB);
                    if (code == 165) {
                        outputCB.rewind();
                        System.out.println("WOW:" + outputCB.get());
                    }
                } catch (CharacterCodingException e) {
                    fail("failed to decode(encode(" + code + "))");
                }
            }
        }
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        method = "functionalCoDec_REPR",
        args = {}
    )
    public void test_CodecDynamic () throws CharacterCodingException {
        encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        CharBuffer inputCB = CharBuffer.allocate(65536);
        for (int code = 32; code <= 65533; code ++) {
            if (encoder.canEncode((char) code)) {
                inputCB.put((char) code);
            }
        }
        inputCB.rewind();
        ByteBuffer intermediateBB = encoder.encode(inputCB);
        inputCB.rewind();
        intermediateBB.rewind();
        CharBuffer outputCB = decoder.decode(intermediateBB);
        outputCB.rewind();
        assertEqualCBs("decode(encode(A)) must be identical with A!",
                inputCB, outputCB);
    }

    static void assertEqualCBs (String msg, CharBuffer expectedCB, CharBuffer actualCB) {
        boolean match = true;
        boolean lenMatch = true;
        char expected, actual;
        int len = actualCB.length();
        if (expectedCB.length() != len) {
            lenMatch = false;
            if (expectedCB.length() < len) len = expectedCB.length();
        }
        for (int i = 0; i < len; i++) {
            expected = expectedCB.get();
            actual = actualCB.get();
            if (actual != expected) {
                String detail = String.format(
                        "Mismatch at index %d: %d instead of expected %d.\n",
                        i, (int) actual, (int) expected);
                match = false;
                fail(msg + ": " + detail);
            }
//            else {
//                System.out.format("Match index %d: %d = %d\n",
//                        i, (int) actual[i], (int) expected[i]);
//            }
        }
        assertTrue(msg, match);
        assertTrue(msg + "(IN LENGTH ALSO!)", lenMatch);
//        assertTrue(msg, Arrays.equals(actual, expected));
    }

    static void assertEqualChars (String msg, char[] expected, CharBuffer actualCB) {
        boolean match = true;
        boolean lenMatch = true;
        char actual;
        int len = actualCB.length();
        if (expected.length != len) {
            lenMatch = false;
            if (expected.length < len) len = expected.length;
        }
        for (int i = 0; i < len; i++) {
            actual = actualCB.get();
            if (actual != expected[i]) {
                String detail = String.format(
                        "Mismatch at index %d: %d instead of expected %d.\n",
                        i, (int) actual, (int) expected[i]);
                match = false;
                fail(msg + ": " + detail);
            }
//            else {
//                System.out.format("Match index %d: %d = %d\n",
//                        i, (int) actual[i], (int) expected[i]);
//            }
        }
        assertTrue(msg, match);
        assertTrue(msg + "(IN LENGTH ALSO!)", lenMatch);
//        assertTrue(msg, Arrays.equals(actual, expected));
    }

    static void assertEqualBytes (String msg, byte[] expected, ByteBuffer actualBB) {
        boolean match = true;
        boolean lenMatch = true;
        byte actual;
        int len = actualBB.remaining();
        if (expected.length != len) {
            lenMatch = false;
            if (expected.length < len) len = expected.length;
        }
        for (int i = 0; i < len; i++) {
            actual = actualBB.get();
            if (actual != expected[i]) {
                String detail = String.format(
                        "Mismatch at index %d: %d instead of expected %d.\n",
                        i, actual & 0xff, expected[i] & 0xff);
                match = false;
                fail(msg + ": " + detail);
            }
        }
        assertTrue(msg, match);
        assertTrue(msg + "(IN LENGTH ALSO!)", lenMatch);
    }


    static abstract class CodesGenerator {
        int row = 0, col = 0;

        abstract void consume(int code);

        boolean isAccepted(int code) {
            return Character.isLetterOrDigit(code);
        }
    }

}
