#  Copyright (c) 2021, Manfred Moitzi
#  License: MIT License
import pytest

pytest.importorskip("PySide6")

from io import StringIO
import math
from ezdxf.lldxf.tags import Tags, DXFTag
from ezdxf.lldxf.loader import load_dxf_structure
from ezdxf.lldxf.tagger import ascii_tags_loader

from ezdxf.addons.browser import DXFTagsModel, DXFStructureModel, DXFDocument
from ezdxf.addons.browser.tags import compile_tags
from ezdxf.addons.browser.data import (
    EntityIndex,
    EntityHistory,
    SearchIndex,
)

from ezdxf.addons.xqt import Qt, QModelIndex


def txt2tags(s: str) -> Tags:
    return Tags(ascii_tags_loader(StringIO(s), skip_comments=False))


NAN = float("nan")


# noinspection PyMissingConstructor
class ModelIndex(QModelIndex):
    """Proxy"""

    def __init__(self, row, col):
        self._row = row
        self._col = col

    def row(self):
        return self._row

    def column(self):
        return self._col


class TestDXFTagsModel:
    def tags(self):
        return txt2tags(POINT)

    @pytest.fixture
    def model(self):
        return DXFTagsModel(self.tags())

    def test_fixed_column_count(self, model):
        assert model.columnCount() == 3

    def test_row_count(self, model):
        assert model.rowCount() == len(compile_tags(self.tags()))

    def test_render_display_role(self, model):
        assert model.data(ModelIndex(0, 0), role=Qt.DisplayRole) == "0"
        assert model.data(ModelIndex(0, 1), role=Qt.DisplayRole) == "<ctrl>"
        assert model.data(ModelIndex(0, 2), role=Qt.DisplayRole) == "POINT"


POINT = """0
POINT
5
0
330
0
100
AcDbEntity
8
0
100
AcDbPoint
10
0.0
20
0.0
30
0.0
"""


def test_setup_dxf_structure_model():
    sections = load_dxf_structure(txt2tags(ENTITIES))
    doc = DXFDocument(sections)
    model = DXFStructureModel("ez.dxf", doc)
    parent = model.item(0, 0)
    assert parent.data(Qt.DisplayRole) == "ez.dxf"
    assert "ENTITIES" in parent.child(0, 0).data(Qt.DisplayRole)
    # one level down
    parent = parent.child(0, 0)
    assert "LINE" in parent.child(0, 0).data(Qt.DisplayRole)
    assert "LINE" in parent.child(1, 0).data(Qt.DisplayRole)


class TestDXFDocument:
    @pytest.fixture
    def doc(self):
        sections = load_dxf_structure(txt2tags(ENTITIES))
        return DXFDocument(sections)

    def test_get_entity_returns_entity_tags(self, doc):
        entity = doc.get_entity("100")
        assert entity[0] == (0, "LINE")

    def test_get_entity_by_invalid_handle_returns_none(self, doc):
        assert doc.get_entity("XXX") is None

    def test_get_start_line_number_for_entity(self, doc):
        entity = doc.get_entity("101")
        assert doc.get_line_number(entity) == 9

    def test_get_entity_by_line_number(self, doc):
        entity = doc.get_entity("101")
        assert doc.get_entity_at_line(9) is entity
        assert doc.get_entity_at_line(10) is entity
        assert (
            doc.get_entity_at_line(99) is entity
        ), "should return the last entity"


class TestTagCompiler:
    def test_compile_single_int(self):
        tags = compile_tags(txt2tags("70\n3"))
        assert tags[0] == (70, 3)

    def test_compile_invalid_int_to_str(self):
        tags = compile_tags(txt2tags("70\nx"))
        assert tags[0] == (70, "x")

    def test_compile_single_float(self):
        tags = compile_tags(txt2tags("40\n3.14"))
        assert tags[0] == (40, 3.14)

    def test_compile_invalid_float_to_str(self):
        tags = compile_tags(txt2tags("40\nx.14"))
        assert tags[0] == (40, "x.14")

    def test_compile_single_2d_point(self):
        tags = compile_tags(txt2tags("10\n1.2\n20\n2.3"))
        assert tags[0] == (10, (1.2, 2.3))

    def test_compile_two_2d_points(self):
        tags = compile_tags(txt2tags("10\n1.1\n20\n1.2\n10\n2.1\n20\n2.2"))
        assert tags[0] == (10, (1.1, 1.2))
        assert tags[1] == (10, (2.1, 2.2))

    def test_compile_nan_coords_2d(self):
        tags = compile_tags(txt2tags("10\nx.2\n20\n2.3"))
        assert math.isnan(tags[0].value[0])

    def test_compile_single_3d_point(self):
        tags = compile_tags(txt2tags("10\n1.2\n20\n2.3\n30\n3.4"))
        assert tags[0] == (10, (1.2, 2.3, 3.4))

    def test_compile_nan_coords_3d(self):
        tags = compile_tags(txt2tags("10\n1\n20\n2\n30\nx"))
        assert math.isnan(tags[0].value[2])

    def test_compile_single_group_code_10(self):
        tags = compile_tags(txt2tags("10\n1.1"))
        assert tags[0] == (10, 1.1)

    def test_compile_two_group_code_10(self):
        tags = compile_tags(txt2tags("10\n1.1\n10\n2.2"))
        assert tags[0] == (10, 1.1)
        assert tags[1] == (10, 2.2)

    def test_compile_swapped_coords(self):
        tags = compile_tags(txt2tags("20\n2.2\n10\n1.1"))
        assert tags[0] == (20, 2.2), "expected coords as single tags"
        assert tags[1] == (10, 1.1), "expected coords as single tags"


ENTITIES = """0
SECTION
2
ENTITIES
0
LINE
5
100
0
LINE
5
101
0
ENDSEC
0
EOF
"""

SECTIONS = """0
SECTION
2
HEADER
9
$ACADVER
1
AC1032
0
ENDSEC
0
SECTION
2
ENTITIES
0
LINE
5
100
0
ENDSEC
0
EOF
"""


class TestEntityIndex:
    @pytest.fixture(scope="class")
    def index(self):
        data = {
            "ENTITIES": [
                Tags([DXFTag(0, "ENTITY1"), DXFTag(5, "F001")]),
                Tags([DXFTag(0, "ENTITY2"), DXFTag(5, "F002")]),
                Tags([DXFTag(0, "ENTITY3"), DXFTag(5, "F003")]),
                Tags([DXFTag(0, "ENTITY4"), DXFTag(5, "F004")]),
                # last entity without handle, has dummy handle "*1"
                Tags([DXFTag(0, "ENTITY5"), DXFTag(1, "DATA")]),
            ]
        }
        return EntityIndex(data)

    def test_contains_all_entities(self, index):
        assert "F001" in index
        assert "F002" in index
        assert "F003" in index
        assert "F004" in index
        assert "*1" in index, "expected dummy handle"

    def test_get_entity_by_handle(self, index):
        tags = index.get("F001")
        assert tags[0] == (0, "ENTITY1")

    def test_get_entity_by_dummy_handle(self, index):
        tags = index.get("*1")
        assert tags[0] == (0, "ENTITY5")

    def test_get_handle_from_casted_tags(self, index):
        entity = Tags(index.get("F001"))
        assert index.get_handle(entity) == "F001"

    def test_get_dummy_handle_from_casted_tags(self, index):
        entity = Tags(index.get("*1"))
        assert index.get_handle(entity) == "*1"

    def test_get_next_entity(self, index):
        e1 = index.get("F001")
        e2 = index.get("F002")
        assert index.next_entity(e1) is e2

    def test_next_entity_of_last_entity_is_last_entity(self, index):
        e1 = index.get("*1")
        assert index.next_entity(e1) is e1

    def test_get_prev_entity(self, index):
        e1 = index.get("F001")
        e2 = index.get("F002")
        assert index.previous_entity(e2) is e1

    def test_prev_entity_of_first_entity_is_first_entity(self, index):
        e1 = index.get("F001")
        assert index.previous_entity(e1) is e1

    def test_max_line_number(self, index):
        assert index.max_line_number == 20

    def test_get_start_line_number(self, index):
        e = index.get("F003")
        assert index.get_start_line_for_entity(e) == 9

    def test_get_start_line_number_for_dummy_handle(self, index):
        e = index.get("*1")
        assert index.get_start_line_for_entity(e) == 17

    def test_entity_at_line(self, index):
        e3 = index.get("F003")
        assert index.get_entity_at_line(9) is e3
        assert index.get_entity_at_line(10) is e3

    def test_entity_at_line_for_dummy_handle(self, index):
        e = index.get("*1")
        assert index.get_entity_at_line(19) is e
        assert index.get_entity_at_line(20) is e


def test_entity_index_adds_missing_endsec_tag():
    # The function load_dxf_structure() throws the ENDSEC tag away.
    # The entity indexer must take this issue into account!
    sections = load_dxf_structure(txt2tags(SECTIONS))
    index = EntityIndex(sections)
    entity = index.get_entity_at_line(15)
    assert entity.get_handle() == "100"
    assert index.get_start_line_for_entity(entity) == 15


class TestEntityHistory:
    @pytest.fixture
    def history2(self):
        history = EntityHistory()
        history.append(Tags([DXFTag(1, "first")]))
        history.append(Tags([DXFTag(2, "second")]))
        return history

    def test_setup_history(self):
        history = EntityHistory()
        assert len(history) == 0
        assert history.index == 0

    def test_empty_history_returns_none(self):
        history = EntityHistory()
        assert history.back() is None
        assert history.forward() is None

    def test_append_one_entity(self):
        history = EntityHistory()
        history.append(Tags())
        assert len(history) == 1
        assert history.index == 0

    def test_append_two_entities(self):
        history = EntityHistory()
        history.append(Tags())
        history.append(Tags())
        assert len(history) == 2
        assert history.index == 1

    def test_go_back_in_history(self, history2):
        first, second = history2.content()
        assert history2.index == 1
        assert history2.back() is first
        assert len(history2) == 2, "entity is still in history"
        assert history2.index == 0

    def test_go_back_and_forward_in_history(self, history2):
        first, second = history2.content()
        assert history2.back() is first
        assert history2.forward() is second

    def test_append_should_add_time_travel_history(self, history2):
        first, second = history2.content()
        assert history2.back() is first  # 1st time travel
        assert history2.index == 0

        assert history2.forward() is second  # 2nd time travel
        assert history2.index == 1

        third = Tags([DXFTag(3, "third")])
        history2.append(third)
        assert history2.index == 4

        # complete travel history
        content = history2.content()
        assert len(content) == 5
        #                                 time wraps ->  append
        assert content == [first, second, first, second, third]


SEARCH_EXAMPLE1 = """0
SEARCH1
8
LayerName1
62
7
"""

SEARCH_EXAMPLE2 = """0
SEARCH2
8
LayerName2
62
6
"""


class TestSearchIndex:
    @pytest.fixture(scope="class")
    def entities(self):
        return [txt2tags(SEARCH_EXAMPLE1), txt2tags(SEARCH_EXAMPLE2)]

    @pytest.fixture
    def search(self, entities):
        return SearchIndex(entities)

    @staticmethod
    def move_cursor_forward(s: SearchIndex, count: int):
        for _ in range(count):
            s.move_cursor_forward()

    @staticmethod
    def move_cursor_backward(s: SearchIndex, count: int):
        for _ in range(count):
            s.move_cursor_backward()

    def test_valid_setup_and_default_settings(self, search):
        assert len(search.entities) == 2
        assert search.is_end_of_index is False
        assert (
            search.case_insensitive is True
        ), "should be case insensitive by default"
        assert (
            search.numbers is False
        ), "should not search in number tags by default"

    def test_empty_search_index(self):
        search_index = SearchIndex([])
        assert search_index.is_end_of_index is True

    def test_reset_cursor_forward(self, search):
        search.reset_cursor(backward=False)
        assert search.cursor() == (
            0,
            0,
        ), "cursor should be the first tag of the first entity"
        assert search.is_end_of_index is False

    def test_move_cursor_forward(self, search):
        search.reset_cursor()
        search.move_cursor_forward()
        assert search.cursor() == (0, 1)

    def test_move_cursor_forward_beyond_entity_border(self, search):
        search.reset_cursor()
        self.move_cursor_forward(search, 3)
        assert search.cursor() == (1, 0)

    def test_move_cursor_forward_to_the_end_of_index(self, search):
        search.reset_cursor()
        self.move_cursor_forward(search, 10)
        assert search.is_end_of_index is True
        assert search.cursor() == (
            1,
            2,
        ), "index should stop at the last tag of the last entity"

    def test_reset_cursor_backward(self, search):
        search.reset_cursor(backward=True)
        assert search.cursor() == (
            1,
            2,
        ), "cursor should be the last tag of the last entity"
        assert search.is_end_of_index is False

    def test_move_cursor_backward(self, search):
        search.reset_cursor(backward=True)
        search.move_cursor_backward()
        assert search.cursor() == (1, 1)

    def test_move_cursor_backward_beyond_entity_border(self, search):
        search.reset_cursor(backward=True)
        self.move_cursor_backward(search, 3)
        assert search.cursor() == (0, 2)

    def test_move_cursor_backward_to_the_end_of_index(self, search):
        search.reset_cursor()
        self.move_cursor_backward(search, 10)
        assert search.is_end_of_index is True
        assert search.cursor() == (
            0,
            0,
        ), "index should stop at the first tag of the first entity"

    def test_failing_search(self, search):
        entity, index = search.find("XDATA")
        assert entity is None
        assert index == -1
        assert search.is_end_of_index is True

    def test_find_entity_type(self, search):
        entity, index = search.find("SEARCH1")
        assert entity is search.entities[0]
        assert index == 0

    def test_find_forward_entity_type(self, search):
        search.find("SEARCH")
        entity, index = search.find_forward()
        assert entity is search.entities[1]
        assert index == 0

    def test_find_content(self, search):
        entity, index = search.find("LayerName1")
        assert entity is search.entities[0]
        assert index == 1

    def test_find_forward_content(self, search):
        search.find("LayerName")
        entity, index = search.find_forward()
        assert entity is search.entities[1]
        assert index == 1

    def test_failing_find_forward_returns_none(self, search):
        search.find("LayerName")
        search.find_forward()
        entity, index = search.find_forward()
        assert entity is None
        assert index == -1

    def test_not_initiated_find_forward_returns_none(self, search):
        entity, index = search.find_forward()
        assert entity is None
        assert index == -1

    def test_case_insensitive_search(self, search):
        search.case_insensitive = True
        entity, index = search.find("LAYERNAME1")
        assert entity is search.entities[0]
        assert index == 1

    def test_case_sensitive_search(self, search):
        search.case_insensitive = False
        entity, index = search.find("LAYERNAME1")
        assert entity is None

    def test_ignore_number_tags(self, search):
        search.numbers = False
        entity, index = search.find("6")
        assert entity is None

    def test_search_in_number_tags(self, search):
        search.numbers = True
        entity, index = search.find("6")
        assert entity is search.entities[1]
        assert index == 2

    def test_failing_find_forward_stops_at_the_end(self, search):
        assert search.find("XXX") is search.NOT_FOUND
        assert search.is_end_of_index is True

    def test_failing_find_backwards_stops_at_the_beginning(self, search):
        assert search.find("XXX", backward=True) is search.NOT_FOUND
        assert search.is_end_of_index is True


if __name__ == "__main__":
    pytest.main([__file__])
