# Copyright 2017 VMware, Inc.
#
# All Rights Reserved
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

from neutron_dynamic_routing.db import bgp_db
from neutron_dynamic_routing.extensions import bgp as bgp_ext
from neutron_lib.callbacks import events
from neutron_lib.callbacks import registry
from neutron_lib.callbacks import resources
from neutron_lib import context as n_context
from neutron_lib import exceptions as n_exc
from neutron_lib.plugins import directory
from neutron_lib.services import base as service_base
from oslo_log import log as logging

from vmware_nsx.common import locking
from vmware_nsx.common import nsxv_constants
from vmware_nsx.db import nsxv_db
from vmware_nsx.extensions import edge_service_gateway_bgp_peer as ext_esg
from vmware_nsx.extensions import projectpluginmap
from vmware_nsx.plugins.nsx import utils as tvd_utils
from vmware_nsx.services.dynamic_routing.nsx_v import driver as nsxv_driver

LOG = logging.getLogger(__name__)
PLUGIN_NAME = bgp_ext.BGP_EXT_ALIAS + '_nsx_svc_plugin'


@tvd_utils.filter_plugins
class NSXBgpPlugin(service_base.ServicePluginBase, bgp_db.BgpDbMixin):
    """BGP service plugin for NSX-V as well as TVD plugins.

    Currently only the nsx-v is supported. other plugins will be refused.
    """

    supported_extension_aliases = [bgp_ext.BGP_EXT_ALIAS,
                                   ext_esg.ESG_BGP_PEER_EXT_ALIAS]

    methods_to_separate = ['get_bgp_speakers',
                           'get_bgp_peers']

    def __init__(self):
        super(NSXBgpPlugin, self).__init__()
        self._core_plugin = directory.get_plugin()

        # initialize the supported drivers (currently only NSX-v)
        self.drivers = {}
        try:
            self.drivers[projectpluginmap.NsxPlugins.NSX_V] = (
                nsxv_driver.NSXvBgpDriver(self))
        except Exception:
            # No driver found
            LOG.warning("NSXBgpPlugin failed to initialize the NSX-V driver")
            self.drivers[projectpluginmap.NsxPlugins.NSX_V] = None

        self._register_callbacks()

    def get_plugin_name(self):
        return PLUGIN_NAME

    def get_plugin_type(self):
        return bgp_ext.BGP_EXT_ALIAS

    def get_plugin_description(self):
        """returns string description of the plugin."""
        return ("BGP dynamic routing service for announcement of next-hops "
                "for project networks, floating IP's, and DVR host routes.")

    def _register_callbacks(self):
        registry.subscribe(self.router_interface_callback,
                           resources.ROUTER_INTERFACE,
                           events.AFTER_CREATE)
        registry.subscribe(self.router_interface_callback,
                           resources.ROUTER_INTERFACE,
                           events.AFTER_DELETE)
        registry.subscribe(self.router_gateway_callback,
                           resources.ROUTER_GATEWAY,
                           events.AFTER_UPDATE)
        registry.subscribe(self.router_gateway_callback,
                           resources.ROUTER_GATEWAY,
                           events.AFTER_DELETE)
        registry.subscribe(self._after_service_edge_create_callback,
                           nsxv_constants.SERVICE_EDGE,
                           events.AFTER_CREATE)
        registry.subscribe(self._before_service_edge_delete_callback,
                           nsxv_constants.SERVICE_EDGE,
                           events.BEFORE_DELETE)

    def _get_driver_by_project(self, context, project):
        # Check if the current project id has a matching driver
        # Currently only NSX-V is supported
        if self._core_plugin.is_tvd_plugin():
            plugin_type = self._core_plugin.get_plugin_type_from_project(
                context, project)
        else:
            plugin_type = self._core_plugin.plugin_type()

        if not self.drivers.get(plugin_type):
            msg = (_("Project %(project)s with plugin %(plugin)s has no "
                     "support for dynamic routing") % {
                'project': project,
                'plugin': plugin_type})
            raise n_exc.InvalidInput(error_message=msg)

        return self.drivers[plugin_type]

    def _get_driver_by_speaker(self, context, bgp_speaker_id):
        try:
            speaker = self.get_bgp_speaker(context, bgp_speaker_id)
        except Exception:
            msg = _("BGP speaker %s could not be found") % bgp_speaker_id
            raise n_exc.BadRequest(resource=bgp_ext.BGP_SPEAKER_RESOURCE_NAME,
                                   msg=msg)
        return self._get_driver_by_project(context, speaker['tenant_id'])

    def create_bgp_speaker(self, context, bgp_speaker):
        driver = self._get_driver_by_project(
            context, bgp_speaker['bgp_speaker']['tenant_id'])
        driver.create_bgp_speaker(context, bgp_speaker)
        return super(NSXBgpPlugin, self).create_bgp_speaker(context,
                                                            bgp_speaker)

    def update_bgp_speaker(self, context, bgp_speaker_id, bgp_speaker):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            driver.update_bgp_speaker(context, bgp_speaker_id, bgp_speaker)
            # TBD(roeyc): rolling back changes on edges base class call failed.
            return super(NSXBgpPlugin, self).update_bgp_speaker(
                context, bgp_speaker_id, bgp_speaker)

    def delete_bgp_speaker(self, context, bgp_speaker_id):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            driver.delete_bgp_speaker(context, bgp_speaker_id)
            super(NSXBgpPlugin, self).delete_bgp_speaker(context,
                                                         bgp_speaker_id)

    def _add_esg_peer_info(self, context, peer):
        # TODO(asarfaty): only if nsxv driver, or do it in the driver itself
        binding = nsxv_db.get_nsxv_bgp_peer_edge_binding(context.session,
                                                         peer['id'])
        if binding:
            peer['esg_id'] = binding['edge_id']

    def get_bgp_peer(self, context, bgp_peer_id, fields=None):
        peer = super(NSXBgpPlugin, self).get_bgp_peer(context,
                                                      bgp_peer_id, fields)
        if not fields or 'esg_id' in fields:
            self._add_esg_peer_info(context, peer)
        return peer

    def get_bgp_peers_by_bgp_speaker(self, context,
                                     bgp_speaker_id, fields=None):
        ret = super(NSXBgpPlugin, self).get_bgp_peers_by_bgp_speaker(
            context, bgp_speaker_id, fields=fields)
        if fields is None or 'esg_id' in fields:
            for peer in ret:
                self._add_esg_peer_info(context, peer)
        return ret

    def _get_driver_by_peer(self, context, bgp_peer_id):
        try:
            peer = self.get_bgp_peer(context, bgp_peer_id)
        except Exception:
            raise bgp_ext.BgpPeerNotFound(id=bgp_peer_id)
        return self._get_driver_by_project(context, peer['tenant_id'])

    def create_bgp_peer(self, context, bgp_peer):
        driver = self._get_driver_by_project(
            context, bgp_peer['bgp_peer']['tenant_id'])
        driver.create_bgp_peer(context, bgp_peer)
        peer = super(NSXBgpPlugin, self).create_bgp_peer(context, bgp_peer)
        # TODO(asarfaty): only if nsxv driver, or do it in the driver itself
        esg_id = bgp_peer['bgp_peer'].get('esg_id')
        if esg_id:
            nsxv_db.add_nsxv_bgp_peer_edge_binding(context.session, peer['id'],
                                                   esg_id)
            peer['esg_id'] = esg_id
        return peer

    def update_bgp_peer(self, context, bgp_peer_id, bgp_peer):
        driver = self._get_driver_by_peer(context, bgp_peer_id)
        super(NSXBgpPlugin, self).update_bgp_peer(context,
                                                  bgp_peer_id, bgp_peer)
        driver.update_bgp_peer(context, bgp_peer_id, bgp_peer)
        return self.get_bgp_peer(context, bgp_peer_id)

    def delete_bgp_peer(self, context, bgp_peer_id):
        driver = self._get_driver_by_peer(context, bgp_peer_id)
        bgp_peer_info = {'bgp_peer_id': bgp_peer_id}
        bgp_speaker_ids = driver._get_bgp_speakers_by_bgp_peer(
            context, bgp_peer_id)
        for speaker_id in bgp_speaker_ids:
            try:
                self.remove_bgp_peer(context, speaker_id, bgp_peer_info)
            except bgp_ext.BgpSpeakerPeerNotAssociated:
                LOG.debug("Couldn't find bgp speaker %s peer binding while "
                          "deleting bgp peer %s", speaker_id, bgp_peer_id)
        super(NSXBgpPlugin, self).delete_bgp_peer(context, bgp_peer_id)

    def add_bgp_peer(self, context, bgp_speaker_id, bgp_peer_info):
        # speaker & peer must belong to the same driver
        if not bgp_peer_info.get('bgp_peer_id'):
            msg = _("bgp_peer_id must be specified")
            raise n_exc.BadRequest(resource='bgp-peer', msg=msg)
        peer_driver = self._get_driver_by_peer(
            context, bgp_peer_info['bgp_peer_id'])
        speaker_driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        if peer_driver != speaker_driver:
            msg = _("Peer and Speaker must belong to the same plugin")
            raise n_exc.InvalidInput(error_message=msg)
        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            speaker_driver.add_bgp_peer(context,
                                        bgp_speaker_id, bgp_peer_info)
            return super(NSXBgpPlugin, self).add_bgp_peer(context,
                                                          bgp_speaker_id,
                                                          bgp_peer_info)

    def remove_bgp_peer(self, context, bgp_speaker_id, bgp_peer_info):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            ret = super(NSXBgpPlugin, self).remove_bgp_peer(
                context, bgp_speaker_id, bgp_peer_info)
            driver.remove_bgp_peer(context, bgp_speaker_id, bgp_peer_info)
            return ret

    def _validate_network_plugin(
        self, context, network_info,
        plugin_type=projectpluginmap.NsxPlugins.NSX_V):
        """Make sure the network belongs to the NSX0-V plugin"""
        if not network_info.get('network_id'):
            msg = _("network_id must be specified")
            raise n_exc.BadRequest(resource=bgp_ext.BGP_SPEAKER_RESOURCE_NAME,
                                   msg=msg)
        net_id = network_info['network_id']
        p = self._core_plugin._get_plugin_from_net_id(context, net_id)
        if p.plugin_type() != plugin_type:
            msg = (_('Network should belong to the %s plugin as the bgp '
                     'speaker') % plugin_type)
            raise n_exc.InvalidInput(error_message=msg)

    def add_gateway_network(self, context, bgp_speaker_id, network_info):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        if self._core_plugin.is_tvd_plugin():
            # The plugin of the network and speaker must be the same
            self._validate_network_plugin(context, network_info)

        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            driver.add_gateway_network(context,
                                       bgp_speaker_id,
                                       network_info)
            return super(NSXBgpPlugin, self).add_gateway_network(
                context, bgp_speaker_id, network_info)

    def remove_gateway_network(self, context, bgp_speaker_id, network_info):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        with locking.LockManager.get_lock(str(bgp_speaker_id)):
            super(NSXBgpPlugin, self).remove_gateway_network(
                context, bgp_speaker_id, network_info)
            driver.remove_gateway_network(context,
                                          bgp_speaker_id,
                                          network_info)

    def get_advertised_routes(self, context, bgp_speaker_id):
        driver = self._get_driver_by_speaker(context, bgp_speaker_id)
        return driver.get_advertised_routes(context, bgp_speaker_id)

    def router_interface_callback(self, resource, event, trigger, **kwargs):
        if not kwargs['network_id']:
            # No GW network, hence no BGP speaker associated
            return

        context = kwargs['context'].elevated()
        router_id = kwargs['router_id']
        subnets = kwargs.get('subnets')
        network_id = kwargs['network_id']
        port = kwargs['port']

        speakers = self._bgp_speakers_for_gateway_network(context,
                                                          network_id)
        for speaker in speakers:
            speaker_id = speaker.id
            with locking.LockManager.get_lock(str(speaker_id)):
                speaker = self.get_bgp_speaker(context, speaker_id)
                driver = self._get_driver_by_project(
                    context, speaker['tenant_id'])
                if network_id not in speaker['networks']:
                    continue
                if event == events.AFTER_CREATE:
                    driver.advertise_subnet(context, speaker_id,
                                            router_id, subnets[0])
                if event == events.AFTER_DELETE:
                    subnet_id = port['fixed_ips'][0]['subnet_id']
                    driver.withdraw_subnet(context, speaker_id,
                                           router_id, subnet_id)

    def router_gateway_callback(self, resource, event, trigger, **kwargs):
        context = kwargs.get('context') or n_context.get_admin_context()
        context = context.elevated()
        router_id = kwargs['router_id']
        network_id = kwargs['network_id']
        speakers = self._bgp_speakers_for_gateway_network(context, network_id)

        for speaker in speakers:
            speaker_id = speaker.id
            driver = self._get_driver_by_project(
                context, speaker['tenant_id'])
            with locking.LockManager.get_lock(str(speaker_id)):
                speaker = self.get_bgp_speaker(context, speaker_id)
                if network_id not in speaker['networks']:
                    continue
                if event == events.AFTER_DELETE:
                    gw_ips = kwargs['gateway_ips']
                    driver.disable_bgp_on_router(context,
                                                 speaker,
                                                 router_id,
                                                 gw_ips[0])
                if event == events.AFTER_UPDATE:
                    updated_port = kwargs['updated_port']
                    router = kwargs['router']
                    driver.process_router_gw_port_update(
                        context, speaker, router, updated_port)

    def _before_service_edge_delete_callback(self, resource, event,
                                             trigger, **kwargs):
        context = kwargs['context'].elevated()
        router = kwargs['router']
        ext_net_id = router.gw_port and router.gw_port['network_id']
        gw_ip = router.gw_port and router.gw_port['fixed_ips'][0]['ip_address']
        edge_id = kwargs.get('edge_id')
        speakers = self._bgp_speakers_for_gateway_network(context, ext_net_id)
        for speaker in speakers:
            driver = self._get_driver_by_project(
                context, speaker['tenant_id'])
            with locking.LockManager.get_lock(speaker.id):
                speaker = self.get_bgp_speaker(context, speaker.id)
                if ext_net_id not in speaker['networks']:
                    continue
                driver.disable_bgp_on_router(context, speaker,
                                             router['id'],
                                             gw_ip, edge_id)

    def _after_service_edge_create_callback(self, resource, event,
                                            trigger, **kwargs):
        context = kwargs['context'].elevated()
        router = kwargs['router']
        ext_net_id = router.gw_port and router.gw_port['network_id']
        speakers = self._bgp_speakers_for_gateway_network(context, ext_net_id)
        for speaker in speakers:
            driver = self._get_driver_by_project(
                context, speaker['tenant_id'])
            with locking.LockManager.get_lock(speaker.id):
                speaker = self.get_bgp_speaker(context, speaker.id)
                if ext_net_id not in speaker['networks']:
                    continue
                driver.enable_bgp_on_router(context, speaker, router['id'])


class NSXvBgpPlugin(NSXBgpPlugin):
    """Defined for backwards compatibility only"""
    pass
