# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2012 Nicira Networks, Inc.  All rights reserved.
#
# Copyright (c) 2014, Oracle and/or its affiliates. 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.
#
# @author: Dan Wendlandt, Nicira, Inc
# @author: Girish Moodalbail, Oracle, Inc.
#

"""
Based off generic l3_agent (quantum/agent/l3_agent) code
"""

import sqlalchemy as sa

from quantum.api.v2 import attributes
from quantum.common import constants as l3_constants
from quantum.common import exceptions as q_exc
from quantum.db import l3_db
from quantum.extensions import l3
from quantum.openstack.common import log as logging
from quantum.openstack.common import uuidutils
from quantum.plugins.evs.db import api as evs_db


LOG = logging.getLogger(__name__)

DEVICE_OWNER_ROUTER_INTF = l3_constants.DEVICE_OWNER_ROUTER_INTF
DEVICE_OWNER_ROUTER_GW = l3_constants.DEVICE_OWNER_ROUTER_GW
DEVICE_OWNER_FLOATINGIP = l3_constants.DEVICE_OWNER_FLOATINGIP


class Router(evs_db.EVS_DB_BASE):
    """Represents a v2 quantum router."""

    id = sa.Column(sa.String(36), primary_key=True,
                   default=uuidutils.generate_uuid)
    name = sa.Column(sa.String(255))
    status = sa.Column(sa.String(16))
    admin_state_up = sa.Column(sa.Boolean)
    tenant_id = sa.Column(sa.String(255))
    gw_port_id = sa.Column(sa.String(36))
    gw_port_network_id = sa.Column(sa.String(36))


class FloatingIP(evs_db.EVS_DB_BASE):
    """Represents a floating IP, which may or many not be
       allocated to a tenant, and may or may not be associated with
       an internal port/ip address/router."""

    id = sa.Column(sa.String(36), primary_key=True,
                   default=uuidutils.generate_uuid)
    floating_ip_address = sa.Column(sa.String(64), nullable=False)
    floating_network_id = sa.Column(sa.String(36), nullable=False)
    floating_port_id = sa.Column(sa.String(36), nullable=False)
    fixed_port_id = sa.Column(sa.String(36))
    fixed_ip_address = sa.Column(sa.String(64))
    router_id = sa.Column(sa.String(36), sa.ForeignKey('routers.id'))
    tenant_id = sa.Column(sa.String(255))


class EVS_L3_NAT_db_mixin(l3_db.L3_NAT_db_mixin):
    """Mixin class to add L3/NAT router methods"""

    Router = Router
    FloatingIP = FloatingIP

    def _make_router_dict(self, router, fields=None):
        res = {'id': router['id'],
               'name': router['name'],
               'tenant_id': router['tenant_id'],
               'admin_state_up': router['admin_state_up'],
               'status': router['status'],
               'external_gateway_info': None}
        if router['gw_port_id']:
            nw_id = router['gw_port_network_id']
            res['external_gateway_info'] = {'network_id': nw_id}
        return self._fields(res, fields)

    def create_router(self, context, router):
        return super(EVS_L3_NAT_db_mixin, self).\
            create_router(evs_db.get_evs_context(context), router)

    def update_router(self, context, id, router):
        return super(EVS_L3_NAT_db_mixin, self).\
            update_router(evs_db.get_evs_context(context), id, router)

    def _update_router_gw_info(self, context, router_id, info):
        """This method overrides the base class method and it's contents
        are exactly same as the base class method except that the Router
        DB columns are different for EVS and OVS"""

        router = self._get_router(context, router_id)
        gw_port_id = router['gw_port_id']
        gw_port_network_id = router['gw_port_network_id']

        network_id = info.get('network_id', None) if info else None
        if network_id:
            self._get_network(context, network_id)
            if not self._network_is_external(context, network_id):
                msg = _("Network %s is not a valid external "
                        "network") % network_id
                raise q_exc.BadRequest(resource='router', msg=msg)

        # figure out if we need to delete existing port
        if gw_port_id and gw_port_network_id != network_id:
            fip_count = self.get_floatingips_count(context.elevated(),
                                                   {'router_id': [router_id]})
            if fip_count:
                raise l3.RouterExternalGatewayInUseByFloatingIp(
                    router_id=router_id, net_id=gw_port_network_id)
            with context.session.begin(subtransactions=True):
                router['gw_port_id'] = None
                router['gw_port_network_id'] = None
                context.session.add(router)
            self.delete_port(context.elevated(), gw_port_id,
                             l3_port_check=False)

        if network_id is not None and (gw_port_id is None or
                                       gw_port_network_id != network_id):
            subnets = self._get_subnets_by_network(context,
                                                   network_id)
            for subnet in subnets:
                self._check_for_dup_router_subnet(context, router_id,
                                                  network_id, subnet['id'],
                                                  subnet['cidr'])

            # Port has no 'tenant-id', as it is hidden from user
            gw_port = self.create_port(context.elevated(), {
                'port':
                {'tenant_id': '',  # intentionally not set
                 'network_id': network_id,
                 'mac_address': attributes.ATTR_NOT_SPECIFIED,
                 'fixed_ips': attributes.ATTR_NOT_SPECIFIED,
                 'device_id': router_id,
                 'device_owner': DEVICE_OWNER_ROUTER_GW,
                 'admin_state_up': True,
                 'name': ''}})

            if not len(gw_port['fixed_ips']):
                self.delete_port(context.elevated(), gw_port['id'],
                                 l3_port_check=False)
                msg = (_('No IPs available for external network %s') %
                       network_id)
                raise q_exc.BadRequest(resource='router', msg=msg)

            with context.session.begin(subtransactions=True):
                router['gw_port_id'] = gw_port['id']
                router['gw_port_network_id'] = gw_port['network_id']
                context.session.add(router)

    def delete_router(self, context, id):
        super(EVS_L3_NAT_db_mixin, self).\
            delete_router(evs_db.get_evs_context(context), id)

    def get_router(self, context, id, fields=None):
        return super(EVS_L3_NAT_db_mixin, self).\
            get_router(evs_db.get_evs_context(context), id, fields)

    def get_routers(self, context, filters=None, fields=None,
                    sorts=None, limit=None, marker=None, page_reverse=False):

        query = evs_db.get_session().query(self.Router)
        if filters is not None:
            for key, value in filters.iteritems():
                column = getattr(self.Router, key, None)
                if column:
                    query = query.filter(column.in_(value))

        routers = query.all()
        retlist = []
        for router in routers:
            retlist.append(self._make_router_dict(router, fields))
        return retlist

    def get_routers_count(self, context, filters=None):
        return len(self.get_routers(context, filters))

    def add_router_interface(self, context, router_id, interface_info):
        return super(EVS_L3_NAT_db_mixin, self).\
            add_router_interface(evs_db.get_evs_context(context),
                                 router_id, interface_info)

    def remove_router_interface(self, context, router_id, interface_info):
        super(EVS_L3_NAT_db_mixin, self).\
            remove_router_interface(evs_db.get_evs_context(context),
                                    router_id, interface_info)

    def create_floatingip(self, context, floatingip):
        return super(EVS_L3_NAT_db_mixin, self).\
            create_floatingip(evs_db.get_evs_context(context), floatingip)

    def update_floatingip(self, context, id, floatingip):
        return super(EVS_L3_NAT_db_mixin, self).\
            update_floatingip(evs_db.get_evs_context(context), id, floatingip)

    def delete_floatingip(self, context, id):
        super(EVS_L3_NAT_db_mixin, self).\
            delete_floatingip(evs_db.get_evs_context(context), id)

    def get_floatingip(self, context, id, fields=None):
        return super(EVS_L3_NAT_db_mixin, self).\
            get_floatingip(evs_db.get_evs_context(context), id, fields)

    def get_floatingips(self, context, filters=None, fields=None,
                        sorts=None, limit=None, marker=None,
                        page_reverse=False):

        query = evs_db.get_session().query(self.FloatingIP)
        if filters:
            for key, value in filters.iteritems():
                column = getattr(self.FloatingIP, key, None)
                if column:
                    query = query.filter(column.in_(value))

        floatingips = query.all()
        retlist = []
        for floatingip in floatingips:
            retlist.append(self._make_floatingip_dict(floatingip, fields))
        return retlist

    def get_floatingips_count(self, context, filters=None):
        return len(self.get_floatingips(context, filters))

    def prevent_l3_port_deletion(self, context, port_id):
        """ Checks to make sure a port is allowed to be deleted, raising
        an exception if this is not the case.  This should be called by
        any plugin when the API requests the deletion of a port, since
        some ports for L3 are not intended to be deleted directly via a
        DELETE to /ports, but rather via other API calls that perform the
        proper deletion checks.
        """
        port = self.get_port(context, port_id)
        if port['device_owner'] in [DEVICE_OWNER_ROUTER_INTF,
                                    DEVICE_OWNER_ROUTER_GW,
                                    DEVICE_OWNER_FLOATINGIP]:
            raise l3.L3PortInUse(port_id=port_id,
                                 device_owner=port['device_owner'])

    def disassociate_floatingips(self, context, port_id):
        super(EVS_L3_NAT_db_mixin, self).\
            disassociate_floatingips(evs_db.get_evs_context(context), port_id)

    def _network_is_external(self, context, net_id):
        try:
            evs = self.get_network(context, net_id)
            return evs[l3.EXTERNAL]
        except:
            return False

    def get_sync_data(self, context, router_ids=None, active=None):
        return super(EVS_L3_NAT_db_mixin, self).\
            get_sync_data(evs_db.get_evs_context(context), router_ids, active)

    def get_external_network_id(self, context):
        return super(EVS_L3_NAT_db_mixin, self).\
            get_external_network_id(evs_db.get_evs_context(context))

    def _get_tenant_id_for_create(self, context, resource):
        if context.is_admin and 'tenant_id' in resource:
            tenant_id = resource['tenant_id']
        elif ('tenant_id' in resource and
              resource['tenant_id'] != context.tenant_id):
            reason = _('Cannot create resource for another tenant')
            raise q_exc.AdminRequired(reason=reason)
        else:
            tenant_id = context.tenant_id
        return tenant_id

    def _get_by_id(self, context, model, id):
        return context.session.query(model).\
            filter(model.id == id).one()

    def _get_network(self, context, network_id):
        return self.get_network(context, network_id)

    def _get_subnet(self, context, subnet_id):
        return self.get_subnet(context, subnet_id)

    def _get_port(self, context, port_id):
        return self.get_port(context, port_id)

    def _delete_port(self, context, port_id):
        return self.delete_port(context, port_id)

    def _get_subnets_by_network(self, context, network_id):
        return self.get_subnets(context, filters={'network_id': network_id})

    def allow_l3_port_deletion(self, context, port_id):
        """ If an L3 agent is using this port, then we need to send
        a notification to L3 agent to release the port before we can
        delete the port"""
        pass