from events import CriticalStrikeEvent, StrikeEvent
from mech_factory.component_storage.items import BigItem, DurableItem, Item, ItemStatus, ItemTypes
from test_mech import AbstractTestMechAmor, INNER_ARMOR, NEXT_OUTER_ZONE, OUTER_ARMOR
from mech_factory.component_storage import Area, AreaStatus, OuterAmor, ZoneNames


class TestMechAmor(AbstractTestMechAmor):

    def test_process(self):
        self.mech = self.factory.auslieferung()
        for zone_name in ZoneNames:
            with self.subTest(msg=zone_name.value):
                zone = self.mech.inner_structure.zones.get(zone_name)
                area = zone.area
                start_outer_armor = OUTER_ARMOR[zone_name]
                start_inner_armor = INNER_ARMOR[NEXT_OUTER_ZONE[zone_name]]

                self.assertEqual(start_outer_armor, zone.armor)
                self.assertEqual(area, zone.parent)
                self.assertEqual(start_inner_armor, area.armor)
                self.assertEqual(AreaStatus.FINE, zone.state)
                self.assertEqual(AreaStatus.FINE, area.state)

                event = self.mech.strike(zone_name, 10)
                self.assertEqual(start_outer_armor, zone.armor)
                self.assertEqual(start_inner_armor, area.armor)
                self.assertEqual(AreaStatus.FINE, zone.state)
                self.assertEqual(AreaStatus.FINE, area.state)
                self.assertIsInstance(event, StrikeEvent)
                self.assertEqual(zone, event.zone)
                self.assertEqual(10, event.hits)
                self.assertEqual(area, event.zone.parent)

    def test_critical_process(self):
        self.mech = self.factory.auslieferung()
        for zone_name in ZoneNames:
            with self.subTest(msg=zone_name.value):
                zone = self.mech.inner_structure.zones.get(zone_name)
                area = zone.area

                event = self.mech.critical_strike(zone_name, (1, 2))
                self.assertIsInstance(event, CriticalStrikeEvent)
                self.assertEqual(area, event.area)
                self.assertIsNone(event.is_empty())

    def test_strike(self):
        start_outer_armor = 11
        start_area_armor = 5
        start_parent_armor = 3
        parent = Area()
        parent.armor = start_parent_armor
        area = Area()
        area.armor = start_area_armor
        area.parent = parent
        zone = OuterAmor(area)
        zone.armor = start_outer_armor

        self.assertEqual(start_outer_armor, zone.armor)
        self.assertEqual(start_area_armor, area.armor)
        self.assertEqual(AreaStatus.FINE, zone.state)
        self.assertEqual(AreaStatus.FINE, area.state)

        event = StrikeEvent(zone, start_outer_armor - 3).process_event()
        self.assertEqual(3, zone.armor)
        self.assertEqual(start_area_armor, area.armor)
        self.assertEqual(AreaStatus.DAMAGED, zone.state)
        self.assertEqual(AreaStatus.FINE, area.state)
        self.assertIsInstance(event, StrikeEvent)
        self.assertEqual(zone, event.zone)
        self.assertEqual(0, event.hits)

        event = StrikeEvent(zone, 4).process_event()
        self.assertEqual(0, zone.armor)
        self.assertEqual(start_area_armor - 1, area.armor)
        self.assertEqual(AreaStatus.DESTROYED, zone.state)
        self.assertEqual(AreaStatus.DAMAGED, area.state)
        self.assertIsInstance(event, StrikeEvent)
        self.assertEqual(area, event.zone)
        self.assertEqual(0, event.hits)

        event = StrikeEvent(zone, start_area_armor - 1).process_event()
        self.assertEqual(0, zone.armor)
        self.assertEqual(0, area.armor)
        self.assertEqual(AreaStatus.DESTROYED, zone.state)
        self.assertEqual(AreaStatus.DESTROYED, area.state)
        self.assertIsInstance(event, StrikeEvent)
        self.assertEqual(area, event.zone)
        self.assertEqual(0, event.hits)

        event = StrikeEvent(zone, 1).process_event()
        self.assertEqual(0, zone.armor)
        self.assertEqual(0, area.armor)
        self.assertEqual(AreaStatus.DESTROYED, zone.state)
        self.assertEqual(AreaStatus.DESTROYED, area.state)
        self.assertIsInstance(event, StrikeEvent)
        self.assertNotEqual(area, event.zone)
        self.assertEqual(area.parent, event.zone)
        self.assertEqual(0, event.hits)

    # noinspection PyUnresolvedReferences
    def test_critical_strike(self):
        parent = Area()
        area = Area()
        area.parent = parent
        big_item_01 = BigItem(ItemTypes.SUSTAINMENT, 5.0)
        item_01 = Item(ItemTypes.SUSTAINMENT)
        durable_item_01 = DurableItem(ItemTypes.SUSTAINMENT, 3)
        area.items = {
                (1, 1): big_item_01,
                (1, 2): durable_item_01,
                (1, 3): durable_item_01,
                (1, 4): None,
                (1, 5): item_01,
                (1, 6): None,
                }

        zone = OuterAmor(area)

        event = CriticalStrikeEvent(zone, (1, 1)).process_event()
        self.assertEqual(AreaStatus.DAMAGED, zone.state)
        self.assertEqual(AreaStatus.DAMAGED, area.state)
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertFalse(event.is_empty())
        self.assertEqual(area, event.area)
        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 1)].state)

        event = CriticalStrikeEvent(zone, (1, 5)).process_event()
        self.assertEqual(AreaStatus.DAMAGED, zone.state)
        self.assertEqual(AreaStatus.DAMAGED, area.state)
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertFalse(event.is_empty())
        self.assertEqual(area, event.area)
        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 5)].state)

        event = CriticalStrikeEvent(zone, (1, 2)).process_event()
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertFalse(event.is_empty())
        self.assertEqual(area, event.area)
        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 2)].state)
        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 3)].state)

        event = CriticalStrikeEvent(zone, (1, 3)).process_event()
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertFalse(event.is_empty())
        self.assertEqual(area, event.area)
        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 2)].state)
        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 3)].state)

        event = CriticalStrikeEvent(zone, (1, 2)).process_event()
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertFalse(event.is_empty())
        self.assertEqual(area, event.area)
        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 2)].state)
        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 5)].state)

        event = CriticalStrikeEvent(zone, (1, 4)).process_event()
        self.assertIsInstance(event, CriticalStrikeEvent)
        self.assertTrue(event.is_empty())
        self.assertEqual(area, event.area)