from pathlib import Path

import docdeid as dd
import pytest

from deduce import utils
from deduce.annotator import TokenPatternAnnotator


class TestStrMatch:
    def test_str_match(self):
        assert utils.str_match("a", "a")
        assert utils.str_match("willem", "willem")
        assert not utils.str_match("a", "b")
        assert not utils.str_match("willem", "klaas")

    def test_str_match_fuzzy(self):
        assert utils.str_match("a", "a", max_edit_distance=1)
        assert utils.str_match("willem", "willem", max_edit_distance=1)
        assert utils.str_match("willem", "illem", max_edit_distance=1)
        assert utils.str_match("willem", "qwillem", max_edit_distance=1)
        assert utils.str_match("willem", "willme", max_edit_distance=1)
        assert utils.str_match("willem", "Willem", max_edit_distance=1)

        assert not utils.str_match("a", "abc", max_edit_distance=1)
        assert not utils.str_match("willem", "wilhelm", max_edit_distance=1)
        assert not utils.str_match("willem", "klaas", max_edit_distance=1)


class TestClassForName:
    def test_class_for_name(self):
        assert (
            utils.class_for_name(
                module_name="deduce.annotator", class_name="TokenPatternAnnotator"
            )
            == TokenPatternAnnotator
        )


class TestInitializeClass:
    def test_initialize_class(self):

        cls = TokenPatternAnnotator

        tag = "_"
        pattern = [{"key": "value"}]

        annotator = utils.initialize_class(
            cls, args={"tag": tag, "pattern": pattern}, extras={}
        )

        assert annotator.tag == tag
        assert annotator.pattern == pattern

    def test_initialize_class_with_extras(self):

        cls = TokenPatternAnnotator

        tag = "_"
        pattern = [{"key": "value"}]
        ds = dd.ds.DsCollection()

        annotator = utils.initialize_class(
            cls,
            args={"tag": tag, "pattern": pattern},
            extras={"ds": ds, "unused_argument": "_"},
        )

        assert annotator.tag == tag
        assert annotator.pattern == pattern
        assert annotator.ds is ds


class TestOverwriteDict:
    def test_empty(self):
        for add in [{}, {"a": 1}, {"a": 1, "b": {}}, {"a": 1, "b": {"c": 2}}]:
            assert utils.overwrite_dict({}, add) == add

    def test_nonempty_no_nesting(self):
        assert utils.overwrite_dict({"a": 1}, {"a": 1}) == {"a": 1}
        assert utils.overwrite_dict({"a": 1}, {"a": 2}) == {"a": 2}
        assert utils.overwrite_dict({"a": 1}, {"b": 2}) == {"a": 1, "b": 2}

    def test_nonempty_with_nesting(self):
        assert utils.overwrite_dict({"a": 1, "b": {"c": 2}}, {"b": {"c": 4}}) == {
            "a": 1,
            "b": {"c": 4},
        }
        assert utils.overwrite_dict({"a": 1, "b": {"c": 2}}, {"b": {"d": 4}}) == {
            "a": 1,
            "b": {"c": 2, "d": 4},
        }


class TestHasOverlap:
    def test_has_overlap(self):

        assert not utils.has_overlap([])
        assert not utils.has_overlap([(0, 10)])
        assert utils.has_overlap([(0, 10), (5, 15)])
        assert not utils.has_overlap([(0, 10), (10, 15)])
        assert not utils.has_overlap([(0, 10), (15, 25)])
        assert not utils.has_overlap([(15, 25), (0, 10)])


class TestStrVariations:
    def test_has_overlap(self):

        assert utils.has_overlap([(0, 10), (5, 14)])
        assert utils.has_overlap([(0, 10), (9, 15)])
        assert utils.has_overlap([(9, 15), (5, 10)])
        assert utils.has_overlap([(9, 15, True), (5, 10, False)])
        assert not utils.has_overlap([(0, 10), (10, 13)])
        assert not utils.has_overlap([(0, 10), (10, 10)])
        assert not utils.has_overlap([(0, 10, True), (10, 10, False)])

    def test_repl_none(self):

        s = "Prof. Lieflantlaan"
        matches = []

        segments = utils.repl_segments(s, matches)

        assert segments == [["Prof. Lieflantlaan"]]

    def test_repl_segments_single_to_single(self):

        s = "Prof. Lieflantlaan"
        matches = [(0, 5, ["Prof."])]

        segments = utils.repl_segments(s, matches)

        assert segments == [["Prof."], [" Lieflantlaan"]]

    def test_repl_segments_single_to_multiple(self):

        s = "Prof. Lieflantlaan"
        matches = [(0, 5, ["Prof.", "Professor"])]

        segments = utils.repl_segments(s, matches)

        assert segments == [["Prof.", "Professor"], [" Lieflantlaan"]]

    def test_repl_segments_multiple_to_multiple(self):

        s = "Prof. Lieflantlaan"
        matches = [(0, 5, ["Prof.", "Professor"]), (14, 18, ["laan", "ln"])]

        segments = utils.repl_segments(s, matches)

        assert segments == [["Prof.", "Professor"], [" Lieflant"], ["laan", "ln"]]

    def test_str_variations_no_matches(self):

        s = "Prof. Lieflantlaan"
        repl = {}

        variations = utils.str_variations(s, repl)

        assert variations == [s]

    def test_str_variations_overlap(self):

        s = "Prof. Lieflantlaan"
        repl = {"laan": ["laan", "ln"], "lantlaan": ["lantlaan", "lantln"]}

        with pytest.raises(RuntimeError):
            _ = utils.str_variations(s, repl)

    def test_str_variations_one_match(self):

        s = "Prof. Lieflantlaan"
        repl = {"Prof.": ["Prof.", "Professor"]}

        variations = utils.str_variations(s, repl)

        assert variations == ["Prof. Lieflantlaan", "Professor Lieflantlaan"]

    def test_str_variations_multiple_matches(self):

        s = "Prof. Lieflantlaan"
        repl = {"Prof.": ["Prof.", "Professor"], "laan": ["laan", "ln"]}

        variations = utils.str_variations(s, repl)

        assert variations == [
            "Prof. Lieflantlaan",
            "Professor Lieflantlaan",
            "Prof. Lieflantln",
            "Professor Lieflantln",
        ]

    def test_str_variations_regexp(self):

        s = "van Bevanstraat"
        repl = {"^van": ["Van", "van"]}

        variations = utils.str_variations(s, repl)

        assert variations == ["Van Bevanstraat", "van Bevanstraat"]

    def test_apply_transform(self):

        s = {"Prof. Lieflantlaan"}
        repl = {"Prof.": ["Prof.", "Professor"]}

        transform_config = {"transforms": {"prefix": repl}}
        variations = utils.apply_transform(s, transform_config)

        assert variations == {"Prof. Lieflantlaan", "Professor Lieflantlaan"}

    def test_apply_transform2(self):

        items = {"den Burg", "Rotterdam"}
        transform = {"transforms": {"name": {"den": ["den", ""]}}}

        transformed_items = utils.apply_transform(items, transform)

        assert transformed_items == {"den Burg", "Burg", "Rotterdam"}

    def test_apply_transform_no_strip_lines(self):

        items = {"den Burg", "Rotterdam"}
        transform = {"transforms": {"name": {"den": ["den", ""]}}, "strip_lines": False}

        transformed_items = utils.apply_transform(items, transform)

        assert transformed_items == {"den Burg", " Burg", "Rotterdam"}


class TestOptionalLoad:
    def test_optional_load_items(self):

        path = Path("tests/data/lookup/src/lst_test_nested/items.txt")

        assert utils.optional_load_items(path) == {"a", "b"}

    def test_optional_load_items_nonexisting(self):

        path = Path("tests/data/non/existing/file.txt")

        assert utils.optional_load_items(path) is None

    def test_optional_load_json(self):

        path = Path("tests/data/small.json")

        assert utils.optional_load_json(path) == {"test": True}

    def test_optional_load_json_nonexisting(self):

        path = Path("tests/data/non/existing/file.json")

        assert utils.optional_load_json(path) is None