"""Tests for tokenutil"""

# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.

import pytest
import textwrap

from IPython.utils.tokenutil import token_at_cursor, line_at_cursor


def expect_token(expected: str, cell: str, cursor_pos: int | None = None) -> None:
    """
    If cursor_pos is `None`, look for `|` as the cursor position.
    Assert that the token at the cursor position is `expected`.
    """
    if cursor_pos is None:
        assert (
            cursor_count := cell.count("|")
        ) == 1, (
            f"Cursor position not specified and found {cursor_count} instance(s) of '|'"
        )
        cursor_pos = cell.index("|")
        cell = cell.replace("|", "")
    token = token_at_cursor(cell, cursor_pos)
    offset = 0
    for line in cell.splitlines():
        if offset + len(line) >= cursor_pos:
            break
        else:
            offset += len(line) + 1
    column = cursor_pos - offset
    line_with_cursor = "%s|%s" % (line[:column], line[column:])
    assert token == expected, "Expected %r, got %r in: %r (pos %i)" % (
        expected,
        token,
        line_with_cursor,
        cursor_pos,
    )


def test_simple():
    cell = "foo"
    for i in range(len(cell)):
        expect_token("foo", cell, i)


def test_function():
    cell = "foo(a=5, b='10')"
    for i in range(len(cell)):
        expect_token("foo", cell, i)
    expect_token("a", "foo(|a, b)")
    expect_token("foo", "foo(a|, b)")
    expect_token("foo", "foo(a,| b)")
    expect_token("b", "foo(a, |b)")
    expect_token("foo", "foo(a, b|)")


@pytest.mark.parametrize(
    "cell",
    [
        "\n".join(["a = 5", "b = hello('string', there)"]),
        textwrap.dedent(
            '''
            """\n\nxxxxxxxxxx\n\n"""
            5, """
            """\n\nxxxxxxxxxx\n\n"""
            docstring
            multiline token
            """, [
            2, 3, "complicated"]
            b = hello("string", there)
        '''
        ),
    ],
)
def test_multiline(cell):
    expected = "hello"
    start = cell.index(expected) + 1
    for i in range(start, start + len(expected)):
        expect_token(expected, cell, i)
    start = cell.index(expected) + 1
    for i in range(start, start + len(expected)):
        expect_token(expected, cell, i)


def test_nested_call_kwargs():
    cell = "foo(bar(a=5), b=10)"
    start = cell.index("bar")
    last = start + len("bar")
    for i in range(start, last + 1):
        expect_token("bar", cell, i)
    start = cell.index("a=")
    for i in range(start, start + 3):
        expect_token("bar", cell, i)
    expect_token("bar", "foo(bar(a=|5), b=10)")
    expect_token("bar", "foo(bar(a=5|), b=10)")
    for i in range(cell.index(")") + 1, cell.index("b=") + 2):
        expect_token("foo", cell, i)
    expect_token("foo", cell, len(cell) - 1)


def test_nested_call_args():
    expect_token("bar", "foo(bar(x,| ))")
    expect_token("bar", "foo(bar(x, |))")
    expect_token("bar", "foo(ba|r(x, y))")
    expect_token("x", "foo(bar(|x, y))")
    expect_token("bar", "foo(bar(x|, y))")
    expect_token("bar", "foo(bar(x,| y))")
    expect_token("y", "foo(bar(x, |y))")
    expect_token("bar", "foo(bar(x, y|))")
    expect_token("foo", "foo(bar(x, y)|)")
    expect_token("foo", "foo(bar(, y)|)")


def test_outer_name():
    expect_token("x", "|x + foo(a, b) + y + z")
    expect_token("x", "x| + foo(a, b) + y + z")
    expect_token("x", "x |+ foo(a, b) + y + z")
    expect_token("x", "x +| foo(a, b) + y + z")
    expect_token("foo", "x + |foo(a, b) + y + z")
    expect_token("a", "x + foo(|a, b) + y + z")
    expect_token("foo", "x + foo(a|, b) + y + z")
    expect_token("foo", "x + foo(a, b)| + y + z")
    expect_token("foo", "x + foo(a, b) |+ y + z")
    expect_token("foo", "x + foo(a, b) +| y + z")
    expect_token("y", "x + foo(a, b) + |y + z")
    expect_token("y", "x + foo(a, b) + y| + z")
    expect_token("y", "x + foo(a, b) + y |+ z")
    expect_token("y", "x + foo(a, b) + y +| z")
    expect_token("z", "x + foo(a, b) + y + |z")


def test_attrs():
    cell = "a = obj.attr.subattr"
    expected = "obj"
    idx = cell.find("obj") + 1
    for i in range(idx, idx + 3):
        expect_token(expected, cell, i)
    idx = cell.find(".attr") + 2
    expected = "obj.attr"
    for i in range(idx, idx + 4):
        expect_token(expected, cell, i)
    idx = cell.find(".subattr") + 2
    expected = "obj.attr.subattr"
    for i in range(idx, len(cell)):
        expect_token(expected, cell, i)


def test_line_at_cursor():
    cell = ""
    (line, offset) = line_at_cursor(cell, cursor_pos=11)
    assert line == ""
    assert offset == 0

    # The position after a newline should be the start of the following line.
    cell = "One\nTwo\n"
    (line, offset) = line_at_cursor(cell, cursor_pos=4)
    assert line == "Two\n"
    assert offset == 4

    # The end of a cell should be on the last line
    cell = "pri\npri"
    (line, offset) = line_at_cursor(cell, cursor_pos=7)
    assert line == "pri"
    assert offset == 4


@pytest.mark.parametrize(
    "c, token",
    zip(
        list(range(16, 22)) + list(range(22, 28)),
        ["int"] * (22 - 16) + ["map"] * (28 - 22),
    ),
)
def test_multiline_statement(c, token):
    cell = """a = (1,
    3)

int()
map()
"""
    expect_token(token, cell, c)