from collections import defaultdict
import logging

from libnmstate.error import NmstateNotImplementedError
from libnmstate.error import NmstateVerificationError
from libnmstate.error import NmstateValueError
from libnmstate.iplib import KERNEL_MAIN_ROUTE_TABLE_ID
from libnmstate.iplib import is_ipv6_address
from libnmstate.iplib import canonicalize_ip_network
from libnmstate.prettystate import format_desired_current_state_diff
from libnmstate.schema import Interface
from libnmstate.schema import RouteRule
from libnmstate.schema import Route

from .state import StateEntry
from .state import state_match


class RouteRuleEntry(StateEntry):
    def __init__(self, route_rule):
        self.ip_from = route_rule.get(RouteRule.IP_FROM)
        self.ip_to = route_rule.get(RouteRule.IP_TO)
        self.priority = route_rule.get(RouteRule.PRIORITY)
        self.route_table = route_rule.get(RouteRule.ROUTE_TABLE)
        self._complement_defaults()
        self._canonicalize_ip_network()

    def _complement_defaults(self):
        if self.ip_from is None:
            self.ip_from = ""
        if self.ip_to is None:
            self.ip_to = ""
        if self.priority is None:
            self.priority = RouteRule.USE_DEFAULT_PRIORITY
        if (
            self.route_table is None
            or self.route_table == RouteRule.USE_DEFAULT_ROUTE_TABLE
        ):
            self.route_table = KERNEL_MAIN_ROUTE_TABLE_ID

    def _canonicalize_ip_network(self):
        if self.ip_from:
            self.ip_from = canonicalize_ip_network(self.ip_from)
        if self.ip_to:
            self.ip_to = canonicalize_ip_network(self.ip_to)

    def _keys(self):
        return (self.ip_from, self.ip_to, self.priority, self.route_table)

    @property
    def is_ipv6(self):
        if self.ip_from:
            return is_ipv6_address(self.ip_from)
        elif self.ip_to:
            return is_ipv6_address(self.ip_to)
        else:
            logging.warning(
                f"Neither {RouteRule.IP_FROM} nor {RouteRule.IP_TO} "
                "is defined, treating it a IPv4 route rule"
            )
            return False

    @property
    def absent(self):
        raise NmstateNotImplementedError(
            "RouteRuleEntry does not support absent property"
        )

    def is_valid(self, config_iface_routes):
        """
        Return False when there is no route for defined route table.
        """
        found = False
        for route_set in config_iface_routes.values():
            for route in route_set:
                if route.table_id == self.route_table or (
                    route.table_id == Route.USE_DEFAULT_ROUTE_TABLE
                    and self.route_table == KERNEL_MAIN_ROUTE_TABLE_ID
                ):
                    found = True
                    break
        return found


class RouteRuleState:
    def __init__(self, route_state, des_rule_state, cur_rule_state):
        self._config_changed = False
        self._cur_rules = defaultdict(set)
        self._rules = defaultdict(set)
        if cur_rule_state:
            for rule_dict in _get_config(cur_rule_state):
                rule = RouteRuleEntry(rule_dict)
                self._cur_rules[rule.route_table].add(rule)
        if des_rule_state:
            for rule_dict in _get_config(des_rule_state):
                rule = RouteRuleEntry(rule_dict)
                self._rules[rule.route_table].add(rule)
            if self._rules != self._cur_rules:
                self._config_changed = True
        else:
            # Discard invalid route rule when merging from current
            for rules in self._cur_rules.values():
                for rule in rules:
                    if not route_state or rule.is_valid(
                        route_state.config_iface_routes
                    ):
                        self._rules[rule.route_table].add(rule)

    @property
    def _config(self):
        return _get_config(self._rules)

    def verify(self, cur_rule_state):
        current = RouteRuleState(
            route_state=None,
            des_rule_state=None,
            cur_rule_state=cur_rule_state,
        )
        for route_table, rules in self._rules.items():
            rule_info = [
                _remove_route_rule_default_values(r.to_dict())
                for r in sorted(rules)
            ]
            cur_rule_info = [
                r.to_dict()
                for r in sorted(current._rules.get(route_table, set()))
            ]

            if not state_match(rule_info, cur_rule_info):
                raise NmstateVerificationError(
                    format_desired_current_state_diff(
                        {RouteRule.KEY: {RouteRule.CONFIG: rule_info}},
                        {RouteRule.KEY: {RouteRule.CONFIG: cur_rule_info}},
                    )
                )

    @property
    def config_changed(self):
        return self._config_changed

    def gen_metadata(self, route_state):
        """
        Generate metada which could used for storing into interface.
        Data structure returned is:
            {
                iface_name: {
                    Interface.IPV4: ipv4_route_rules,
                    Interface.IPV6: ipv6_route_rules,
                }
            }
        """
        route_rule_metadata = {}
        for route_table, rules in self._rules.items():
            iface_name = self._iface_for_route_table(route_state, route_table)
            route_rule_metadata[iface_name] = {
                Interface.IPV4: [],
                Interface.IPV6: [],
            }
            for rule in rules:
                family = Interface.IPV6 if rule.is_ipv6 else Interface.IPV4
                route_rule_metadata[iface_name][family].append(rule.to_dict())
        return route_rule_metadata

    def _iface_for_route_table(self, route_state, route_table):
        for routes in route_state.config_iface_routes.values():
            for route in routes:
                if route.table_id == route_table:
                    return route.next_hop_interface
        raise NmstateValueError(
            "Failed to find interface to with route table ID "
            f"{route_table} to store route rules"
        )


def _get_config(state):
    return state.get(RouteRule.CONFIG, [])


def _remove_route_rule_default_values(rule):
    if rule.get(RouteRule.PRIORITY) == RouteRule.USE_DEFAULT_PRIORITY:
        del rule[RouteRule.PRIORITY]
    if rule.get(RouteRule.ROUTE_TABLE) == RouteRule.USE_DEFAULT_ROUTE_TABLE:
        del rule[RouteRule.ROUTE_TABLE]
    return rule