import enum

from MechFabrik.bauteile.items import Gyroskope, Item, ItemStatus


class ZoneNames(enum.Enum):
    HEAD = 'Kopf'
    MIDDLE_TORSO_FRONT = 'Torso Mitte Vorn'
    MIDDLE_TORSO_REAR = 'Torso Mitte Rücken'
    RIGHT_TORSO_FRONT = 'Rechter Torso Vorn'
    RIGHT_TORSO_REAR = 'Rechter Torso Rücken'
    LEFT_TORSO_FRONT = 'Linker Torso Vorn'
    LEFT_TORSO_REAR = 'Linker Torso Rücken'
    RIGHT_LEG = 'Rechtes Bein'
    RIGHT_ARM = 'Rechter Arm'
    LEFT_LEG = 'Linkes Bein'
    LEFT_ARM = 'Linker Arm'


class AreaNames(enum.Enum):
    HEAD = 'Kopf'
    MIDDLE_TORSO = 'Torso Mitte'
    RIGHT_TORSO = 'Rechter Torso'
    LEFT_TORSO = 'Linker Torso'
    RIGHT_LEG = 'Rechtes Bein'
    RIGHT_ARM = 'Rechter Arm'
    LEFT_LEG = 'Linkes Bein'
    LEFT_ARM = 'Linker Arm'


class AreaStatus(enum.Flag):
    FINE = 0
    DAMAGED = 1
    DESTROYED = 2


class Zone:

    def __init__(self):
        self.__dict__['_armor'] = 0
        self.__dict__['_parent'] = None
        self.__dict__['_state'] = AreaStatus.FINE

    def __setattr__(self, key, value):
        self.__dict__['_' + key] = value

    def __getattr__(self, item):
        return self.__dict__['_' + item]


class Area(Zone):

    def __init__(self):
        super().__init__()
        self.__dict__['_outer_amor'] = list()
        self.__dict__['_children'] = list()
        self.__dict__['_items'] = dict()


class OuterAmor(Zone):

    def __init__(self, area: Area):
        super().__init__()
        self.__dict__['_parent'] = area
        self.__dict__['_area'] = area


class StrikeEvent:
    def __init__(self, zone: Zone, hits: int):
        self._zone = zone
        self._hits = hits

    @property
    def zone(self) -> Zone:
        return self._zone

    @property
    def hits(self) -> int:
        return self._hits

    @hits.setter
    def hits(self, hits: int):
        self._hits = hits

    def process_event(self) -> StrikeEvent:
        while self.hits > 0:
            if self.hits >= self.zone.armor:
                self.hits -= self.zone.armor
                self.zone.armor = 0
                self.zone.state = AreaStatus.DESTROYED
                if self.hits > 0:
                    self._zone = self.zone.parent
            else:
                self.zone.armor -= self.hits
                self.zone.state = AreaStatus.DAMAGED
                self.hits = 0
                break
        return self


class InnerStructure:

    def __init__(self, tonnage: float, gyroskope: Gyroskope):
        self._gyroskope = gyroskope
        self._tonnage = tonnage
        self._areas = dict()
        self._zones = dict()

    @property
    def tonnage(self) -> float:
        return self._tonnage

    @property
    def gyroskope(self) -> Gyroskope:
        return self._gyroskope

    @property
    def areas(self) -> dict[AreaNames, Area]:
        return self._areas

    def add_area(self, index: AreaNames, area: Area):
        self._areas[index] = area

    @property
    def zones(self) -> dict[ZoneNames, OuterAmor]:
        return self._zones

    def add_zone(self, index: ZoneNames, zone: OuterAmor):
        self._zones[index] = zone


class CriticalStrikeEvent:
    def __init__(self, zone: OuterAmor, index: tuple[int,int]):
        self.__dict__['_zone'] = zone
        self.__dict__['_area'] = zone.area
        self.__dict__['_index'] = index
        self.__dict__['_item_is_empty'] = None

    @property
    def area(self) -> Area:
        return self.__dict__['_area']

    def process_event(self) -> CriticalStrikeEvent:
        self.__dict__['_zone'].state = AreaStatus.DAMAGED
        self.__dict__['_area'].state = AreaStatus.DAMAGED
        item = self.__dict__['_area'].items[self.__dict__['_index']]
        if item is None or item.state == ItemStatus.DESTROYED:
            self.__dict__['_item_is_empty'] = True
        else:
            self.__dict__['_item_is_empty'] = False
            item.process_strike()
        return self

    def is_empty(self):
        return self.__dict__['_item_is_empty']