#
# Copyright (c) 2014, Arista Networks, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#   Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
#
#   Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
#
#   Neither the name of Arista Networks nor the names of its
#   contributors may be used to endorse or promote products derived from
#   this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ARISTA NETWORKS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
"""Module for working with spanning-tree in EOS

This module provides an API for working with spanning-tree configuration
in EOS.  This includes both global spanning-tree configuration as well as
interface config.

Global Parameters:
    mode (string): The spanning-tree operational mode.  Accepted values
        for this version are 'mstp' or 'none'.  This configuration
        parameter is not defaultable

    interfaces (StpInterfaces): The collection of STP enabled interfaces.

Interface Parameters:
    name (string): The name of the interface the STP configuration is in
        reference to.  The interface name is the full interface identifier

    portfast (string): The portfast configuration value for the interface.
        Accepted values are 'edge', 'network', or 'disabled'

    bpduguard (boolean): True if the BPDU Guard feature is enabled on the
        interface or False if it is disabled
"""

import re

from pyeapi.api import Entity, EntityCollection


class Stp(Entity):
    """The Stp class implements global configuration for spanning-tree

    The spanning-tree protocol provides both global and interface
    configuration options.  This class is the top-level class that provides
    access to all spanning-tree configuration options supported.

    Example:
        The below example demonstrates how to use the STP class to work
        with both global configuration and interface configuration.

        >>> import pyeapi.resources.stp
        >>> stp = pyeapi.resources.stp.instance(node)
        >>> stp.set_mode('mstp')
        True
        >>> stp.interfaces.set_bpduguard('Ethernet1', True)
        True

    Attributes:
        interfaces (StpInterfaces): An instance for configuration spanning-tree
            configuration interfaces

        instances (StpInstances): An instance object for working with
            spanning-tree global instances

    """

    def __init__(self, *args, **kwargs):
        super(Stp, self).__init__(*args, **kwargs)
        self._interfaces = None
        self._instances = None

    def get(self):
        """Returns the spanning-tree configuration as a dict object

        The dictionary object represents the entire spanning-tree
        configuration derived from the nodes running config.  This
        includes both globally configuration attributes as well as
        interfaces and instances.  See the StpInterfaces and StpInstances
        classes for the key/value pair definitions.

        Note:
            See the individual classes for detailed message structures

        Returns:
            A Python dictionary object of key/value pairs the represent
            the entire supported spanning-tree configuration::

                {
                    "mode": [mstp, none],
                    "interfaces": {...},
                    "instances": {...}
                }
        """
        return dict(interfaces=self.interfaces.getall(),
                    instances=self.instances.getall())

    @property
    def interfaces(self):
        if self._interfaces is not None:
            return self._interfaces
        self._interfaces = StpInterfaces(self.node)
        return self._interfaces

    @property
    def instances(self):
        if self._instances is not None:
            return self._instances
        self._instances = StpInstances(self.node)
        return self._instances

    def set_mode(self, value=None, default=False, disable=False):
        """Configures the global spanning-tree mode

        Note:
            This configuration parameter is not defaultable

        Args:
            value (string): The value to configure the global spanning-tree
                mode of operation.  Valid values include 'mstp', 'none'
            default (bool): Set the global spanning-tree mode to default.
            disable (bool): Negate the global spanning-tree mode.

        Returns:
            True if the configuration operation succeeds otherwise False

        Raises:
            ValueError if the value is not in the accepted range
        """
        if not default and not disable:
            if value not in ['mstp', 'none']:
                raise ValueError("Specified value must be one of "
                                 "'mstp', 'none'")
        cmds = self.command_builder('spanning-tree mode', value=value,
                                    default=default, disable=disable)
        return self.configure(cmds)


class StpInstances(EntityCollection):
    """Provides a configuration resource for spanning-tree instances

    This class provides an API for working with spanning-tree instances from
    the global configuration.  Spanning tree instances work with MST
    configuration
    """

    def getall(self):
        # TODO: (privateip, 20150106) stubbed out, needs implementation
        return dict()


class StpInterfaces(EntityCollection):
    """Provides a configuration resource for spanning-tree interfaces

    This class provides an API for working with spanning-tree interface
    configurations.  It provides access to managing specific interface
    spanning-tree configuration options.  Note that spanning-tree interfaces
    cannot be created or deleted.
    """

    def get(self, name):
        """Returns the specified interfaces STP configuration resource

        The STP interface resource contains the following

            * name (str): The interface name
            * portfast (bool): The spanning-tree portfast admin state
            * bpduguard (bool): The spanning-tree bpduguard admin state
            * portfast_type (str): The spanning-tree portfast <type> value.
                Valid values include "edge", "network", "normal"

        Args:
            name (string): The interface identifier to retrieve the config
                for.  Note: Spanning-tree interfaces are only supported on
                Ethernet and Port-Channel interfaces

        Returns:
            dict: A resource dict object that represents the interface
                configuration.

            None: If the specified interace is not a STP port
        """
        if not isvalidinterface(name):
            return None

        config = self.get_block(r'^interface\s%s$' % name)
        resp = dict()
        resp.update(self._parse_bpduguard(config))
        resp.update(self._parse_portfast(config))
        resp.update(self._parse_portfast_type(config))
        return resp

    def _parse_bpduguard(self, config):
        value = 'spanning-tree bpduguard enable' in config
        return dict(bpduguard=value)

    def _parse_portfast(self, config):
        value = 'no spanning-tree portfast' not in config
        return dict(portfast=value)

    def _parse_portfast_type(self, config):
        if 'spanning-tree portfast network' in config:
            value = 'network'
        elif 'no spanning-tree portfast' in config:
            value = 'normal'
        else:
            value = 'edge'
        return dict(portfast_type=value)

    def getall(self):
        """Returns the collection of STP interfaces

        This method will return all of the configured spanning-tree
        interfaces from the current nodes configuration.

        Returns:
            A Python dictionary object that represents all configured
                spanning-tree interfaces indexed by interface name.
        """
        interfaces_re = re.compile(r'(?<=^interface\s)(.+)$', re.M)

        response = dict()
        for name in interfaces_re.findall(self.config):
            if name[0:2] in ['Et', 'Po']:
                interface = self.get(name)
                if interface:
                    response[name] = interface
        return response

    def configure_interface(self, name, cmds):
        if not isvalidinterface(name):
            raise ValueError('invalid interface value specified')
        return super(StpInterfaces, self).configure_interface(name, cmds)

    def set_portfast_type(self, name, value='normal'):
        """Configures the portfast value for the specified interface

        Args:
            name (string): The interface identifier to configure.  The name
                must be the full interface name (eg Ethernet1, not Et1).

            value (string): The value to configure the portfast setting to.
                Valid values include "edge", "network", "normal".  The
                default value is "normal"

        Returns:
            True if the command succeeds, otherwise False

        Raises:
            ValueError: Raised if an invalid interface name or value is
                specified

        """
        if value not in ['network', 'edge', 'normal', None]:
            raise ValueError('invalid portfast type value specified')

        cmds = ['spanning-tree portfast %s' % value]
        if value == 'edge':
            cmds.append('spanning-tree portfast auto')
        return self.configure_interface(name, cmds)

    def set_portfast(self, name, value=None, default=False, disable=False):
        """Configures the portfast value for the specified interface

        Args:
            name (string): The interface identifier to configure.  The name
                must be the full interface name (eg Ethernet1, not Et1)

            value (bool): True if portfast is enabled otherwise False

            default (bool): Configures the portfast parameter to its default
                value using the EOS CLI default config command

            disable (bool): Negates the portfast parameter using the EOS
                CLI no config command

        Returns:
            True if the command succeeds, otherwise False

        Raises:
            ValueError: Rasied if an invalid interface name is specified

            TypeError: Raised if the value keyword argument does not evaluate
                to a valid boolean

        """
        if value is False:
            disable = True
        string = 'spanning-tree portfast'
        cmds = self.command_builder(string, value=value, default=default,
                                    disable=disable)
        return self.configure_interface(name, cmds)

    def set_bpduguard(self, name, value=False, default=False, disable=False):
        """Configures the bpduguard value for the specified interface

        Args:
            name (string): The interface identifier to configure.  The name
                must be the full interface name (eg Ethernet1, not Et1)

            value (bool): True if bpduguard is enabled otherwise False

            default (bool): Configures the bpduguard parameter to its default
                value using the EOS CLI default config command

            disable (bool): Negates the bpduguard parameter using the EOS
                CLI no config command

        Returns:
            True if the command succeeds, otherwise False

        Raises:
            ValueError: Rasied if an invalid interface name is specified

            TypeError: Raised if the value keyword argument does not evaluate
                to a valid boolean

        """
        value = 'enable' if value else 'disable'
        string = 'spanning-tree bpduguard'
        cmds = self.command_builder(string, value=value, default=default,
                                    disable=disable)
        return self.configure_interface(name, cmds)


def isvalidinterface(value):
    """Checks value to see if it could be a spanning-tree interface

    This function will check the value and return a boolean whether or not
    the interface could be a spanning-tree interface

    Note:
        This function only checks *if* the interface could be a spanning-tree
            interface but does not check if it *is* configured as a
            spanning-tree interface

    Args:
        value (string): The interface name to validate

    Returns:
        True if it could be a spanning-tree interface, otherwise False
    """
    return value[0:2] in ['Et', 'Po']


def instance(api):
    return Stp(api)