import os.path
from unittest import TestCase

from kpmatch import PatternParsingError
import kpmatch.matchers as m
import kpmatch.parse as p


def join_matchers(first: m.PathMatcher, *others: m.PathMatcher) -> m.PathMatcher:
    for matcher in others:
        first.append(matcher)
    return first


class ParseTests(TestCase):
    def test_parse_pattern(self):
        # pattern <- (any_segments / fixed_segment)*
        self.assertEqual(
            p._parse_pattern("?a[bc]/**/*.{def,ghi}"),
            join_matchers(
                m.AnyCharacter(),
                m.FixedName("a"),
                m.CharacterSet("bc", False),
                m.EndOfSegment(),
                m.AnySegments(),
                m.AnyName(),
                m.FixedName("."),
                m.OneOf((m.FixedName("def"), m.FixedName("ghi"))),
                m.EndOfSegment(),
                m.EndOfPath(),
            ),
        )

    def test_parse_any_segments(self):
        # any_segments <- "**" (SEP / EOS)
        self.assertTupleEqual(p._parse_any_segments("**", 0), (m.AnySegments(), 2))
        self.assertTupleEqual(p._parse_any_segments("**/a", 0), (m.AnySegments(), 3))
        self.assertTupleEqual(p._parse_any_segments("**a", 0), (None, 0))

    def test_parse_fixed_segment(self):
        # fixed_segment <- name_part+ (SEP / EOS)
        self.assertTupleEqual(
            p._parse_fixed_segment("?a[bc]/*.{def,ghi}", 0),
            (
                join_matchers(
                    m.AnyCharacter(),
                    m.FixedName("a"),
                    m.CharacterSet("bc", False),
                    m.EndOfSegment(),
                ),
                7,
            ),
        )
        self.assertTupleEqual(
            p._parse_fixed_segment("?a[bc]/*.{def,ghi}", 7),
            (
                join_matchers(
                    m.AnyName(),
                    m.FixedName("."),
                    m.OneOf((m.FixedName("def"), m.FixedName("ghi"))),
                    m.EndOfSegment(),
                ),
                18,
            ),
        )

    def test_parse_name_part(self):
        # name_part <- any_name / one_of / simple_name_part / ","
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 0), (m.AnyCharacter(), 1)
        )
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 1), (m.FixedName("a"), 2)
        )
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 2), (m.CharacterSet("bc", False), 6)
        )
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 6), (m.FixedName(","), 7)
        )
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 7), (m.AnyName(), 8)
        )
        self.assertTupleEqual(
            p._parse_name_part("?a[bc],*{def,ghi}", 8),
            (m.OneOf((m.FixedName("def"), m.FixedName("ghi"))), 17),
        )

    def test_parse_any_name(self):
        # any_name = "*"+
        self.assertTupleEqual(p._parse_any_name("*a", 0), (m.AnyName(), 1))
        self.assertTupleEqual(p._parse_any_name("a*", 1), (m.AnyName(), 2))
        self.assertTupleEqual(p._parse_any_name("a***a", 1), (m.AnyName(), 4))

    def test_parse_one_of(self):
        # one_of = "{" simple_name_part+ ("," simple_name_part+)* "}"
        self.assertTupleEqual(p._parse_one_of("", 0), (None, 0))
        self.assertTupleEqual(p._parse_one_of("abc,def}", 0), (None, 0))
        self.assertTupleEqual(p._parse_one_of("{abc,def", 0), (None, 0))
        self.assertTupleEqual(
            p._parse_one_of("{abc,def}", 0),
            (m.OneOf((m.FixedName("abc"), m.FixedName("def"))), 9),
        )
        self.assertTupleEqual(
            p._parse_one_of("{a[bc],d?f,ghi}", 0),
            (
                m.OneOf(
                    (
                        join_matchers(m.FixedName("a"), m.CharacterSet("bc", False)),
                        join_matchers(
                            m.FixedName("d"), m.AnyCharacter(), m.FixedName("f")
                        ),
                        m.FixedName("ghi"),
                    )
                ),
                15,
            ),
        )
        self.assertRaises(PatternParsingError, p._parse_one_of, "{abc{def}", 0)
        self.assertTupleEqual(
            p._parse_one_of("{abc{def}", 4), (m.OneOf((m.FixedName("def"),)), 9)
        )
        self.assertTupleEqual(
            p._parse_one_of("{abc}def}", 0), (m.OneOf((m.FixedName("abc"),)), 5)
        )
        self.assertTupleEqual(
            p._parse_one_of(os.path.join("{abc", "def}"), 0),
            (None, 0),
        )
        self.assertTupleEqual(p._parse_one_of("{,def", 0), (None, 0))
        self.assertRaises(PatternParsingError, p._parse_one_of, "{,def}", 0)

    def test_parse_one_of_choice(self):
        # one_of_choice = simple_name_part+
        self.assertTupleEqual(
            p._parse_one_of_choice("?a[bc],def", 0),
            (
                join_matchers(
                    m.AnyCharacter(), m.FixedName("a"), m.CharacterSet("bc", False)
                ),
                6,
            ),
        )

    def test_parse_simple_name_part(self):
        # simple_name_part = any_character / character_set / fixed_name
        self.assertTupleEqual(
            p._parse_simple_name_part("?a[bc]", 0), (m.AnyCharacter(), 1)
        )
        self.assertTupleEqual(
            p._parse_simple_name_part("?a[bc]", 1), (m.FixedName("a"), 2)
        )
        self.assertTupleEqual(
            p._parse_simple_name_part("?a[bc]", 2), (m.CharacterSet("bc", False), 6)
        )

    def test_parse_any_character(self):
        self.assertTupleEqual(p._parse_any_character("?a", 0), (m.AnyCharacter(), 1))
        self.assertTupleEqual(p._parse_any_character("a?", 1), (m.AnyCharacter(), 2))

    def test_parse_character_set(self):
        self.assertTupleEqual(p._parse_character_set("", 0), (None, 0))
        self.assertTupleEqual(p._parse_character_set("abc]", 0), (None, 0))
        self.assertTupleEqual(p._parse_character_set("[abc", 0), (None, 0))
        self.assertTupleEqual(
            p._parse_character_set("[abcdef]", 0), (m.CharacterSet("abcdef", False), 8)
        )
        self.assertTupleEqual(
            p._parse_character_set("[!abcdef]", 0), (m.CharacterSet("abcdef", True), 9)
        )
        self.assertTupleEqual(p._parse_character_set("[abcdef]", 3), (None, 3))
        self.assertRaises(PatternParsingError, p._parse_character_set, "[abc[def]", 0)
        self.assertTupleEqual(
            p._parse_character_set("[abc[def]", 4), (m.CharacterSet("def", False), 9)
        )
        self.assertRaises(PatternParsingError, p._parse_character_set, "[abc!def]", 0)
        self.assertTupleEqual(
            p._parse_character_set("[abc]def]", 0), (m.CharacterSet("abc", False), 5)
        )
        self.assertTupleEqual(
            p._parse_character_set(os.path.join("[abc", "def]"), 0),
            (None, 0),
        )

    def test_parse_fixed_name(self):
        self.assertTupleEqual(p._parse_fixed_name("", 0), (None, 0))
        self.assertTupleEqual(
            p._parse_fixed_name("abcdef", 0), (m.FixedName("abcdef"), 6)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abcdef", 2), (m.FixedName("cdef"), 6)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc[def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc!def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc]def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc{def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc,def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc}def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc*def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name("abc?def", 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name(os.path.join("abc", "def"), 0), (m.FixedName("abc"), 3)
        )
        self.assertTupleEqual(
            p._parse_fixed_name(os.path.join("abc", "def"), 2), (m.FixedName("c"), 3)
        )