/* Copyright (c) 2008-2018, Nathan Sweet
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
 * conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided with the distribution.
 * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

package dorkboxTest.network.kryo;

import static com.esotericsoftware.minlog.Log.WARN;
import static com.esotericsoftware.minlog.Log.warn;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;

import org.junit.Before;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.Serializer;
import com.esotericsoftware.kryo.io.ByteBufferInput;
import com.esotericsoftware.kryo.io.ByteBufferOutput;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.unsafe.UnsafeByteBufferInput;
import com.esotericsoftware.kryo.unsafe.UnsafeByteBufferOutput;
import com.esotericsoftware.kryo.unsafe.UnsafeInput;
import com.esotericsoftware.kryo.unsafe.UnsafeOutput;

/** Convenience methods for round tripping objects.
 * @author Nathan Sweet */
@SuppressWarnings("unchecked")
abstract public class KryoTestCase {
	// When true, roundTrip will only do a single write/read to make debugging easier (breaks some tests).
	static private final boolean debug = false;

	protected Kryo kryo;
	protected Output output;
	protected Input input;
	protected Object object1, object2;
	protected boolean supportsCopy;

	static interface BufferFactory {
		public Output createOutput(OutputStream os);

		public Output createOutput(OutputStream os, int size);

		public Output createOutput(int size, int limit);

		public Input createInput(InputStream os, int size);

		public Input createInput(byte[] buffer);
	}

	@Before
	public void setUp () throws Exception {
		if (debug && WARN) warn("*** DEBUG TEST ***");

		kryo = new Kryo();
	}

	/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
	public <T> T roundTrip (int length, T object1) {
		T object2 = roundTripWithBufferFactory(length, object1, new BufferFactory() {
			@Override
            public Output createOutput (OutputStream os) {
				return new Output(os);
			}

			@Override
            public Output createOutput (OutputStream os, int size) {
				return new Output(os, size);
			}

			@Override
            public Output createOutput (int size, int limit) {
				return new Output(size, limit);
			}

			@Override
            public Input createInput (InputStream os, int size) {
				return new Input(os, size);
			}

			@Override
            public Input createInput (byte[] buffer) {
				return new Input(buffer);
			}
		});

		if (debug) return object2;

		roundTripWithBufferFactory(length, object1, new BufferFactory() {
			@Override
            public Output createOutput (OutputStream os) {
				return new ByteBufferOutput(os);
			}

			@Override
            public Output createOutput (OutputStream os, int size) {
				return new ByteBufferOutput(os, size);
			}

			@Override
            public Output createOutput (int size, int limit) {
				return new ByteBufferOutput(size, limit);
			}

			@Override
            public Input createInput (InputStream os, int size) {
				return new ByteBufferInput(os, size);
			}

			@Override
            public Input createInput (byte[] buffer) {
				ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
				byteBuffer.put(buffer).flip();
				return new ByteBufferInput(byteBuffer);
			}
		});

		roundTripWithBufferFactory(length, object1, new BufferFactory() {
			@Override
            public Output createOutput (OutputStream os) {
				return new UnsafeOutput(os);
			}

			@Override
            public Output createOutput (OutputStream os, int size) {
				return new UnsafeOutput(os, size);
			}

			@Override
            public Output createOutput (int size, int limit) {
				return new UnsafeOutput(size, limit);
			}

			@Override
            public Input createInput (InputStream os, int size) {
				return new UnsafeInput(os, size);
			}

			@Override
            public Input createInput (byte[] buffer) {
				return new UnsafeInput(buffer);
			}
		});

		roundTripWithBufferFactory(length, object1, new BufferFactory() {
			@Override
            public Output createOutput (OutputStream os) {
				return new UnsafeByteBufferOutput(os);
			}

			@Override
            public Output createOutput (OutputStream os, int size) {
				return new UnsafeByteBufferOutput(os, size);
			}

			@Override
            public Output createOutput (int size, int limit) {
				return new UnsafeByteBufferOutput(size, limit);
			}

			@Override
            public Input createInput (InputStream os, int size) {
				return new UnsafeByteBufferInput(os, size);
			}

			@Override
            public Input createInput (byte[] buffer) {
				ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
				byteBuffer.put(buffer).flip();
				return new UnsafeByteBufferInput(byteBuffer);
			}
		});

		return object2;
	}

	/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
	public <T> T roundTripWithBufferFactory (int length, T object1, BufferFactory sf) {
		boolean checkLength = length != Integer.MIN_VALUE;

		this.object1 = object1;

		// Test output to stream, large buffer.
		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
		output = sf.createOutput(outStream, 4096);
		kryo.writeClassAndObject(output, object1);
		output.flush();

		if (debug) System.out.println();

		// Test input from stream, large buffer.
		byte[] out = outStream.toByteArray();
		input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 4096);
		object2 = kryo.readClassAndObject(input);
		doAssertEquals(object1, object2);
		if (checkLength) {
			assertEquals("Incorrect number of bytes read.", length, input.total());
			assertEquals("Incorrect number of bytes written.", length, output.total());
		}

		if (debug) return (T)object2;

		// Test output to stream, small buffer.
		outStream = new ByteArrayOutputStream();
		output = sf.createOutput(outStream, 10);
		kryo.writeClassAndObject(output, object1);
		output.flush();

		// Test input from stream, small buffer.
		input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
		object2 = kryo.readClassAndObject(input);
		doAssertEquals(object1, object2);
		if (checkLength) assertEquals("Incorrect number of bytes read.", length, input.total());

		if (object1 != null) {
			// Test null with serializer.
			Serializer serializer = kryo.getRegistration(object1.getClass()).getSerializer();
			output.reset();
			outStream.reset();
			kryo.writeObjectOrNull(output, null, serializer);
			output.flush();

			// Test null from byte array with and without serializer.
			input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
			assertNull(kryo.readObjectOrNull(input, object1.getClass(), serializer));

			input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
			assertNull(kryo.readObjectOrNull(input, object1.getClass()));
		}

		// Test output to byte array.
		output = sf.createOutput(length * 2, -1);
		kryo.writeClassAndObject(output, object1);
		output.flush();

		// Test input from byte array.
		input = sf.createInput(output.toBytes());
		object2 = kryo.readClassAndObject(input);
		doAssertEquals(object1, object2);
		if (checkLength) {
			assertEquals("Incorrect length.", length, output.total());
			assertEquals("Incorrect number of bytes read.", length, input.total());
		}
		input.reset();

		if (supportsCopy) {
			// Test copy.
			T copy = kryo.copy(object1);
			doAssertEquals(object1, copy);
			copy = kryo.copyShallow(object1);
			doAssertEquals(object1, copy);
		}

		return (T)object2;
	}

	protected void doAssertEquals (Object object1, Object object2) {
		assertEquals(arrayToList(object1), arrayToList(object2));
	}

	static public Object arrayToList (Object array) {
		if (array == null || !array.getClass().isArray()) return array;
		ArrayList list = new ArrayList(Array.getLength(array));
		for (int i = 0, n = Array.getLength(array); i < n; i++)
			list.add(arrayToList(Array.get(array, i)));
		return list;
	}

	static public ArrayList list (Object... items) {
		ArrayList list = new ArrayList();
		for (Object item : items)
			list.add(item);
		return list;
	}
}