# ================================================================================
# Copyright (c) 2018 AT&T Intellectual Property. 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.
# ============LICENSE_END=========================================================
#
# ECOMP is a trademark and service mark of AT&T Intellectual Property.

"""policy-client communicates with policy-engine thru REST API"""

import json
import logging
import re

from .policy_consts import (POLICY_BODY, POLICY_CONFIG, POLICY_ID, POLICY_NAME,
                            POLICY_VERSION)

class PolicyUtils(object):
    """policy-client utils"""
    _logger = logging.getLogger("policy_handler.policy_utils")
    _policy_name_ext = re.compile('[.][0-9]+[.][a-zA-Z]+$')

    @staticmethod
    def extract_policy_id(policy_name):
        """ policy_name  = policy_id + "." + <version> + "." + <extension>
        For instance,
        policy_name      = DCAE_alex.Config_alex_policy_number_1.3.xml
               policy_id = DCAE_alex.Config_alex_policy_number_1
            policy_scope = DCAE_alex
            policy_class = Config
          policy_version = 3
        type = extension = xml
               delimiter = "."
        policy_class_delimiter = "_"
        policy_name in PAP = DCAE_alex.alex_policy_number_1
        """
        if not policy_name:
            return
        return PolicyUtils._policy_name_ext.sub('', policy_name)

    @staticmethod
    def parse_policy_config(policy):
        """try parsing the config in policy."""
        if not policy:
            return policy
        config = policy.get(POLICY_BODY, {}).get(POLICY_CONFIG)
        if config:
            policy[POLICY_BODY][POLICY_CONFIG] = Utils.safe_json_parse(config)
        return policy

    @staticmethod
    def convert_to_policy(policy_config):
        """wrap policy_config received from policy-engine with policy_id."""
        if not policy_config:
            return
        policy_name = policy_config.get(POLICY_NAME)
        policy_version = policy_config.get(POLICY_VERSION)
        if not policy_name or not policy_version:
            return
        policy_id = PolicyUtils.extract_policy_id(policy_name)
        if not policy_id:
            return
        return {POLICY_ID:policy_id, POLICY_BODY:policy_config}

    @staticmethod
    def select_latest_policy(policy_configs, min_version_expected=None, ignore_policy_names=None):
        """For some reason, the policy-engine returns all version of the policy_configs.
        DCAE-Controller is only interested in the latest version
        """
        if not policy_configs:
            return
        latest_policy_config = {}
        for policy_config in policy_configs:
            policy_name = policy_config.get(POLICY_NAME)
            policy_version = policy_config.get(POLICY_VERSION)
            if not policy_name or not policy_version or not policy_version.isdigit():
                continue
            policy_version = int(policy_version)
            if min_version_expected and policy_version < min_version_expected:
                continue
            if ignore_policy_names and policy_name in ignore_policy_names:
                continue

            if not latest_policy_config \
            or int(latest_policy_config[POLICY_VERSION]) < policy_version:
                latest_policy_config = policy_config

        return PolicyUtils.parse_policy_config(PolicyUtils.convert_to_policy(latest_policy_config))

    @staticmethod
    def select_latest_policies(policy_configs):
        """For some reason, the policy-engine returns all version of the policy_configs.
        DCAE-Controller is only interested in the latest versions
        """
        if not policy_configs:
            return {}
        policies = {}
        for policy_config in policy_configs:
            policy = PolicyUtils.convert_to_policy(policy_config)
            if not policy:
                continue
            policy_id = policy.get(POLICY_ID)
            policy_version = policy.get(POLICY_BODY, {}).get(POLICY_VERSION)
            if not policy_id or not policy_version or not policy_version.isdigit():
                continue
            if policy_id not in policies \
            or int(policy_version) > int(policies[policy_id][POLICY_BODY][POLICY_VERSION]):
                policies[policy_id] = policy

        for policy_id in policies:
            policies[policy_id] = PolicyUtils.parse_policy_config(policies[policy_id])

        return policies

class Utils(object):
    """general purpose utils"""
    _logger = logging.getLogger("policy_handler.utils")

    @staticmethod
    def safe_json_parse(json_str):
        """try parsing json without exception - returns the json_str back if fails"""
        if not json_str:
            return json_str
        try:
            return json.loads(json_str)
        except (ValueError, TypeError) as err:
            Utils._logger.warning("unexpected json error(%s): len(%s) str[:100]: (%s)",
                                  str(err), len(json_str), str(json_str)[:100])
        return json_str

    @staticmethod
    def are_the_same(body_1, body_2):
        """check whether both objects are the same"""
        if (body_1 and not body_2) or (not body_1 and body_2):
            Utils._logger.debug("only one is empty %s != %s", body_1, body_2)
            return False

        if body_1 is None and body_2 is None:
            return True

        if isinstance(body_1, list) and isinstance(body_2, list):
            if len(body_1) != len(body_2):
                Utils._logger.debug("len %s != %s", json.dumps(body_1), json.dumps(body_2))
                return False

            for val_1, val_2 in zip(body_1, body_2):
                if not Utils.are_the_same(val_1, val_2):
                    return False
            return True

        if isinstance(body_1, dict) and isinstance(body_2, dict):
            if body_1.keys() ^ body_2.keys():
                Utils._logger.debug("keys %s != %s", json.dumps(body_1), json.dumps(body_2))
                return False

            for key, val_1 in body_1.items():
                if not Utils.are_the_same(val_1, body_2[key]):
                    return False
            return True

        # ... here when primitive values or mismatched types ...
        the_same_values = (body_1 == body_2)
        if not the_same_values:
            Utils._logger.debug("values %s != %s", body_1, body_2)
        return the_same_values