package serializers.flatbuffers;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.google.flatbuffers.FlatBufferBuilder;

import data.media.MediaTransformer;
import serializers.SerClass;
import serializers.SerFeatures;
import serializers.SerFormat;
import serializers.SerGraph;
import serializers.Serializer;
import serializers.TestGroups;
import serializers.flatbuffers.media.Image;
import serializers.flatbuffers.media.Media;
import serializers.flatbuffers.media.MediaContent;
import serializers.flatbuffers.media.Player;
import serializers.flatbuffers.media.Size;

public class FlatBuffers {
	public static void register(TestGroups groups) {
		groups.media.add(new Transformer(), new FBSerializer(),
				new SerFeatures(SerFormat.BIN_CROSSLANG, SerGraph.FULL_GRAPH, SerClass.CLASSES_KNOWN, ""));
	}

	static final class FBSerializer extends Serializer<MediaContent> {

		public String getName() {
			return "flatbuffers";
		}

		MediaContent mc = new MediaContent();

		@Override
		public MediaContent deserialize(byte[] array) throws Exception {
			ByteBuffer bb = ByteBuffer.wrap(array);
			return MediaContent.getRootAsMediaContent(bb);
		}

		int i = 0;

		@Override
		public byte[] serialize(MediaContent content) {
			byte[] result = content.getByteBuffer().array();
			if (i == 0) {
				i++;
				System.err.println("Size: " + result.length);
			}
			return result;
		}
	}

	static final class Transformer extends MediaTransformer<MediaContent> {

		@Override
		public MediaContent forward(data.media.MediaContent a) {

			ByteBuffer bb = ByteBuffer.allocate(1024);
			FlatBufferBuilder fbb = new FlatBufferBuilder(bb);

			int media = forwardMedia(a.media, fbb);
			int images[] = new int[a.images.size()];
			for (int i = 0; i < a.images.size(); i++) {
				images[i] = forwardImage(a.images.get(i), fbb);
			}
			int image = MediaContent.createImagesVector(fbb, images);
			int offset = MediaContent.createMediaContent(fbb, image, media);
			MediaContent.finishMediaContentBuffer(fbb, offset);
			return MediaContent.getRootAsMediaContent(bb);
		}

		private static int forwardMedia(data.media.Media media, FlatBufferBuilder fbb) {
			int uri = fbb.createString(media.uri);
			String titleS = media.title;
			int title = titleS != null ? fbb.createString(titleS) : 0;
			int format = fbb.createString(media.format);
			int[] persons = new int[media.persons.size()];
			for (int i = 0; i < media.persons.size(); i++) {
				persons[i] = fbb.createString(media.persons.get(i));
			}
			int person = Media.createPersonsVector(fbb, persons);
			byte player = forwardPlayer(media.player);
			String copyrightS = media.copyright;
			int copyright = copyrightS != null ? fbb.createString(copyrightS) : 0;
			return Media.createMedia(fbb, uri, title, media.width, media.height, format, media.duration, media.size,
					media.bitrate, person, player, copyright);
		}

		private static int forwardImage(data.media.Image image, FlatBufferBuilder fbb) {
			int uri = fbb.createString(image.uri);
			String titleS = image.title;
			int title = titleS != null ? fbb.createString(titleS) : 0;
			byte size = forwardSize(image.size);
			return Image.createImage(fbb, uri, title, image.width, image.height, size);
		}

		private static byte forwardPlayer(data.media.Media.Player p) {
			switch (p) {
			case JAVA:
				return Player.JAVA;
			case FLASH:
				return Player.FLASH;
			default:
				throw new AssertionError("invalid case: " + p);
			}
		}

		private static byte forwardSize(data.media.Image.Size s) {
			switch (s) {
			case SMALL:
				return Size.SMALL;
			case LARGE:
				return Size.LARGE;
			default:
				throw new AssertionError("invalid case: " + s);
			}
		}

		private Image image = new Image();

		@Override
		public data.media.MediaContent reverse(MediaContent a) {
			List<data.media.Image> images = new ArrayList<data.media.Image>(a.imagesLength());
			for (int i = 0; i < a.imagesLength(); i++) {
				images.add(reverseImage(a.images(image, i)));
			}
			return new data.media.MediaContent(reverseMedia(a.media()), images);
		}

		@Override
		public data.media.MediaContent shallowReverse(MediaContent a) {
			return new data.media.MediaContent(reverseMedia(a.media()), Collections.<data.media.Image> emptyList());
		}

		private static data.media.Media reverseMedia(Media media) {
			return new data.media.Media(media.uri(), media.title(), media.width(), media.height(), media.format(),
					media.duration(), media.size(), media.bitrate(), media.bitrate() != 0, reversePersons(media),
					reversePlayer(media.player()), media.copyright());
		}

		private static data.media.Media.Player reversePlayer(byte p) {
			switch (p) {
			case Player.JAVA:
				return data.media.Media.Player.JAVA;
			case Player.FLASH:
				return data.media.Media.Player.FLASH;
			default:
				throw new AssertionError("invalid case: " + p);
			}
		}

		private static List<String> reversePersons(Media media) {
			List<String> result = new ArrayList<>(media.personsLength());
			for (int i = 0; i < media.personsLength(); i++) {
				result.add(media.persons(i));
			}
			return result;
		}

		private static data.media.Image reverseImage(Image image) {
			return new data.media.Image(image.uri(), image.title(), image.width(), image.height(),
					reverseSize(image.size()));
		}

		private static data.media.Image.Size reverseSize(byte s) {
			switch (s) {
			case Size.SMALL:
				return data.media.Image.Size.SMALL;
			case Size.LARGE:
				return data.media.Image.Size.LARGE;
			default:
				throw new AssertionError("invalid case: " + s);
			}
		}
	}
}