import os.path
from unittest import TestCase

import kpmatch.matchers as m
import kpmatch.parse as p
from kpmatch.config import Config


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_expand_braces(self):
        cfg = Config()
        self.assertEqual(
            [
                "ab/**/*.def",
                "ab/ghi",
                "a?c/**/*.def",
                "a?c/ghi",
            ],
            p._expand_braces(cfg, "a{b,?c}/{**/*.def,ghi}"),
        )

    def test_parse_braces_notation(self):
        # braces_notation <- ( fixed_section (braced_section fixed_section)* )? EOS
        cfg = Config()
        self.assertEqual(p._parse_braces_notation(cfg, ""), [])
        self.assertEqual(
            p._parse_braces_notation(cfg, "a{b,?c}/{**/*.def,ghi}"),
            [["a"], ["b", "?c"], ["/"], ["**/*.def", "ghi"]],
        )

    def test_parse_braced_section(self):
        # braced_section = "{" braces_alternative ("," braces_alternative)* "}"
        self.assertTupleEqual(
            p._parse_braced_section("{abc,def}", 0), (["abc", "def"], 9)
        )
        self.assertTupleEqual(p._parse_braced_section("{abc}", 0), (["abc"], 5))
        self.assertTupleEqual(
            p._parse_braced_section("{a,b,c,}", 0), (["a", "b", "c", ""], 8)
        )
        self.assertRaises(p.PatternParsingError, p._parse_braced_section, "abc,def}", 0)
        self.assertRaises(p.PatternParsingError, p._parse_braced_section, "{abc,def", 0)
        self.assertRaises(
            p.PatternParsingError, p._parse_braced_section, "{abc{def}", 0
        )

    def test_parse_braces_alternative(self):
        # braces_alternative <- (!("{" / "," / "}") .)+
        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 0), ("ab", 2))
        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 3), ("c", 4))
        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 5), ("d", 6))

    def test_parse_fixed_section(self):
        # fixed_section <- (!("{" / "}") .)+
        self.assertTupleEqual(p._parse_fixed_section("", 0), ("", 0))
        self.assertTupleEqual(p._parse_fixed_section("ab{c,d}", 0), ("ab", 2))
        self.assertRaises(p.PatternParsingError, p._parse_fixed_section, "c,d}", 0)

    def test_parse_pattern(self):
        cfg = Config()
        # pattern <- (any_segments / fixed_segment)*
        self.assertEqual(
            p._parse_pattern(cfg, "?a[bc]/**/*.def"),
            join_matchers(
                m.AnyCharacter(),
                m.FixedName("a"),
                m.CharacterSet("bc", False),
                m.EndOfSegment(),
                m.AnySegments(),
                m.AnyName(),
                m.FixedName("."),
                m.FixedName("def"),
                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", 0),
            (
                join_matchers(
                    m.AnyCharacter(),
                    m.FixedName("a"),
                    m.CharacterSet("bc", False),
                    m.EndOfSegment(),
                ),
                7,
            ),
        )
        self.assertTupleEqual(
            p._parse_fixed_segment("?a[bc]/*.def", 7),
            (
                join_matchers(
                    m.AnyName(),
                    m.FixedName(".def"),
                    m.EndOfSegment(),
                ),
                12,
            ),
        )

    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", 8),
            (m.FixedName("def"), 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_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(p.PatternParsingError, p._parse_character_set, "[abc[def]", 0)
        self.assertTupleEqual(
            p._parse_character_set("[abc[def]", 4), (m.CharacterSet("def", False), 9)
        )
        self.assertRaises(p.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)
        )