/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed 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.infinispan.schematic.internal.document;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.util.concurrent.atomic.AtomicReference;
import org.infinispan.schematic.document.Document;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

@Ignore
public class JsonPerformanceTest {

    protected JsonReader reader;
    protected boolean print;

    @Before
    public void beforeTest() {
        reader = new JsonReader();
    }

    @After
    public void afterTest() {
        reader = null;
        gc();
    }

    @Test
    public void shouldReadLargeTestDocumentWithoutDateMatching() throws Exception {
        testReadingJson(getLargeTestData(), 200, false, false);
    }

    @Test
    public void shouldReadLargeTestDocumentWithDateMatching() throws Exception {
        testReadingJson(getLargeTestData(), 200, false, true);
    }

    @Test
    public void shouldReadLargeTestDocumentWithoutDataMatchingUsingJsonSimple() throws Exception {
        testReadingJsonWithJsonSimple(getLargeTestData(), 200, false);
    }

    @Test
    public void shouldReadSmallTestDocumentWithoutDateMatching() throws Exception {
        testReadingJson(getSmallTestData(), 200, false, false);
    }

    @Test
    public void shouldReadSmallTestDocumentWithDateMatching() throws Exception {
        testReadingJson(getSmallTestData(), 200, false, true);
    }

    @Test
    public void shouldReadSmallTestDocumentWithoutDataMatchingUsingJsonSimple() throws Exception {
        testReadingJsonWithJsonSimple(getSmallTestData(), 200, false);
    }

    // @Test
    // public void shouldReadLargeTestDocumentToAndFromBson() throws Exception {
    // testReadingJsonThenWritingBsonThenReadingBson(getLargeTestData(), 200, false, true);
    // }

    @Test
    public void shouldReadSmallTestDocumentToAndFromBson() throws Exception {
        testReadingJsonThenWritingBsonThenReadingBson(getSmallTestData(), 200, false, true);
    }

    public static String getLargeTestData() throws Exception {
        String result = read("sample-large-performance.json");
        assert result.length() != 0;
        return result;
    }

    public static String getSmallTestData() throws Exception {
        String result = read("sample-small-performance.json");
        assert result.length() != 0;
        return result;
    }

    private static String read( String resourcePath ) throws IOException {
        return read(JsonPerformanceTest.class.getClassLoader().getResourceAsStream(resourcePath));
    }

    private static String read( InputStream stream ) throws IOException {
        return read(new InputStreamReader(stream));
    }

    private static String read( Reader reader ) throws IOException {
        if (reader == null) return "";
        StringBuilder sb = new StringBuilder();
        try {
            int numRead = 0;
            char[] buffer = new char[1024];
            while ((numRead = reader.read(buffer)) > -1) {
                sb.append(buffer, 0, numRead);
            }
        } finally {
            reader.close();
        }
        return sb.toString();
    }

    private static void gc() {
        try {
            Thread.sleep(500L);
        } catch (InterruptedException ie) {
        }
        System.gc();
        try {
            Thread.sleep(500L);
        } catch (InterruptedException ie) {
        }
    }

    private static void runTest( String message,
                                 int loops,
                                 int testDataLength,
                                 boolean print,
                                 Runnable function ) {
        assert loops > 0;
        // Run several times to warm up ...
        for (int i = 0; i != 3; ++i) {
            function.run();
        }
        long stop = 0L;
        long start = System.nanoTime();
        try {
            for (int i = 0; i != loops; ++i) {
                function.run();
            }
        } finally {
            stop = System.nanoTime();
        }
        if (print) {
            while (message.length() < 60)
                message = message + " ";
            System.out.print(message + " -- data length: " + testDataLength);
            System.out.print(" -- average time: ");
            double delta = (stop - start) / (loops + 0D);
            String unit = "nanos";
            if (delta > 1000.0) {
                delta /= 1000000;
                unit = "millis";
            }
            System.out.println(delta + " " + unit);
        }
    }

    protected void testReadingJson( final String testData,
                                    int numberOfRuns,
                                    final boolean getValue,
                                    final boolean introspectStringValues ) throws Exception {
        assert testData != null;
        final JsonReader reader = new JsonReader();
        final AtomicReference<Exception> error = new AtomicReference<Exception>();
        final String key = "key";
        runTest("JsonReader.read(String," + introspectStringValues + ")", numberOfRuns, testData.length(), print, new Runnable() {
            @Override
            public void run() {
                try {
                    Document doc = reader.read(testData, introspectStringValues);
                    if (getValue) doc.get(key);
                } catch (Exception t) {
                    error.compareAndSet(null, t);
                }
            }
        });
        if (error.get() != null) throw error.get();
    }

    protected void testReadingJsonWithJsonSimple( final String testData,
                                                  int numberOfRuns,
                                                  final boolean getValue ) throws Exception {
        final org.json.simple.parser.JSONParser parser = new org.json.simple.parser.JSONParser();
        final AtomicReference<Exception> error = new AtomicReference<Exception>();
        final String key = "key";
        runTest("org.json.simple.parser.JSONParser().parse(Reader)", numberOfRuns, testData.length(), print, new Runnable() {
            @Override
            public void run() {
                try {
                    org.json.simple.JSONObject obj = (org.json.simple.JSONObject)parser.parse(new StringReader(testData));
                    if (getValue) obj.get(key);
                } catch (Exception t) {
                    error.compareAndSet(null, t);
                }
            }
        });
        if (error.get() != null) throw error.get();
    }

    protected void testReadingJsonThenWritingBsonThenReadingBson( final String testData,
                                                                  int numberOfRuns,
                                                                  final boolean getValue,
                                                                  final boolean introspectStringValues ) throws Exception {
        assert testData != null;
        // Read the JSON into in-memory ...
        Document doc = new JsonReader().read(testData, introspectStringValues);

        // Write the in-memory out to BSON ...
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        new BsonWriter().write(doc, bytes);
        final byte[] bsonBytes = bytes.toByteArray();

        final BsonReader bsonReader = new BsonReader();
        final AtomicReference<Exception> error = new AtomicReference<Exception>();
        final String key = "key";
        runTest("BsonReader.read(InputStream)", numberOfRuns, testData.length(), print, new Runnable() {
            @Override
            public void run() {
                try {
                    ByteArrayInputStream input = new ByteArrayInputStream(bsonBytes);
                    Document doc = bsonReader.read(input);
                    doc.get(key);
                } catch (Exception t) {
                    error.compareAndSet(null, t);
                }
            }
        });
        if (error.get() != null) throw error.get();
    }
}
