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

# Copyright (C) 2013 Midokura PTE LTD
# 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: Ryu Ishimoto, Midokura Japan KK

import mock
import uuid


def get_bridge_mock(id=None, **kwargs):
    if id is None:
        id = str(uuid.uuid4())

    bridge = mock.Mock()
    bridge.get_id.return_value = id
    bridge.get_tenant_id.return_value = kwargs.get("tenant_id", "test-tenant")
    bridge.get_name.return_value = kwargs.get("name", "net")
    bridge.get_ports.return_value = []
    bridge.get_peer_ports.return_value = []
    bridge.get_admin_state_up.return_value = kwargs.get("admin_state_up", True)
    return bridge


def get_bridge_port_mock(id=None, bridge_id=None, **kwargs):
    if id is None:
        id = str(uuid.uuid4())
    if bridge_id is None:
        bridge_id = str(uuid.uuid4())

    port = mock.Mock()
    port.get_id.return_value = id
    port.get_bridge_id.return_value = bridge_id
    port.get_admin_state_up.return_value = kwargs.get("admin_state_up", True)
    port.get_type.return_value = "Bridge"
    port.create.return_value = port
    return port


def get_chain_mock(id=None, tenant_id='test-tenant', name='chain',
                   rules=None):
    if id is None:
        id = str(uuid.uuid4())

    if rules is None:
        rules = []

    chain = mock.Mock()
    chain.get_id.return_value = id
    chain.get_tenant_id.return_value = tenant_id
    chain.get_name.return_value = name
    chain.get_rules.return_value = rules
    return chain


def get_port_group_mock(id=None, tenant_id='test-tenant', name='pg'):
    if id is None:
        id = str(uuid.uuid4())

    port_group = mock.Mock()
    port_group.get_id.return_value = id
    port_group.get_tenant_id.return_value = tenant_id
    port_group.get_name.return_value = name
    return port_group


def get_router_mock(id=None, **kwargs):
    if id is None:
        id = str(uuid.uuid4())

    router = mock.Mock()
    router.get_id.return_value = id
    router.get_tenant_id.return_value = kwargs.get("tenant_id", "test-tenant")
    router.get_name.return_value = kwargs.get("name", "router")
    router.get_ports.return_value = []
    router.get_peer_ports.return_value = []
    router.get_routes.return_value = []
    router.get_admin_state_up.return_value = kwargs.get("admin_state_up", True)
    return router


def get_rule_mock(id=None, chain_id=None, properties=None):
    if id is None:
        id = str(uuid.uuid4())

    if chain_id is None:
        chain_id = str(uuid.uuid4())

    if properties is None:
        properties = {}

    rule = mock.Mock()
    rule.get_id.return_value = id
    rule.get_chain_id.return_value = chain_id
    rule.get_properties.return_value = properties
    return rule


def get_subnet_mock(bridge_id=None, gateway_ip='10.0.0.1',
                    subnet_prefix='10.0.0.0', subnet_len=int(24)):
    if bridge_id is None:
        bridge_id = str(uuid.uuid4())

    subnet = mock.Mock()
    subnet.get_id.return_value = subnet_prefix + '/' + str(subnet_len)
    subnet.get_bridge_id.return_value = bridge_id
    subnet.get_default_gateway.return_value = gateway_ip
    subnet.get_subnet_prefix.return_value = subnet_prefix
    subnet.get_subnet_length.return_value = subnet_len
    return subnet


class MidonetLibMockConfig():

    def __init__(self, inst):
        self.inst = inst

    def _create_bridge(self, **kwargs):
        return get_bridge_mock(**kwargs)

    def _create_router(self, **kwargs):
        return get_router_mock(**kwargs)

    def _create_subnet(self, bridge, gateway_ip, subnet_prefix, subnet_len):
        return get_subnet_mock(bridge.get_id(), gateway_ip=gateway_ip,
                               subnet_prefix=subnet_prefix,
                               subnet_len=subnet_len)

    def _add_bridge_port(self, bridge, **kwargs):
        return get_bridge_port_mock(bridge_id=bridge.get_id(), **kwargs)

    def _get_bridge(self, id):
        return get_bridge_mock(id=id)

    def _get_port(self, id):
        return get_bridge_port_mock(id=id)

    def _get_router(self, id):
        return get_router_mock(id=id)

    def _update_bridge(self, id, **kwargs):
        return get_bridge_mock(id=id, **kwargs)

    def setup(self):
        # Bridge methods side effects
        self.inst.create_bridge.side_effect = self._create_bridge
        self.inst.get_bridge.side_effect = self._get_bridge
        self.inst.update_bridge.side_effect = self._update_bridge

        # Subnet methods side effects
        self.inst.create_subnet.side_effect = self._create_subnet

        # Port methods side effects
        ex_bp = self.inst.add_bridge_port
        ex_bp.side_effect = self._add_bridge_port
        self.inst.get_port.side_effect = self._get_port

        # Router methods side effects
        self.inst.create_router.side_effect = self._create_router
        self.inst.get_router.side_effect = self._get_router


class MidoClientMockConfig():

    def __init__(self, inst):
        self.inst = inst
        self.chains_in = None
        self.port_groups_in = None
        self.chains_out = None
        self.rules_out = None
        self.port_groups_out = None

    def _get_query_tenant_id(self, query):
        if query is not None and query['tenant_id']:
            tenant_id = query['tenant_id']
        else:
            tenant_id = 'test-tenant'
        return tenant_id

    def _get_bridge(self, id):
        return get_bridge_mock(id=id)

    def _get_chain(self, id, query=None):
        if not self.chains_in:
            return []

        tenant_id = self._get_query_tenant_id(query)
        for chain in self.chains_in:
            chain_id = chain['id']
            if chain_id is id:
                rule_mocks = []
                if 'rules' in chain:
                    for rule in chain['rules']:
                        rule_mocks.append(
                            get_rule_mock(id=rule['id'],
                                          chain_id=id,
                                          properties=rule['properties']))

                return get_chain_mock(id=chain_id, name=chain['name'],
                                      tenant_id=tenant_id, rules=rule_mocks)
        return None

    def _get_chains(self, query=None):
        if not self.chains_in:
            return []

        tenant_id = self._get_query_tenant_id(query)
        self.chains_out = []
        self.rules_out = []
        for chain in self.chains_in:
            chain_id = chain['id']

            rule_mocks = []
            if 'rules' in chain:
                for rule in chain['rules']:
                    rule_mocks.append(
                        get_rule_mock(id=rule['id'],
                                      chain_id=id,
                                      properties=rule['properties']))
                    self.rules_out += rule_mocks

            self.chains_out.append(get_chain_mock(id=chain_id,
                                                  name=chain['name'],
                                                  tenant_id=tenant_id,
                                                  rules=rule_mocks))
        return self.chains_out

    def _get_port_groups(self, query=None):
        if not self.port_groups_in:
            return []

        tenant_id = self._get_query_tenant_id(query)
        self.port_groups_out = []
        for port_group in self.port_groups_in:
            self.port_groups_out.append(get_port_group_mock(
                id=port_group['id'], name=port_group['name'],
                tenant_id=tenant_id))
        return self.port_groups_out

    def _get_router(self, id):
        return get_router_mock(id=id)

    def _add_bridge_port(self, bridge):
        return get_bridge_port_mock(bridge_id=bridge.get_id())

    def setup(self):
        self.inst.get_bridge.side_effect = self._get_bridge
        self.inst.get_chains.side_effect = self._get_chains
        self.inst.get_chain.side_effect = self._get_chain
        self.inst.get_port_groups.side_effect = self._get_port_groups
        self.inst.get_router.side_effect = self._get_router
        self.inst.add_bridge_port.side_effect = self._add_bridge_port