import math
import unittest
from unittest.mock import patch
from munch import Munch

from mosfet import utils
from mosfet.game import Game
from mosfet.info import blocks, items


class BlockBreakTimingTests(unittest.TestCase):
    def test_leaf_time_uses_actual_tool_speed_and_game_ticks(self):
        oak_leaves = blocks.MCD_BLOCKS['oak_leaves']['minStateId']
        oak_log = items.get_id('oak_log')
        wooden_hoe = items.get_id('wooden_hoe')

        self.assertAlmostEqual(utils.break_time(oak_leaves, oak_log), 0.3)
        self.assertAlmostEqual(utils.break_time(oak_leaves, wooden_hoe), 0.15)
        self.assertAlmostEqual(
            utils.break_time(oak_leaves, oak_log, in_water=True), 1.5)
        self.assertAlmostEqual(
            utils.break_time(oak_leaves, oak_log, on_ground=False), 1.5)

    def test_efficiency_haste_and_fatigue_affect_break_ticks(self):
        oak_leaves = blocks.MCD_BLOCKS['oak_leaves']['minStateId']
        wooden_hoe = items.get_id('wooden_hoe')
        self.assertAlmostEqual(utils.break_time(
            oak_leaves, wooden_hoe, enchantments={'efficiency': 1}), 0.1)
        self.assertAlmostEqual(utils.break_time(
            oak_leaves, wooden_hoe, effects={'haste': 0}), 0.15)
        self.assertAlmostEqual(utils.break_time(
            oak_leaves, wooden_hoe,
            effects={'mining_fatigue': 0}), 0.5)

    def test_unbreakable_blocks_have_no_completion_deadline(self):
        bedrock = blocks.MCD_BLOCKS['bedrock']['minStateId']
        self.assertTrue(math.isinf(utils.break_time(bedrock)))

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

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

        class FakeChunks:
            @staticmethod
            def get_block_at(*_position):
                return blocks.MCD_BLOCKS['oak_leaves']['minStateId']

        connection = RecordingConnection()
        game = object.__new__(Game)
        game.g = Munch(
            connection=connection, chunks=FakeChunks(), inv={},
            holding=items.get_id('oak_log'), holding_hand=0,
            holding_slot=0)
        game.sequence = 0
        game.break_deadline = None
        game.breaking_state = None
        game.next_swing_at = 0.0

        with patch('mosfet.game.time.monotonic', return_value=100.0):
            self.assertTrue(game.break_block((0, 64, 0)))
        self.assertAlmostEqual(game.break_deadline, 100.3)


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