
# Copyright 2017-present Open Networking Foundation
#
# 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.


import os
import sys

from synchronizers.base.syncstep import SyncStep
from synchronizers.vnodlocal.pseudowireproviders.providerfactory import ProviderFactory
from services.vnodlocal.models import *

from xos.logger import Logger, logging

# vnod local will be in steps/..
parentdir = os.path.join(os.path.dirname(__file__), "..")
sys.path.insert(0, parentdir)

logger = Logger(level=logging.INFO)


class SyncVnodLocalPseudowireConnectorServiceSystem(SyncStep):
    provides = [VnodLocalPseudowireConnectorService]
    observes = VnodLocalPseudowireConnectorService
    requested_interval = 0
    initialized = False

    def __init__(self, **args):
        SyncStep.__init__(self, **args)

    def fetch_pending(self, deletion=False):
        logger.info("VnodLocalPseudowireConnector fetch pending called")

        # Some comments to replace as we write the code

        #    The AdministrativeState state machine:
        #
        #
        #                     Disabled---------DeactivationRequested
        #                         \                      |
        #               ActivationRequested              |
        #               /      /        \                |
        #              /      /          \               |
        #     ActivationFailed         Enabled -----------
        #
        #

        #  The  OperationalState state machine
        #
        #           active
        #              |
        #          inactive

        objs = []


        # The whole thing needs to be conditional on the VnodLocalSystem existing and being 'enabled'
        # This is the 'kill switch' in the system that is the first thing to check
        vnodlocalsystem = self.get_vnodlocal_system()
        if not vnodlocalsystem:
            logger.debug("No VnodLocal System Configured, skipping sync")
            return objs

        # Check to make sure the Metro Network System is enabled
        if vnodlocalsystem.administrativeState == 'disabled':
            # Nothing to do
            logger.debug("VnodLocal System configured - state is Disabled, skipping sync")
            return objs


        # Handle call when deletion is False
        if deletion is False:

            # Check for admin status 'ActivationRequested'
            activationreqs = VnodLocalPseudowireConnectorService.objects.filter(administrativeState='activationrequested')
            for activationreq in activationreqs:
                # Handle the case where we don't yet have a VnodLocalSerive
                if activationreq.vnodlocal is None:
                    # Create VnodLocalService
                    # We save the changes right here in this case to avoid having to to 'pre-save' semnatics
                    # to cover the foreign key
                    vnodlocalservice = VnodLocalService()
                    vnodlocalservice.servicehandle = activationreq.servicehandle
                    vnodlocalservice.administrativeState = 'configurationrequested'
                    vnodlocalservice.save()
                    activationreq.vnodlocal = vnodlocalservice
                    activationreq.save()
                elif activationreq.vnodlocal.administrativeState == 'configured':
                    # Once the underlying VnodLocal is configured then activated it
                    vnodlocalservice = activationreq.vnodlocal
                    # Call our underlying provider to connect the pseudo wire
                    self.activate_pseudowire(activationreq, vnodlocalsystem)
                    activationreq.administrativeState = 'enabled'
                    activationreq.operstate = 'active'
                    objs.append(activationreq)
                    vnodlocalservice.administrativeState = 'activationrequested'
                    vnodlocalservice.operstate = 'activereported'
                    objs.append(vnodlocalservice)


            # Check for admin status 'DeactivationRequested'
            deactivationreqs = VnodLocalPseudowireConnectorService.objects.filter(administrativeState='deactivationrequested')
            for deactivationreq in deactivationreqs:
                # Call the XOS Interface to de-actiavte the spoke
                logger.debug("Attempting to de-activate VnodLocalService servicehandle: %s" % deactivationreq.servicehandle)
                # De-activate the underlying service
                vnodlocalservice = deactivationreq.vnodlocal
                # Call our underlying provider to connect the pseudo wire
                self.deactivate_pseudowire(deactivationreq)
                deactivationreq.administrativeState = 'disabled'
                deactivationreq.operstate = 'inactive'
                objs.append(deactivationreq)
                vnodlocalservice.administrativeState = 'deactivationrequested'
                objs.append(vnodlocalservice)


        elif deletion:
            # Apply Deletion Semantics:
            logger.debug("Applying Deletion Semanctics")
            # TODO: Figure out the odd scenario of Service deletion
            deletedobjs = VnodLocalPseudowireConnectorService.deleted_objects.all()

            # Delete the underlying VnodLocalService objects
            for deletedobj in deletedobjs:
                # Set the VnodLocal to Deleted - its Synchronizer will take care of deletion
                vnodlocalobj = deletedobj.vnodlocal
                vnodlocalobj.deleted = True
                vnodlocalobj.save()
                # Delete the underlying pseudowire
                self.delete_pseudowire(deletedobj)
                # Finally - add the Service for deletion
                objs.append(deletedobj)

        # Finally just return the set of changed objects
        return objs


    def sync_record(self, o):

        # Simply save the record to the DB - both updates and adds are handled the same way
        o.save()


    def delete_record(self, o):
        # Overriden to customize our behaviour - the core sync step for will remove the record directly
        # We just log and return
        logger.debug("deleting Object %s" % str(o), extra=o.tologdict())

    def get_vnodlocal_system(self):
        # We only expect to have one of these objects in the system in the curent design
        # So get the first element from the query
        vnodlocalsystems = VnodLocalSystem.objects.all()
        if not vnodlocalsystems:
            return None

        return vnodlocalsystems[0]

    def activate_pseudowire(self, o, vnodlocalsystem):
        # Call the underlying pseudowire provicers and call
        logger.debug("activating pseudowire %s" % o.servicehandle)

        pseudowireprovier = ProviderFactory.getprovider()

        if pseudowireprovier is not None:
            # Pass it the two ports - the internal port configured on the Pseudowire and the NNI port from
            # the VnodLocal
            if o.pseudowirehandle == '':
                o.pseudowirehandle = pseudowireprovier.create(o.internalport, o.vnodlocal.portid, o.vnodlocal.vlanid, vnodlocalsystem)

            # handle already exists - just connect it
            pseudowireprovier.connect(o.pseudowirehandle)
        else:
            # No Provider configured - lets put a handle that reflects thsi
            o.pseudowirehandle = 'No Pseudowire Provider configured'


    def deactivate_pseudowire(self, o):
        # Call the underlying pseudowire provicers and call
        logger.debug("deactivating pseudowire %s" % o.servicehandle)

        pseudowireprovier = ProviderFactory.getprovider()

        if pseudowireprovier is not None:
            # Pass it the handle
            pseudowireprovier.disconnect(o.pseudowirehandle)


    def delete_pseudowire(self, o):
        # Call the underlying pseudowire provicers and call
        logger.debug("deleting pseudowire %s" % o.servicehandle)

        pseudowireprovier = ProviderFactory.getprovider()

        if pseudowireprovier is not None:
            # Pass it the handle
            if o.pseudowirehandle != '':
                pseudowireprovier.delete(o.pseudowirehandle)

        # Either way blank out the handle name
        o.pseudowirehandle = ''