from minecraft.networking.packets import Packet
from minecraft.networking.types import (
    VarInt, Integer, UnsignedByte, Position, Vector, MutableRecord,
    attribute_alias, multi_attribute_alias, Long, Boolean, VarLong,
)


class BlockChangePacket(Packet):
    id = 0x0B
    packet_name = 'block change'
    definition = [
        {'location': Position},
        {'block_state_id': VarInt}]
    block_state_id = 0

    # For protocols < 347: an accessor for (block_state_id >> 4).
    @property
    def blockId(self):
        return self.block_state_id >> 4

    @blockId.setter
    def blockId(self, block_id):
        self.block_state_id = (self.block_state_id & 0xF) | (block_id << 4)

    # For protocols < 347: an accessor for (block_state_id & 0xF).
    @property
    def blockMeta(self):
        return self.block_state_id & 0xF

    @blockMeta.setter
    def blockMeta(self, meta):
        self.block_state_id = (self.block_state_id & ~0xF) | (meta & 0xF)

    # This alias is retained for backward compatibility.
    blockStateId = attribute_alias('block_state_id')


class MultiBlockChangePacket(Packet):
    id = 0x3B
    packet_name = 'multi block change'

    fields = 'chunk_x', 'chunk_z', 'records'

    # Access the 'chunk_x' and 'chunk_z' fields as a tuple.
    chunk_pos = multi_attribute_alias(tuple, 'chunk_x', 'chunk_z')

    class Record(MutableRecord):
        __slots__ = 'x', 'y', 'z', 'block_state_id', 'location'

        def __init__(self, **kwds):
            self.block_state_id = 0
            super(MultiBlockChangePacket.Record, self).__init__(**kwds)

        # Access the 'x', 'y', 'z' fields as a Vector of ints.
        position = multi_attribute_alias(Vector, 'x', 'y', 'z')

        # For protocols < 347: an accessor for (block_state_id >> 4).
        @property
        def blockId(self):
            return self.block_state_id >> 4

        @blockId.setter
        def blockId(self, block_id):
            self.block_state_id = self.block_state_id & 0xF | block_id << 4

        # For protocols < 347: an accessor for (block_state_id & 0xF).
        @property
        def blockMeta(self):
            return self.block_state_id & 0xF

        @blockMeta.setter
        def blockMeta(self, meta):
            self.block_state_id = self.block_state_id & ~0xF | meta & 0xF

        # This alias is retained for backward compatibility.
        blockStateId = attribute_alias('block_state_id')

        def read(self, file_object, parent):
            data = VarLong.read(file_object)
            self.block_state_id = int(data >> 12)
            self.x = int(data >> 8 & 0xf)
            self.z = int(data >> 4 & 0xf)
            self.y = int(data & 0xf)
            # Absolute position in world to be compatible with BlockChangePacket
            self.location = Vector(self.position.x + parent.chunk_x*16, self.position.y, self.position.z + parent.chunk_z*16)

        def write(self, packet_buffer):
            raise
            UnsignedByte.send(self.x << 4 | self.z & 0xF, packet_buffer)
            UnsignedByte.send(self.y, packet_buffer)
            VarInt.send(self.block_state_id, packet_buffer)

    def read(self, file_object):
        coords = Long.read(file_object)
        self.chunk_x = int(coords >> 42 & 0x3fffff)
        self.chunk_z = int(coords >> 20 & 0x3fffff)
        self.chunk_y = int(coords & 0xfffff)
        self.unknown = Boolean.read(file_object)
        array_size = VarInt.read(file_object)
        self.records = []
        for i in range(array_size):
            record = self.Record()
            record.read(file_object, self)
            self.records.append(record)

    def write_fields(self, packet_buffer):
        raise
        Integer.send(self.chunk_x, packet_buffer)
        Integer.send(self.chunk_z, packet_buffer)
        VarInt.send(len(self.records), packet_buffer)
        for record in self.records:
            record.write(packet_buffer)