# Copyright 2020 K Sai Kiran (Tata Elxsi)
#
# 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__ = "K Sai Kiran <saikiran.k@tataelxsi.co.in>"
__date__ = "$28-Apr-2020 23:59:59$"

import asyncio
import aiohttp
import ssl
import certifi
from http import HTTPStatus
import json
import logging
import time
from uuid import uuid4


class NotificationException(Exception):
    """
    Notification Exception
    """

    def __init__(self, message: str, http_code: int = HTTPStatus.BAD_REQUEST) -> None:
        """
        Constructor of notification exception
        :param message: String text containing exception details.
        :param http_code: HTTP status code of exception.
        """
        self.http_code = http_code
        Exception.__init__(self, message)


class NotificationBase:
    response_models = None
    # Common HTTP payload header for all notifications.
    payload_header = {"Content-Type": "application/json", "Accept": "application/json"}

    def __init__(self, db) -> None:
        """
        Constructor of NotificationBase class.
        :param db: Database handler.
        """
        self.db = db
        self.logger = logging.getLogger("nbi.notifications")
        self.subscriber_collection = None

    def get_models(self) -> dict:
        """
        Returns the SOL005 model of notification class
        :param None
        :return: dict of SOL005 data model
        """
        return NotificationBase.response_models

    def get_subscribers(self, **kwargs) -> NotificationException:
        """
        Method should be implemented by all notification subclasses
        :param kwargs: any keyword arguments needed for db query.
        :return: List of subscribers
        """
        raise NotificationException(
            "Method get_subscribers() is not implemented",
            http_code=HTTPStatus.NOT_IMPLEMENTED,
        )

    @staticmethod
    def _get_basic_auth(username: str, password: str) -> tuple:
        return aiohttp.BasicAuth(username, password)

    def _decrypt_password(
        self, hashed: str, salt: str, schema_version: str = "1.1"
    ) -> str:
        return self.db.decrypt(hashed, schema_version, salt=salt)

    def get_payload(self, meta_notification: dict) -> dict:
        """
        Generates SOL005 compliant payload structure and returns them in dictionary.
        :param meta_notification: notification meta data which needs to be formatted as SOL005 compliant
        :return: A dictionary which is SOL005 compliant.
        """
        model_name = meta_notification["notificationType"]
        response_models = self.get_models()
        if not response_models or not response_models.get(model_name):
            raise NotificationException(
                "Response model {} is not defined.".format(model_name),
                HTTPStatus.NOT_IMPLEMENTED,
            )
        model_keys = response_models[model_name]
        payload = dict.fromkeys(model_keys, "N/A")
        notification_keys = set(meta_notification.keys())
        for model_key in model_keys.intersection(notification_keys):
            payload[model_key] = meta_notification[model_key]
        self.logger.debug(
            "Payload generated for subscriber: {} for {}".format(
                payload["subscriptionId"], payload["notificationType"]
            )
        )
        return payload

    async def send_notifications(
        self,
        subscribers: list,
    ):
        """
        Generate tasks for all notification for an event.
        :param subscribers: A list of subscribers who want to be notified for event.
        """
        notifications = []
        for subscriber in subscribers:
            # Notify without auth
            if not subscriber.get("authentication"):
                notifications.append(
                    {
                        "headers": self.payload_header,
                        "payload": self.get_payload(subscriber),
                        "CallbackUri": subscriber["CallbackUri"],
                    }
                )
            elif subscriber["authentication"]["authType"] == "basic":
                salt = subscriber["subscriptionId"]
                hashed_password = subscriber["authentication"]["paramsBasic"][
                    "password"
                ]
                password = self._decrypt_password(hashed_password, salt)
                auth_basic = self._get_basic_auth(
                    subscriber["authentication"]["paramsBasic"]["userName"], password
                )
                notifications.append(
                    {
                        "headers": self.payload_header,
                        "payload": self.get_payload(subscriber),
                        "auth_basic": auth_basic,
                        "CallbackUri": subscriber["CallbackUri"],
                    }
                )
            # TODO add support for AuthType OAuth and TLS after support is added in subscription.
            else:
                self.logger.debug(
                    "Subscriber {} can not be notified. {} notification auth type is not implemented".format(
                        subscriber["subscriptionId"],
                        subscriber["authentication"]["authType"],
                    )
                )

        if notifications:
            tasks = []
            ssl_context = ssl.create_default_context(cafile=certifi.where())
            conn = aiohttp.TCPConnector(ssl=ssl_context)
            async with aiohttp.ClientSession(connector=conn) as session:
                for notification in notifications:
                    tasks.append(
                        asyncio.ensure_future(
                            self.send_notification(session, notification),
                        )
                    )
                await asyncio.gather(*tasks)

    async def send_notification(
        self,
        session: aiohttp.ClientSession,
        notification: dict,
        retry_count: int = 5,
        timeout: float = 5.0,
    ):
        """
        Performs HTTP Post request to notify subscriber. In case if for any reason notification is not sent successfully
        after maximum number of reties, then notification is dropped.
        :param session: An aiohttp client session object to maintain http session.
        :param notification: A dictionary containing all necessary data to make POST request.
        :param retry_count: An integer specifying the maximum number of reties for a notification.
        :param timeout: A float representing client timeout of each HTTP request.
        """
        backoff_delay = 1
        while retry_count > 0:
            try:
                async with session.post(
                    url=notification["CallbackUri"],
                    headers=notification["headers"],
                    auth=notification.get("auth_basic", None),
                    data=json.dumps(notification["payload"]),
                    timeout=timeout,
                ) as resp:
                    # self.logger.debug("Notification response: {}".format(resp.status))
                    if resp.status == HTTPStatus.NO_CONTENT:
                        self.logger.debug(
                            "Notification sent successfully to subscriber {}".format(
                                notification["payload"]["subscriptionId"]
                            )
                        )
                    else:
                        error_text = "Erroneous response code: {}, ".format(resp.status)
                        error_text += await resp.text()
                        raise NotificationException(error_text)
                return True
            except Exception as e:
                error_text = type(e).__name__ + ": " + str(e)
                self.logger.debug(
                    "Unable to send notification to subscriber {}. Details: {}".format(
                        notification["payload"]["subscriptionId"], error_text
                    )
                )
                error_detail = {
                    "error": type(e).__name__,
                    "error_text": str(e),
                    "timestamp": time.time(),
                }
                if "error_details" in notification["payload"].keys():
                    notification["payload"]["error_details"].append(error_detail)
                else:
                    notification["payload"]["error_details"] = [error_detail]
                retry_count -= 1
                backoff_delay *= 2
                self.logger.debug(
                    "Retry Notification for subscriber: {} after backoff delay: {} seconds.".format(
                        notification["payload"]["subscriptionId"], backoff_delay
                    )
                )
                await asyncio.sleep(backoff_delay)
        # Dropping notification
        self.logger.debug(
            "Notification {} sent failed to subscriber:{}.".format(
                notification["payload"]["notificationType"],
                notification["payload"]["subscriptionId"],
            )
        )
        return False


class NsLcmNotification(NotificationBase):
    # maps kafka commands of completed operations to the original operation type
    completed_operation_map = {
        "INSTANTIATED": "INSTANTIATE",
        "SCALED": "SCALE",
        "TERMINATED": "TERMINATE",
        "UPDATED": "UPDATE",
        "HEALED": "HEAL",
    }
    # SOL005 response model for nslcm notifications
    response_models = {
        "NsLcmOperationOccurrenceNotification": {
            "id",
            "nsInstanceId",
            "nsLcmOpOccId",
            "operation",
            "notificationType",
            "subscriptionId",
            "timestamp",
            "notificationStatus",
            "operationState",
            "isAutomaticInvocation",
            "affectedVnf",
            "affectedVl",
            "affectedVnffg",
            "affectedNs",
            "affectedSap",
            "error",
            "_links",
        },
        "NsIdentifierCreationNotification": {
            "notificationType",
            "subscriptionId",
            "timestamp",
            "nsInstanceId",
            "_links",
        },
        "NsIdentifierDeletionNotification": {
            "notificationType",
            "subscriptionId",
            "timestamp",
            "nsInstanceId",
            "_links",
        },
        "NsChangeNotification": {
            "nsInstanceId",
            "nsComponentType",
            "nsComponentId",
            "lcmOpOccIdImpactngNsComponent",
            "lcmOpNameImpactingNsComponent",
            "lcmOpOccStatusImpactingNsComponent",
            "notificationType",
            "subscriptionId",
            "timeStamp",
            "error",
            "_links",
        },
    }

    def __init__(self, db) -> None:
        """
        Constructor of NsLcmNotification class.
        :param db: Database handler.
        """
        super().__init__(db)
        self.subscriber_collection = "mapped_subscriptions"

    def get_models(self) -> dict:
        """
        Returns the SOL005 model of notification class
        :param None
        :return: dict of SOL005 data model
        """
        return NsLcmNotification.response_models

    @staticmethod
    def _format_nslcm_subscribers(subscribers: list, event_details: dict) -> list:
        """
        Formats the raw event details from kakfa message and subscriber details.
        :param subscribers: A list of subscribers whom the event needs to be notified.
        :param event_details: A dict containing all meta data of event.
        :return:
        """
        notification_id = str(uuid4())
        event_timestamp = event_details["params"]["startTime"]
        resource_links = event_details["params"]["links"]
        event_operation = event_details["command"]
        for key in ["_admin", "_id", "id", "links"]:
            event_details["params"].pop(key, None)
        for subscriber in subscribers:
            subscriber["id"] = notification_id
            subscriber["timestamp"] = event_timestamp
            subscriber["_links"] = resource_links
            subscriber["subscriptionId"] = subscriber["reference"]
            subscriber["operation"] = event_operation
            del subscriber["reference"]
            del subscriber["_id"]
            subscriber.update(event_details["params"])
        return subscribers

    def get_subscribers(
        self,
        nsd_id: str,
        ns_instance_id: str,
        command: str,
        op_state: str,
        event_details: dict,
    ) -> list:
        """
        Queries database and returns list of subscribers.
        :param nsd_id: NSD id of an NS whose lifecycle has changed. (scaled, terminated. etc)
        :param ns_instance_id: NS instance id an NS whose lifecycle has changed.
        :param command: the command for event.
        :param op_state: the operation state of NS.
        :param event_details: dict containing raw data of event occured.
        :return: List of interested subscribers for occurred event.
        """
        notification_type = [
            "NsLcmOperationOccurrenceNotification",
            "NsChangeNotification",
            "NsIdentifierCreationNotification",
            "NsIdentifierDeletionNotification",
        ]
        filter_q = {
            "identifier": [nsd_id, ns_instance_id],
            "operationStates": ["ANY"],
            "operationTypes": ["ANY"],
            "notificationType": notification_type,
        }
        if op_state:
            filter_q["operationStates"].append(op_state)
        if command:
            op_type = self.completed_operation_map.get(command, command)
            filter_q["operationTypes"].append(op_type)
        # self.logger.debug("Db query is: {}".format(filter_q))
        subscribers = []
        try:
            subscribers = self.db.get_list(self.subscriber_collection, filter_q)
            subscribers = self._format_nslcm_subscribers(subscribers, event_details)
        except Exception as e:
            error_text = type(e).__name__ + ": " + str(e)
            self.logger.debug("Error getting nslcm subscribers: {}".format(error_text))
        finally:
            return subscribers


class VnfLcmNotification(NotificationBase):
    # SOL003 response model for vnflcm notifications
    response_models = {
        "VnfLcmOperationOccurrenceNotification": {
            "id",
            "notificationType",
            "subscriptionId",
            "timeStamp",
            "notificationStatus",
            "operationState",
            "vnfInstanceId",
            "operation",
            "isAutomaticInvocation",
            "vnfLcmOpOccId",
            "affectedVnfcs",
            "affectedVirtualLinks",
            "affectedExtLinkPorts",
            "affectedVirtualStorages",
            "changedInfo",
            "changedExtConnectivity",
            "modificationsTriggeredByVnfPkgChange",
            "error",
            "_links",
        },
        "VnfIdentifierCreationNotification": {
            "id",
            "notificationType",
            "subscriptionId",
            "timeStamp",
            "vnfInstanceId",
            "_links",
        },
        "VnfIdentifierDeletionNotification": {
            "id",
            "notificationType",
            "subscriptionId",
            "timeStamp",
            "vnfInstanceId",
            "_links",
        },
    }

    def __init__(self, db) -> None:
        """
        Constructor of VnfLcmNotification class.
        :param db: Database handler.
        """
        super().__init__(db)
        self.subscriber_collection = "mapped_subscriptions"

    def get_models(self) -> dict:
        """
        Returns the SOL003 model of notification class
        :param None
        :return: dict of SOL003 data model
        """
        return self.response_models

    def _format_vnflcm_subscribers(
        self, subscribers: list, event_details: dict
    ) -> list:
        """
        Formats the raw event details from kafka message and subscriber details.
        :param subscribers: A list of subscribers whom the event needs to be notified.
        :param event_details: A dict containing all meta data of event.
        :return:
        """
        notification_id = str(uuid4())
        event_timestamp = time.time()
        event_operation = event_details["command"]
        for subscriber in subscribers:
            subscriber["id"] = notification_id
            subscriber["timeStamp"] = event_timestamp
            subscriber["subscriptionId"] = subscriber["reference"]
            subscriber["operation"] = event_operation
            del subscriber["reference"]
            del subscriber["_id"]
            subscriber.update(event_details["params"])
        return subscribers

    def get_subscribers(
        self,
        vnfd_id: str,
        vnf_instance_id: str,
        command: str,
        op_state: str,
        event_details: dict,
    ) -> list:
        """
        Queries database and returns list of subscribers.
        :param vnfd_id: Vnfd id of a VNF whose lifecycle has changed. (instantiated, scaled, terminated. etc)
        :param vnf_instance_id: Vnf instance id of a VNF whose lifecycle has changed.
        :param command: the command for event.
        :param op_state: the operation state of VNF.
        :param event_details: dict containing raw data of event occurred.
        :return: List of interested subscribers for occurred event.
        """
        notification_type = [
            "VnfIdentifierCreationNotification",
            "VnfLcmOperationOccurrenceNotification",
            "VnfIdentifierDeletionNotification",
        ]
        filter_q = {
            "identifier": [vnfd_id, vnf_instance_id],
            "operationStates": ["ANY"],
            "operationTypes": ["ANY"],
            "notificationType": notification_type,
        }
        if op_state:
            filter_q["operationStates"].append(op_state)
        if command:
            filter_q["operationTypes"].append(command)
        subscribers = []
        try:
            subscribers = self.db.get_list(self.subscriber_collection, filter_q)
            subscribers = self._format_vnflcm_subscribers(subscribers, event_details)
        except Exception as e:
            error_text = type(e).__name__ + ": " + str(e)
            self.logger.debug("Error getting vnflcm subscribers: {}".format(error_text))
        finally:
            return subscribers


class NsdNotification(NotificationBase):
    def __init__(self, db):
        """
        Constructor of the class
        """
        super().__init__(db)
        # TODO will update this once support is there from subscription
        self.response_models = {}
        self.subscriber_collection = None


class VnfdNotification(NotificationBase):
    def __init__(self, db):
        """
        Constructor of the class
        """
        super().__init__(db)
        # TODO will update this once support is there from subscription
        self.response_models = {}
        self.subscriber_collection = None