import io
import time
import unittest
from munch import Munch

from minecraft.networking.modern import (
    ClientTickEnd, EntityAnimationPacket, EntitySwingAnimationPacket,
    PunchPacket,
)
from mosfet.game import Game


class RecordingConnection:
    def __init__(self):
        self.packets = []

    def write_packet(self, packet, force=False):
        self.packets.append((packet, force))


class BlockBreakAnimationTests(unittest.TestCase):
    def make_game(self):
        connection = RecordingConnection()
        game = object.__new__(Game)
        game.g = Munch(connection=connection, inv={}, inventory_state_ids={})
        game.sequence = 0
        game.break_deadline = None
        game.breaking_state = None
        game.next_swing_at = 0.0
        return game, connection

    def test_26_3_punch_packet_is_the_empty_serverbound_packet(self):
        self.assertEqual(PunchPacket.id, 0x2E)
        self.assertEqual(PunchPacket.definition, [])

    def test_observer_packet_decodes_entity_id_and_swing_kind(self):
        packet = EntityAnimationPacket()
        packet.read(io.BytesIO(bytes((0x85, 0x01, 0))))
        self.assertEqual(packet.entity_id, 133)
        self.assertEqual(packet.animation, 0)

    def test_26_3_observer_swing_packet_decodes_animation_details(self):
        packet = EntitySwingAnimationPacket()
        packet.read(io.BytesIO(bytes((0x85, 0x01, 0, 1, 6))))
        self.assertEqual(EntitySwingAnimationPacket.id, 0x7B)
        self.assertEqual((packet.entity_id, packet.hand,
                          packet.animation_type, packet.duration),
                         (133, 0, 1, 6))

    def test_animate_sends_punch_before_client_tick_end(self):
        game, connection = self.make_game()
        game.animate()
        self.assertEqual([type(packet) for packet, _ in connection.packets],
                         [PunchPacket, ClientTickEnd])
        self.assertTrue(all(force for _, force in connection.packets))

    def test_breaking_sends_initial_and_periodic_punches(self):
        game, connection = self.make_game()
        game.g.breaking = (1, 2, 3)
        game.break_deadline = time.monotonic() + 5
        game.breaking_state = 10
        game.next_swing_at = 0

        game.tick()
        self.assertEqual(sum(isinstance(packet, PunchPacket)
                             for packet, _ in connection.packets), 1)
        sent = len(connection.packets)
        game.tick()
        self.assertEqual(len(connection.packets), sent)

        game.next_swing_at = 0
        game.tick()
        self.assertEqual(sum(isinstance(packet, PunchPacket)
                             for packet, _ in connection.packets), 2)


if __name__ == '__main__':
    unittest.main()