import re

from frostfs_testlib.storage.cluster import ClusterNode
from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetInfo, NodeNetmapInfo, NodeStatus


class NetmapParser:
    @staticmethod
    def netinfo(output: str) -> NodeNetInfo:
        regexes = {
            "epoch": r"Epoch: (?P<epoch>\d+)",
            "network_magic": r"Network magic: (?P<network_magic>.*$)",
            "time_per_block": r"Time per block: (?P<time_per_block>\d+\w+)",
            "container_fee": r"Container fee: (?P<container_fee>\d+)",
            "epoch_duration": r"Epoch duration: (?P<epoch_duration>\d+)",
            "inner_ring_candidate_fee": r"Inner Ring candidate fee: (?P<inner_ring_candidate_fee>\d+)",
            "maximum_object_size": r"Maximum object size: (?P<maximum_object_size>\d+)",
            "maximum_count_of_data_shards": r"Maximum count of data shards: (?P<maximum_count_of_data_shards>\d+)",
            "maximum_count_of_parity_shards": r"Maximum count of parity shards: (?P<maximum_count_of_parity_shards>\d+)",
            "withdrawal_fee": r"Withdrawal fee: (?P<withdrawal_fee>\d+)",
            "homomorphic_hashing_disabled": r"Homomorphic hashing disabled: (?P<homomorphic_hashing_disabled>true|false)",
            "maintenance_mode_allowed": r"Maintenance mode allowed: (?P<maintenance_mode_allowed>true|false)",
            "eigen_trust_alpha": r"EigenTrustAlpha: (?P<eigen_trust_alpha>\d+\w+$)",
            "eigen_trust_iterations": r"EigenTrustIterations: (?P<eigen_trust_iterations>\d+)",
        }
        parse_result = {}

        for key, regex in regexes.items():
            search_result = re.search(regex, output, flags=re.MULTILINE)
            if search_result == None:
                parse_result[key] = None
                continue
            parse_result[key] = search_result[key].strip()

        node_netinfo = NodeNetInfo(**parse_result)

        return node_netinfo

    @staticmethod
    def snapshot_all_nodes(output: str) -> list[NodeNetmapInfo]:
        """The code will parse each line and return each node as dataclass."""
        netmap_nodes = output.split("Node ")[1:]
        dataclasses_netmap = []
        result_netmap = {}

        regexes = {
            "node_id": r"\d+: (?P<node_id>\w+)",
            "node_data_ips": r"(?P<node_data_ips>/ip4/.+?)$",
            "node_status": r"(?P<node_status>ONLINE|MAINTENANCE|OFFLINE)",
            "cluster_name": r"ClusterName: (?P<cluster_name>\w+)",
            "continent": r"Continent: (?P<continent>\w+)",
            "country": r"Country: (?P<country>\w+)",
            "country_code": r"CountryCode: (?P<country_code>\w+)",
            "external_address": r"ExternalAddr: (?P<external_address>/ip[4].+?)$",
            "location": r"Location: (?P<location>\w+.*)",
            "node": r"Node: (?P<node>\d+\.\d+\.\d+\.\d+)",
            "price": r"Price: (?P<price>\d+)",
            "sub_div": r"SubDiv: (?P<sub_div>.*)",
            "sub_div_code": r"SubDivCode: (?P<sub_div_code>\w+)",
            "un_locode": r"UN-LOCODE: (?P<un_locode>\w+.*)",
            "role": r"role: (?P<role>\w+)",
        }

        for node in netmap_nodes:
            for key, regex in regexes.items():
                search_result = re.search(regex, node, flags=re.MULTILINE)
                if search_result == None:
                    result_netmap[key] = None
                    continue
                if key == "node_data_ips":
                    result_netmap[key] = search_result[key].strip().split(" ")
                    continue
                if key == "external_address":
                    result_netmap[key] = search_result[key].strip().split(",")
                    continue
                if key == "node_status":
                    result_netmap[key] = NodeStatus(search_result[key].strip().lower())
                    continue
                result_netmap[key] = search_result[key].strip()

            dataclasses_netmap.append(NodeNetmapInfo(**result_netmap))

        return dataclasses_netmap

    @staticmethod
    def snapshot_one_node(output: str, cluster_node: ClusterNode) -> NodeNetmapInfo | None:
        snapshot_nodes = NetmapParser.snapshot_all_nodes(output=output)
        snapshot_node = [node for node in snapshot_nodes if node.node == cluster_node.host_ip]
        if not snapshot_node:
            return None
        return snapshot_node[0]