#  • ▌ ▄ ·. ▄▄▄▄·     ▄▄▄ .·▄▄▄▄  ▪  ▄▄▄▄▄      ▄▄▄       ▄▄▄·▄▄▄
#  ·██ ▐███▪▐█ ▀█▪    ▀▄.▀·██▪ ██ ██ •██  ▪     ▀▄ █·    ▐█ ▄█▀▄ █·▪
#  ▐█ ▌▐▌▐█·▐█▀▀█▄    ▐▀▀▪▄▐█· ▐█▌▐█· ▐█.▪ ▄█▀▄ ▐▀▀▄      ██▀·▐▀▀▄  ▄█▀▄
#  ██ ██▌▐█▌██▄▪▐█    ▐█▄▄▌██. ██ ▐█▌ ▐█▌·▐█▌.▐▌▐█•█▌    ▐█▪·•▐█•█▌▐█▌.▐▌
#  ▀▀  █▪▀▀▀·▀▀▀▀      ▀▀▀ ▀▀▀▀▀• ▀▀▀ ▀▀▀  ▀█▄▀▪.▀  ▀    .▀   .▀  ▀ ▀█▄▀▪
#                Magicbane Emulator Project © 2013 - 2022
#                           www.magicbane.com
import copy
from collections import OrderedDict

from arcane.enums.hashes import hash_to_string, string_to_hash
from arcane.util import ResStream


class AttributeValue:
    def load_binary(self, stream: ResStream):
        self.attr_type = stream.read_dword()
        self.attr_value = stream.read_long()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.attr_type)
        stream.write_long(self.attr_value)

    def load_json(self, data):
        self.attr_type = string_to_hash(data['attr_type'])
        self.attr_value = data['attr_value']

    def save_json(self):
        data = OrderedDict()
        data['attr_type'] = hash_to_string(self.attr_type)
        data['attr_value'] = self.attr_value
        return data


class PowerArgument:
    def load_binary(self, stream: ResStream):
        self.power_arguments = [
            stream.read_long(),
            stream.read_long(),
        ]

    def save_binary(self, stream: ResStream):
        stream.write_long(self.power_arguments[0])
        stream.write_long(self.power_arguments[1])

    def load_json(self, data):
        self.power_arguments = data['power_arguments']

    def save_json(self):
        data = OrderedDict()
        data['power_arguments'] = self.power_arguments
        return data


class SkillLevel:
    def load_binary(self, stream: ResStream):
        self.skill_type = stream.read_dword()
        self.skill_level = stream.read_long()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.skill_type)
        stream.write_long(self.skill_level)

    def load_json(self, data):
        self.skill_type = string_to_hash(data['skill_type'])
        self.skill_level = data['skill_level']

    def save_json(self):
        data = OrderedDict()
        data['skill_type'] = hash_to_string(self.skill_type)
        data['skill_level'] = self.skill_level
        return data


class ResourceInfo:
    def load_binary(self, stream: ResStream):
        self.resource_type = stream.read_dword()
        self.resource_value = stream.read_long()

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.resource_type)
        stream.write_long(self.resource_value)

    def load_json(self, data):
        self.resource_type = string_to_hash(data['resource_type'])
        self.resource_value = data['resource_value']

    def save_json(self):
        data = OrderedDict()
        data['resource_type'] = hash_to_string(self.resource_type)
        data['resource_value'] = self.resource_value
        return data


class PowerAction:
    def load_binary(self, stream: ResStream):
        self.power_type = stream.read_dword()

        num_grants = stream.read_dword()
        self.power_actions = [PowerArgument() for _ in range(num_grants)]
        for power in self.power_actions:
            power.load_binary(stream)

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.power_type)
        stream.write_dword(len(self.power_actions))
        for power in self.power_actions:
            power.save_binary(stream)

    def load_json(self, data):
        self.power_type = string_to_hash(data['power_type'])
        self.power_actions = []
        for power_data in data['power_actions']:
            power = PowerArgument()
            power.load_json(power_data)
            self.power_actions.append(power)

    def save_json(self):
        data = OrderedDict()
        data['power_type'] = hash_to_string(self.power_type)
        data['power_actions'] = []
        for power in self.power_actions:
            data['power_actions'].append(power.save_json())
        return data


def _read_granted_pairs(stream: ResStream):
    num_pairs = stream.read_dword()
    return [
        [
            stream.read_dword(),
            stream.read_long(),
        ] for _ in range(num_pairs)
    ]


def _write_granted_pairs(stream: ResStream, pairs):
    stream.write_dword(len(pairs))
    for pair in pairs:
        stream.write_dword(pair[0])
        stream.write_long(pair[1])


def _hash_pair_keys(pairs):
    pairs_copy = copy.deepcopy(pairs)
    for pair in pairs_copy:
        pair[0] = hash_to_string(pair[0])
    return pairs_copy


def _unhash_pair_keys(pairs):
    pairs_copy = copy.deepcopy(pairs)
    for pair in pairs_copy:
        pair[0] = string_to_hash(pair[0])
    return pairs_copy


class PowerGrant:
    def load_binary(self, stream: ResStream):
        self.power_type = stream.read_dword()
        self.power_value = stream.read_long()
        self.power_granted_attrs = _read_granted_pairs(stream)
        self.power_granted_skills = _read_granted_pairs(stream)
        self.power_granted_powers = _read_granted_pairs(stream)
        num_monster_types = stream.read_dword()
        self.power_monster_types = [
            stream.read_dword() for _ in range(num_monster_types)
        ]

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.power_type)
        stream.write_long(self.power_value)
        _write_granted_pairs(stream, self.power_granted_attrs)
        _write_granted_pairs(stream, self.power_granted_skills)
        _write_granted_pairs(stream, self.power_granted_powers)
        stream.write_dword(len(self.power_monster_types))
        for value in self.power_monster_types:
            stream.write_dword(value)

    def load_json(self, data):
        self.power_type = string_to_hash(data['power_type'])
        self.power_value = data['power_value']
        self.power_granted_attrs = _unhash_pair_keys(data['power_granted_attrs'])
        self.power_granted_skills = _unhash_pair_keys(data['power_granted_skills'])
        self.power_granted_powers = _unhash_pair_keys(data['power_granted_powers'])
        self.power_monster_types = data['power_monster_types']

    def save_json(self):
        data = OrderedDict()
        data['power_type'] = hash_to_string(self.power_type)
        data['power_value'] = self.power_value
        data['power_granted_attrs'] = _hash_pair_keys(self.power_granted_attrs)
        data['power_granted_skills'] = _hash_pair_keys(self.power_granted_skills)
        data['power_granted_powers'] = _hash_pair_keys(self.power_granted_powers)
        data['power_monster_types'] = self.power_monster_types
        return data


class SkillGrant:
    def load_binary(self, stream: ResStream):
        self.skill_type = stream.read_dword()
        self.skill_value = stream.read_long()
        self.skill_granted_attrs = _read_granted_pairs(stream)
        self.skill_granted_skills = _read_granted_pairs(stream)
        self.skill_granted_powers = _read_granted_pairs(stream)
        num_monster_types = stream.read_dword()
        self.skill_monster_types = [
            stream.read_dword() for _ in range(num_monster_types)
        ]

    def save_binary(self, stream: ResStream):
        stream.write_dword(self.skill_type)
        stream.write_long(self.skill_value)
        _write_granted_pairs(stream, self.skill_granted_attrs)
        _write_granted_pairs(stream, self.skill_granted_skills)
        _write_granted_pairs(stream, self.skill_granted_powers)
        stream.write_dword(len(self.skill_monster_types))
        for value in self.skill_monster_types:
            stream.write_dword(value)

    def load_json(self, data):
        self.skill_type = string_to_hash(data['skill_type'])
        self.skill_value = data['skill_value']
        self.skill_granted_attrs = _unhash_pair_keys(data['skill_granted_attrs'])
        self.skill_granted_skills = _unhash_pair_keys(data['skill_granted_skills'])
        self.skill_granted_powers = _unhash_pair_keys(data['skill_granted_powers'])
        self.skill_monster_types = data['skill_monster_types']

    def save_json(self):
        data = OrderedDict()
        data['skill_type'] = hash_to_string(self.skill_type)
        data['skill_value'] = self.skill_value
        data['skill_granted_attrs'] = _hash_pair_keys(self.skill_granted_attrs)
        data['skill_granted_skills'] = _hash_pair_keys(self.skill_granted_skills)
        data['skill_granted_powers'] = _hash_pair_keys(self.skill_granted_powers)
        data['skill_monster_types'] = self.skill_monster_types
        return data