# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

from types import FunctionType

from ...utils.formatting import safe_repr
from ...utils.type import full_type_name
from ..validation import Issue
from .null import NULL


def get_locator(*values):
    """
    Gets the first available locator.

    :rtype: :class:`aria.parser.reading.Locator`
    """

    for v in values:
        if hasattr(v, '_locator'):
            locator = v._locator
            if locator is not None:
                return locator
    return None


def parse_types_dict_names(types_dict_names):
    """
    If the first element in the array is a function, extracts it out.
    """

    convert = None
    if isinstance(types_dict_names[0], FunctionType):
        convert = types_dict_names[0]
        types_dict_names = types_dict_names[1:]
    return types_dict_names, convert


def validate_primitive(value, cls, coerce=False):
    """
    Checks if the value is of the primitive type, optionally attempting to coerce it
    if it is not.

    :raises ValueError: if not a primitive type or if coercion failed.
    """

    if (cls is not None) and (value is not None) and (value is not NULL):
        if (cls is unicode) or (cls is str): # These two types are interchangeable
            valid = isinstance(value, basestring)
        elif cls is int:
            # In Python, a bool is an int
            valid = isinstance(value, int) and not isinstance(value, bool)
        else:
            valid = isinstance(value, cls)
        if not valid:
            if coerce:
                value = cls(value)
            else:
                raise ValueError('not a "%s": %s' % (full_type_name(cls), safe_repr(value)))
    return value


def validate_no_short_form(context, presentation):
    """
    Makes sure that we can use short form definitions only if we allowed it.
    """

    if not hasattr(presentation, 'SHORT_FORM_FIELD') and not isinstance(presentation._raw, dict):
        context.validation.report('short form not allowed for field "%s"' % presentation._fullname,
                                  locator=presentation._locator,
                                  level=Issue.BETWEEN_FIELDS)


def validate_no_unknown_fields(context, presentation):
    """
    Make sure that we can use unknown fields only if we allowed it.
    """

    if not getattr(presentation, 'ALLOW_UNKNOWN_FIELDS', False) \
            and not context.validation.allow_unknown_fields \
            and isinstance(presentation._raw, dict) \
            and hasattr(presentation, 'FIELDS'):
        for k in presentation._raw:
            if k not in presentation.FIELDS:
                context.validation.report('field "%s" is not supported in "%s"'
                                          % (k, presentation._fullname),
                                          locator=presentation._get_child_locator(k),
                                          level=Issue.BETWEEN_FIELDS)


def validate_known_fields(context, presentation):
    """
    Validates all known fields.
    """

    if hasattr(presentation, '_iter_fields'):
        for _, field in presentation._iter_fields():
            field.validate(presentation, context)


def get_parent_presentation(context, presentation, *types_dict_names):
    """
    Returns the parent presentation according to the ``derived_from`` field, or ``None`` if invalid.

    Checks that we do not derive from ourselves and that we do not cause a circular hierarchy.

    The arguments from the third onwards are used to locate a nested field under
    ``service_template`` under the root presenter. The first of these can optionally be a function,
    in which case it will be called to convert type names. This can be used to support shorthand
    type names, aliases, etc.
    """

    type_name = presentation.derived_from

    if type_name is None:
        return None

    types_dict_names, convert = parse_types_dict_names(types_dict_names)
    types_dict = context.presentation.get('service_template', *types_dict_names) or {}

    if convert:
        type_name = convert(context, type_name, types_dict)

    # Make sure not derived from self
    if type_name == presentation._name:
        return None
    # Make sure derived from type exists
    elif type_name not in types_dict:
        return None
    else:
        # Make sure derivation hierarchy is not circular
        hierarchy = [presentation._name]
        presentation_copy = presentation
        while presentation_copy.derived_from is not None:
            derived_from = presentation_copy.derived_from
            if convert:
                derived_from = convert(context, derived_from, types_dict)

            if derived_from == presentation_copy._name or derived_from not in types_dict:
                return None
            presentation_copy = types_dict[derived_from]
            if presentation_copy._name in hierarchy:
                return None
            hierarchy.append(presentation_copy._name)

    return types_dict[type_name]


def report_issue_for_unknown_type(context, presentation, type_name, field_name, value=None):
    if value is None:
        value = getattr(presentation, field_name)
    context.validation.report('"%s" refers to an unknown %s in "%s": %s'
                              % (field_name, type_name, presentation._fullname, safe_repr(value)),
                              locator=presentation._get_child_locator(field_name),
                              level=Issue.BETWEEN_TYPES)


def report_issue_for_parent_is_self(context, presentation, field_name):
    context.validation.report('parent type of "%s" is self' % presentation._fullname,
                              locator=presentation._get_child_locator(field_name),
                              level=Issue.BETWEEN_TYPES)


def report_issue_for_unknown_parent_type(context, presentation, field_name):
    context.validation.report('unknown parent type "%s" in "%s"'
                              % (getattr(presentation, field_name), presentation._fullname),
                              locator=presentation._get_child_locator(field_name),
                              level=Issue.BETWEEN_TYPES)


def report_issue_for_circular_type_hierarchy(context, presentation, field_name):
    context.validation.report('"%s" of "%s" creates a circular type hierarchy'
                              % (getattr(presentation, field_name), presentation._fullname),
                              locator=presentation._get_child_locator(field_name),
                              level=Issue.BETWEEN_TYPES)