import gc
from pathlib import Path

from jedi import parser_utils
from parso import parse
from parso.cache import parser_cache
from parso.python import tree

import pytest


class TestCallAndName:
    def get_call(self, source):
        # Get the simple_stmt and then the first one.
        node = parse(source).children[0]
        if node.type == 'simple_stmt':
            return node.children[0]
        return node

    def test_name_and_call_positions(self):
        name = self.get_call('name\nsomething_else')
        assert name.value == 'name'
        assert name.start_pos == (1, 0)
        assert name.end_pos == (1, 4)

        leaf = self.get_call('1.0\n')
        assert leaf.value == '1.0'
        assert parser_utils.safe_literal_eval(leaf.value) == 1.0
        assert leaf.start_pos == (1, 0)
        assert leaf.end_pos == (1, 3)

    def test_call_type(self):
        call = self.get_call('hello')
        assert isinstance(call, tree.Name)

    def test_literal_type(self):
        literal = self.get_call('1.0')
        assert isinstance(literal, tree.Literal)
        assert type(parser_utils.safe_literal_eval(literal.value)) == float

        literal = self.get_call('1')
        assert isinstance(literal, tree.Literal)
        assert type(parser_utils.safe_literal_eval(literal.value)) == int

        literal = self.get_call('"hello"')
        assert isinstance(literal, tree.Literal)
        assert parser_utils.safe_literal_eval(literal.value) == 'hello'


def test_hex_values_in_docstring():
    source = r'''
        def foo(object):
            """
             \xff
            """
            return 1
        '''

    doc = parser_utils.clean_scope_docstring(next(parse(source).iter_funcdefs()))
    assert doc == '\xff'


@pytest.mark.parametrize(
    'code,signature', [
        ('def my_function(x, typed: Type, z):\n return', 'my_function(x, typed: Type, z)'),
        ('def my_function(x, y, z) -> str:\n return', 'my_function(x, y, z) -> str'),
        ('lambda x, y, z: x + y * z\n', '<lambda>(x, y, z)')
    ])
def test_get_signature(code, signature):
    node = parse(code, version='3.8').children[0]
    if node.type == 'simple_stmt':
        node = node.children[0]
    assert parser_utils.get_signature(node) == signature


def test_parser_cache_clear(Script):
    """
    If parso clears its cache, Jedi should not keep those resources, they
    should be freed.
    """
    script = Script("a = abs\na", path=Path(__file__).parent / 'parser_cache_test_foo.py')
    script.complete()
    module_id = id(script._module_node)
    del parser_cache[script._inference_state.grammar._hashed][script.path]
    del script

    gc.collect()
    assert module_id not in [id(m) for m in gc.get_referrers(tree.Module)]