"""
PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
through function annotations. There is a strong suggestion in this document
that only the type of type hinting defined in PEP0484 should be allowed
as annotations in future python versions.
"""

import re

from parso import ParserSyntaxError, parse

from jedi._compatibility import force_unicode
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.base_value import ContextSet, NO_VALUES
from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \
    AbstractAnnotatedClass
from jedi.inference.gradual.typing import GenericClass
from jedi.inference.helpers import is_string
from jedi.inference.compiled import builtin_from_name
from jedi import debug
from jedi import parser_utils


def infer_annotation(value, annotation):
    """
    Inferes an annotation node. This means that it inferes the part of
    `int` here:

        foo: int = 3

    Also checks for forward references (strings)
    """
    value_set = value.infer_node(annotation)
    if len(value_set) != 1:
        debug.warning("Inferred typing index %s should lead to 1 object, "
                      " not %s" % (annotation, value_set))
        return value_set

    inferred_value = list(value_set)[0]
    if is_string(inferred_value):
        result = _get_forward_reference_node(value, inferred_value.get_safe_value())
        if result is not None:
            return value.infer_node(result)
    return value_set


def _infer_annotation_string(value, string, index=None):
    node = _get_forward_reference_node(value, string)
    if node is None:
        return NO_VALUES

    value_set = value.infer_node(node)
    if index is not None:
        value_set = value_set.filter(
            lambda value: value.array_type == u'tuple'  # noqa
                            and len(list(value.py__iter__())) >= index
        ).py__simple_getitem__(index)
    return value_set


def _get_forward_reference_node(value, string):
    try:
        new_node = value.infer_state.grammar.parse(
            force_unicode(string),
            start_symbol='eval_input',
            error_recovery=False
        )
    except ParserSyntaxError:
        debug.warning('Annotation not parsed: %s' % string)
        return None
    else:
        module = value.tree_node.get_root_node()
        parser_utils.move(new_node, module.end_pos[0])
        new_node.parent = value.tree_node
        return new_node


def _split_comment_param_declaration(decl_text):
    """
    Split decl_text on commas, but group generic expressions
    together.

    For example, given "foo, Bar[baz, biz]" we return
    ['foo', 'Bar[baz, biz]'].

    """
    try:
        node = parse(decl_text, error_recovery=False).children[0]
    except ParserSyntaxError:
        debug.warning('Comment annotation is not valid Python: %s' % decl_text)
        return []

    if node.type == 'name':
        return [node.get_code().strip()]

    params = []
    try:
        children = node.children
    except AttributeError:
        return []
    else:
        for child in children:
            if child.type in ['name', 'atom_expr', 'power']:
                params.append(child.get_code().strip())

    return params


@infer_state_method_cache()
def infer_param(execution_value, param):
    values = _infer_param(execution_value, param)
    infer_state = execution_value.infer_state
    if param.star_count == 1:
        tuple_ = builtin_from_name(infer_state, 'tuple')
        return ContextSet([GenericClass(
            tuple_,
            generics=(values,),
        ) for c in values])
    elif param.star_count == 2:
        dct = builtin_from_name(infer_state, 'dict')
        return ContextSet([GenericClass(
            dct,
            generics=(ContextSet([builtin_from_name(infer_state, 'str')]), values),
        ) for c in values])
        pass
    return values


def _infer_param(execution_value, param):
    """
    Infers the type of a function parameter, using type annotations.
    """
    annotation = param.annotation
    if annotation is None:
        # If no Python 3-style annotation, look for a Python 2-style comment
        # annotation.
        # Identify parameters to function in the same sequence as they would
        # appear in a type comment.
        all_params = [child for child in param.parent.children
                      if child.type == 'param']

        node = param.parent.parent
        comment = parser_utils.get_following_comment_same_line(node)
        if comment is None:
            return NO_VALUES

        match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment)
        if not match:
            return NO_VALUES
        params_comments = _split_comment_param_declaration(match.group(1))

        # Find the specific param being investigated
        index = all_params.index(param)
        # If the number of parameters doesn't match length of type comment,
        # ignore first parameter (assume it's self).
        if len(params_comments) != len(all_params):
            debug.warning(
                "Comments length != Params length %s %s",
                params_comments, all_params
            )
        from jedi.inference.value.instance import InstanceArguments
        if isinstance(execution_value.var_args, InstanceArguments):
            if index == 0:
                # Assume it's self, which is already handled
                return NO_VALUES
            index -= 1
        if index >= len(params_comments):
            return NO_VALUES

        param_comment = params_comments[index]
        return _infer_annotation_string(
            execution_value.function_value.get_default_param_value(),
            param_comment
        )
    # Annotations are like default params and resolve in the same way.
    value = execution_value.function_value.get_default_param_value()
    return infer_annotation(value, annotation)


def py__annotations__(funcdef):
    dct = {}
    for function_param in funcdef.get_params():
        param_annotation = function_param.annotation
        if param_annotation is not None:
            dct[function_param.name.value] = param_annotation

    return_annotation = funcdef.annotation
    if return_annotation:
        dct['return'] = return_annotation
    return dct


@infer_state_method_cache()
def infer_return_types(function_execution_value):
    """
    Infers the type of a function's return value,
    according to type annotations.
    """
    all_annotations = py__annotations__(function_execution_value.tree_node)
    annotation = all_annotations.get("return", None)
    if annotation is None:
        # If there is no Python 3-type annotation, look for a Python 2-type annotation
        node = function_execution_value.tree_node
        comment = parser_utils.get_following_comment_same_line(node)
        if comment is None:
            return NO_VALUES

        match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment)
        if not match:
            return NO_VALUES

        return _infer_annotation_string(
            function_execution_value.function_value.get_default_param_value(),
            match.group(1).strip()
        ).execute_annotation()
        if annotation is None:
            return NO_VALUES

    value = function_execution_value.function_value.get_default_param_value()
    unknown_type_vars = list(find_unknown_type_vars(value, annotation))
    annotation_values = infer_annotation(value, annotation)
    if not unknown_type_vars:
        return annotation_values.execute_annotation()

    type_var_dict = infer_type_vars_for_execution(function_execution_value, all_annotations)

    return ContextSet.from_sets(
        ann.define_generics(type_var_dict)
        if isinstance(ann, (AbstractAnnotatedClass, TypeVar)) else ContextSet({ann})
        for ann in annotation_values
    ).execute_annotation()


def infer_type_vars_for_execution(execution_value, annotation_dict):
    """
    Some functions use type vars that are not defined by the class, but rather
    only defined in the function. See for example `iter`. In those cases we
    want to:

    1. Search for undefined type vars.
    2. Infer type vars with the execution state we have.
    3. Return the union of all type vars that have been found.
    """
    value = execution_value.function_value.get_default_param_value()

    annotation_variable_results = {}
    executed_params, _ = execution_value.get_executed_params_and_issues()
    for executed_param in executed_params:
        try:
            annotation_node = annotation_dict[executed_param.string_name]
        except KeyError:
            continue

        annotation_variables = find_unknown_type_vars(value, annotation_node)
        if annotation_variables:
            # Infer unknown type var
            annotation_value_set = value.infer_node(annotation_node)
            star_count = executed_param._param_node.star_count
            actual_value_set = executed_param.infer(use_hints=False)
            if star_count == 1:
                actual_value_set = actual_value_set.merge_types_of_iterate()
            elif star_count == 2:
                # TODO _dict_values is not public.
                actual_value_set = actual_value_set.try_merge('_dict_values')
            for ann in annotation_value_set:
                _merge_type_var_dicts(
                    annotation_variable_results,
                    _infer_type_vars(ann, actual_value_set),
                )

    return annotation_variable_results


def _merge_type_var_dicts(base_dict, new_dict):
    for type_var_name, values in new_dict.items():
        try:
            base_dict[type_var_name] |= values
        except KeyError:
            base_dict[type_var_name] = values


def _infer_type_vars(annotation_value, value_set):
    """
    This function tries to find information about undefined type vars and
    returns a dict from type var name to value set.

    This is for example important to understand what `iter([1])` returns.
    According to typeshed, `iter` returns an `Iterator[_T]`:

        def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...

    This functions would generate `int` for `_T` in this case, because it
    unpacks the `Iterable`.
    """
    type_var_dict = {}
    if isinstance(annotation_value, TypeVar):
        return {annotation_value.py__name__(): value_set.py__class__()}
    elif isinstance(annotation_value, LazyGenericClass):
        name = annotation_value.py__name__()
        if name == 'Iterable':
            given = annotation_value.get_generics()
            if given:
                for nested_annotation_value in given[0]:
                    _merge_type_var_dicts(
                        type_var_dict,
                        _infer_type_vars(
                            nested_annotation_value,
                            value_set.merge_types_of_iterate()
                        )
                    )
        elif name == 'Mapping':
            given = annotation_value.get_generics()
            if len(given) == 2:
                for value in value_set:
                    try:
                        method = value.get_mapping_item_values
                    except AttributeError:
                        continue
                    key_values, value_values = method()

                    for nested_annotation_value in given[0]:
                        _merge_type_var_dicts(
                            type_var_dict,
                            _infer_type_vars(
                                nested_annotation_value,
                                key_values,
                            )
                        )
                    for nested_annotation_value in given[1]:
                        _merge_type_var_dicts(
                            type_var_dict,
                            _infer_type_vars(
                                nested_annotation_value,
                                value_values,
                            )
                        )
    return type_var_dict


def find_type_from_comment_hint_for(value, node, name):
    return _find_type_from_comment_hint(value, node, node.children[1], name)


def find_type_from_comment_hint_with(value, node, name):
    assert len(node.children[1].children) == 3, \
        "Can only be here when children[1] is 'foo() as f'"
    varlist = node.children[1].children[2]
    return _find_type_from_comment_hint(value, node, varlist, name)


def find_type_from_comment_hint_assign(value, node, name):
    return _find_type_from_comment_hint(value, node, node.children[0], name)


def _find_type_from_comment_hint(value, node, varlist, name):
    index = None
    if varlist.type in ("testlist_star_expr", "exprlist", "testlist"):
        # something like "a, b = 1, 2"
        index = 0
        for child in varlist.children:
            if child == name:
                break
            if child.type == "operator":
                continue
            index += 1
        else:
            return []

    comment = parser_utils.get_following_comment_same_line(node)
    if comment is None:
        return []
    match = re.match(r"^#\s*type:\s*([^#]*)", comment)
    if match is None:
        return []
    return _infer_annotation_string(
        value, match.group(1).strip(), index
    ).execute_annotation()


def find_unknown_type_vars(value, node):
    def check_node(node):
        if node.type in ('atom_expr', 'power'):
            trailer = node.children[-1]
            if trailer.type == 'trailer' and trailer.children[0] == '[':
                for subscript_node in _unpack_subscriptlist(trailer.children[1]):
                    check_node(subscript_node)
        else:
            type_var_set = value.infer_node(node)
            for type_var in type_var_set:
                if isinstance(type_var, TypeVar) and type_var not in found:
                    found.append(type_var)

    found = []  # We're not using a set, because the order matters.
    check_node(node)
    return found


def _unpack_subscriptlist(subscriptlist):
    if subscriptlist.type == 'subscriptlist':
        for subscript in subscriptlist.children[::2]:
            if subscript.type != 'subscript':
                yield subscript
    else:
        if subscriptlist.type != 'subscript':
            yield subscriptlist