path: root/src/ch/epfl/xblast/client/GameStateDeserializer.java

package ch.epfl.xblast.client;

import ch.epfl.xblast.*;
import ch.epfl.xblast.client.GameState.Player;

import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * The client game state deserializer.
 *
 * @author Pacien TRAN-GIRARD (261948)
 * @author Timothée FLOURE (257420)
 */
public final class GameStateDeserializer {

    private static final int SERIALIZED_PLAYER_LENGTH = 4;
    private static final int SERIALIZED_PLAYERS_LENGTH = PlayerID.values().length * SERIALIZED_PLAYER_LENGTH;
    private static final int SERIALIZED_TICKS_LENGTH = 1;

    /**
     * Represents a length-prefixed chunk of byte-encoded data.
     */
    private static class VariableLengthChunk {

        private static final int PREFIX_SHIFT = 1;

        private final List<Byte> bytes;

        /**
         * Instantiates a VariableLengthChunk from a byte sequence.
         *
         * @param l the byte sequence
         */
        public VariableLengthChunk(List<Byte> l) {
            this.bytes = Lists.immutableList(l);
        }

        /**
         * Returns the length of the chunk given by its prefix.
         *
         * @return the length of the chunk
         */
        public int length() {
            if (this.bytes.isEmpty())
                return 0;
            else
                return Byte.toUnsignedInt(this.bytes.get(0));
        }

        /**
         * Returns the head of the desired length of the chunk.
         *
         * @param takeFirst the desired length
         * @return the head
         */
        public List<Byte> head(int takeFirst) {
            return this.bytes.subList(0, takeFirst);
        }

        /**
         * Returns the head of the size-prefixed chunk.
         *
         * @return the head
         */
        public List<Byte> head() {
            if (this.length() < 1)
                return Collections.emptyList();
            else
                return this.bytes.subList(PREFIX_SHIFT, this.length() + PREFIX_SHIFT);
        }

        /**
         * Returns the tail of the chunk, with the head of the given length dropped.
         *
         * @param dropFirst the length to drop
         * @return the tail
         */
        public VariableLengthChunk tail(int dropFirst) {
            return new VariableLengthChunk(
                    this.bytes.subList(dropFirst, this.bytes.size()));
        }

        /**
         * Returns the tail of the size-prefixed chunk.
         *
         * @return the tail
         */
        public VariableLengthChunk tail() {
            return new VariableLengthChunk(
                    this.bytes.subList(this.length() + PREFIX_SHIFT, this.bytes.size()));
        }

    }

    private GameStateDeserializer() {
        // Static class
    }

    /**
     * Deserialize an encoded chunk of data and link it to images.
     *
     * @param data            serialized data
     * @param imageCollection ImageCollection related to the type of data
     * @return a list of Images corresponding to the serialized element
     */
    private static List<Image> deserializeImageChunk(List<Byte> data, ImageCollection imageCollection) {
        return Collections.unmodifiableList(RunLengthEncoder.decode(data).stream()
                .map(Byte::toUnsignedInt)
                .map(imageCollection::imageOrNull)
                .collect(Collectors.toList()));
    }

    /**
     * Unserializes a spiral-ordered byte representation of a board.
     *
     * @param serializedBoard the run-length-compressed, serialized spiral ordered board
     * @return the row-major-ordered board
     * @throws IllegalArgumentException if the length of the serialized board is invalid
     */
    private static List<Image> deserializeBoard(List<Byte> serializedBoard) {
        List<Image> spiralOrdered = deserializeImageChunk(serializedBoard, ImageCollection.BOARD_IMAGES);

        if (spiralOrdered.size() != Cell.SPIRAL_ORDER.size())
            throw new IllegalArgumentException();

        Map<Cell, Image> imageMap = IntStream
                .range(0, Cell.SPIRAL_ORDER.size()).mapToObj(i -> i)
                .collect(Collectors.toMap(Cell.SPIRAL_ORDER::get, spiralOrdered::get));

        return Collections.unmodifiableList(Cell.ROW_MAJOR_ORDER.stream()
                .map(imageMap::get)
                .collect(Collectors.toList()));
    }

    /**
     * Unserializes a byte representation of explosions and bombs.
     *
     * @param serializedExplosions the run-length-compressed, serialized explosions
     * @return the explosions
     */
    private static List<Image> deserializeExplosions(List<Byte> serializedExplosions) {
        return deserializeImageChunk(serializedExplosions, ImageCollection.EXPLOSIONS_IMAGES);
    }

    /**
     * Unserializes a byte representation of a Player.
     *
     * @param id               the PlayerID
     * @param serializedPlayer the serialized player
     * @return the player
     * @throws IllegalArgumentException if the byte chunk is invalid.
     */
    private static Player deserializePlayer(PlayerID id, List<Byte> serializedPlayer) {
        if (Objects.isNull(serializedPlayer) || serializedPlayer.size() != SERIALIZED_PLAYER_LENGTH)
            throw new IllegalArgumentException();

        List<Integer> intPlayerData = serializedPlayer.stream()
                .map(Byte::toUnsignedInt)
                .collect(Collectors.toList());

        Integer lives = intPlayerData.get(0);
        SubCell pos = new SubCell(intPlayerData.get(1), intPlayerData.get(2));
        Image img = ImageCollection.PLAYERS_IMAGES.imageOrNull(intPlayerData.get(3));
        return new Player(id, lives, pos, img);
    }

    /**
     * Unserializes a byte representation of players.
     *
     * @param serializedPlayers the serialized players
     * @return the list of deserialized players
     * @throws IllegalArgumentException if the byte chunk is invalid.
     */
    private static List<Player> deserializePlayers(List<Byte> serializedPlayers) {
        if (Objects.isNull(serializedPlayers) || serializedPlayers.size() != SERIALIZED_PLAYERS_LENGTH)
            throw new IllegalArgumentException();

        return Collections.unmodifiableList(Arrays.stream(PlayerID.values())
                .map(pid -> {
                    List<Byte> chunk = serializedPlayers.subList(
                            pid.ordinal() * SERIALIZED_PLAYER_LENGTH,
                            (pid.ordinal() + 1) * SERIALIZED_PLAYER_LENGTH);
                    return new AbstractMap.SimpleImmutableEntry<>(pid, chunk);
                })
                .map(e -> deserializePlayer(e.getKey(), e.getValue()))
                .collect(Collectors.toList()));
    }

    /**
     * Unserializes a byte representation of the ticks.
     *
     * @param serializedTicks the serialized ticks
     * @return the ticks
     * @throws IllegalArgumentException if the byte chunk is invalid.
     */
    private static int deserializeTicks(List<Byte> serializedTicks) {
        if (Objects.isNull(serializedTicks) || serializedTicks.size() != SERIALIZED_TICKS_LENGTH)
            throw new IllegalArgumentException();

        return Byte.toUnsignedInt(serializedTicks.get(0));
    }

    /**
     * Deserialize an incoming GameState.
     *
     * @param serializedData the serialized gameState
     * @return a new GameState build from the serialized data.
     */
    public static GameState deserialize(List<Byte> serializedData) {
        VariableLengthChunk chunks = new VariableLengthChunk(serializedData);

        List<Image> board = deserializeBoard(chunks.head());
        chunks = chunks.tail();

        List<Image> explosions = deserializeExplosions(chunks.head());
        chunks = chunks.tail();

        List<Player> players = deserializePlayers(chunks.head(SERIALIZED_PLAYERS_LENGTH));
        chunks = chunks.tail(SERIALIZED_PLAYERS_LENGTH);

        int ticks = deserializeTicks(chunks.head(SERIALIZED_TICKS_LENGTH));

        return new GameState(players, board, explosions, ticks);
    }

}