# Generated by Snowball 2.0.0 - https://snowballstem.org/

from .basestemmer import BaseStemmer
from .among import Among


class GermanStemmer(BaseStemmer):
    '''
    This class implements the stemming algorithm defined by a snowball script.
    Generated by Snowball 2.0.0 - https://snowballstem.org/
    '''

    a_0 = [
        Among(u"", -1, 5),
        Among(u"U", 0, 2),
        Among(u"Y", 0, 1),
        Among(u"\u00E4", 0, 3),
        Among(u"\u00F6", 0, 4),
        Among(u"\u00FC", 0, 2)
    ]

    a_1 = [
        Among(u"e", -1, 2),
        Among(u"em", -1, 1),
        Among(u"en", -1, 2),
        Among(u"ern", -1, 1),
        Among(u"er", -1, 1),
        Among(u"s", -1, 3),
        Among(u"es", 5, 2)
    ]

    a_2 = [
        Among(u"en", -1, 1),
        Among(u"er", -1, 1),
        Among(u"st", -1, 2),
        Among(u"est", 2, 1)
    ]

    a_3 = [
        Among(u"ig", -1, 1),
        Among(u"lich", -1, 1)
    ]

    a_4 = [
        Among(u"end", -1, 1),
        Among(u"ig", -1, 2),
        Among(u"ung", -1, 1),
        Among(u"lich", -1, 3),
        Among(u"isch", -1, 2),
        Among(u"ik", -1, 2),
        Among(u"heit", -1, 3),
        Among(u"keit", -1, 4)
    ]

    g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32, 8]

    g_s_ending = [117, 30, 5]

    g_st_ending = [117, 30, 4]

    I_x = 0
    I_p2 = 0
    I_p1 = 0

    def __r_prelude(self):
        # (, line 33
        # test, line 35
        v_1 = self.cursor
        # repeat, line 35
        while True:
            v_2 = self.cursor
            try:
                # (, line 35
                # or, line 38
                try:
                    v_3 = self.cursor
                    try:
                        # (, line 36
                        # [, line 37
                        self.bra = self.cursor
                        # literal, line 37
                        if not self.eq_s(u"\u00DF"):
                            raise lab2()
                        # ], line 37
                        self.ket = self.cursor
                        # <-, line 37
                        if not self.slice_from(u"ss"):
                            return False
                        raise lab1()
                    except lab2: pass
                    self.cursor = v_3
                    # next, line 38
                    if self.cursor >= self.limit:
                        raise lab0()
                    self.cursor += 1
                except lab1: pass
                continue
            except lab0: pass
            self.cursor = v_2
            break
        self.cursor = v_1
        # repeat, line 41
        while True:
            v_4 = self.cursor
            try:
                # goto, line 41
                try:
                    while True:
                        v_5 = self.cursor
                        try:
                            # (, line 41
                            if not self.in_grouping(GermanStemmer.g_v, 97, 252):
                                raise lab5()
                            # [, line 42
                            self.bra = self.cursor
                            # or, line 42
                            try:
                                v_6 = self.cursor
                                try:
                                    # (, line 42
                                    # literal, line 42
                                    if not self.eq_s(u"u"):
                                        raise lab7()
                                    # ], line 42
                                    self.ket = self.cursor
                                    if not self.in_grouping(GermanStemmer.g_v, 97, 252):
                                        raise lab7()
                                    # <-, line 42
                                    if not self.slice_from(u"U"):
                                        return False
                                    raise lab6()
                                except lab7: pass
                                self.cursor = v_6
                                # (, line 43
                                # literal, line 43
                                if not self.eq_s(u"y"):
                                    raise lab5()
                                # ], line 43
                                self.ket = self.cursor
                                if not self.in_grouping(GermanStemmer.g_v, 97, 252):
                                    raise lab5()
                                # <-, line 43
                                if not self.slice_from(u"Y"):
                                    return False
                            except lab6: pass
                            self.cursor = v_5
                            raise lab4()
                        except lab5: pass
                        self.cursor = v_5
                        if self.cursor >= self.limit:
                            raise lab3()
                        self.cursor += 1
                except lab4: pass
                continue
            except lab3: pass
            self.cursor = v_4
            break
        return True

    def __r_mark_regions(self):
        # (, line 47
        self.I_p1 = self.limit
        self.I_p2 = self.limit
        # test, line 52
        v_1 = self.cursor
        # (, line 52
        # hop, line 52
        c = self.cursor + 3
        if 0 > c or c > self.limit:
            return False
        self.cursor = c
        # setmark x, line 52
        self.I_x = self.cursor
        self.cursor = v_1
        # gopast grouping v, line 54
        if not self.go_out_grouping(GermanStemmer.g_v, 97, 252):
            return False
        self.cursor += 1
        # gopast non v, line 54
        if not self.go_in_grouping(GermanStemmer.g_v, 97, 252):
            return False
        self.cursor += 1
        # setmark p1, line 54
        self.I_p1 = self.cursor
        # try, line 55
        try:
            # (, line 55
            if not self.I_p1 < self.I_x:
                raise lab0()
            self.I_p1 = self.I_x
        except lab0: pass
        # gopast grouping v, line 56
        if not self.go_out_grouping(GermanStemmer.g_v, 97, 252):
            return False
        self.cursor += 1
        # gopast non v, line 56
        if not self.go_in_grouping(GermanStemmer.g_v, 97, 252):
            return False
        self.cursor += 1
        # setmark p2, line 56
        self.I_p2 = self.cursor
        return True

    def __r_postlude(self):
        # repeat, line 60
        while True:
            v_1 = self.cursor
            try:
                # (, line 60
                # [, line 62
                self.bra = self.cursor
                # substring, line 62
                among_var = self.find_among(GermanStemmer.a_0)
                if among_var == 0:
                    raise lab0()
                # ], line 62
                self.ket = self.cursor
                if among_var == 1:
                    # (, line 63
                    # <-, line 63
                    if not self.slice_from(u"y"):
                        return False
                elif among_var == 2:
                    # (, line 64
                    # <-, line 64
                    if not self.slice_from(u"u"):
                        return False
                elif among_var == 3:
                    # (, line 65
                    # <-, line 65
                    if not self.slice_from(u"a"):
                        return False
                elif among_var == 4:
                    # (, line 66
                    # <-, line 66
                    if not self.slice_from(u"o"):
                        return False
                elif among_var == 5:
                    # (, line 68
                    # next, line 68
                    if self.cursor >= self.limit:
                        raise lab0()
                    self.cursor += 1
                continue
            except lab0: pass
            self.cursor = v_1
            break
        return True

    def __r_R1(self):
        if not self.I_p1 <= self.cursor:
            return False
        return True

    def __r_R2(self):
        if not self.I_p2 <= self.cursor:
            return False
        return True

    def __r_standard_suffix(self):
        # (, line 78
        # do, line 79
        v_1 = self.limit - self.cursor
        try:
            # (, line 79
            # [, line 80
            self.ket = self.cursor
            # substring, line 80
            among_var = self.find_among_b(GermanStemmer.a_1)
            if among_var == 0:
                raise lab0()
            # ], line 80
            self.bra = self.cursor
            # call R1, line 80
            if not self.__r_R1():
                raise lab0()
            if among_var == 1:
                # (, line 82
                # delete, line 82
                if not self.slice_del():
                    return False

            elif among_var == 2:
                # (, line 85
                # delete, line 85
                if not self.slice_del():
                    return False

                # try, line 86
                v_2 = self.limit - self.cursor
                try:
                    # (, line 86
                    # [, line 86
                    self.ket = self.cursor
                    # literal, line 86
                    if not self.eq_s_b(u"s"):
                        self.cursor = self.limit - v_2
                        raise lab1()
                    # ], line 86
                    self.bra = self.cursor
                    # literal, line 86
                    if not self.eq_s_b(u"nis"):
                        self.cursor = self.limit - v_2
                        raise lab1()
                    # delete, line 86
                    if not self.slice_del():
                        return False

                except lab1: pass
            elif among_var == 3:
                # (, line 89
                if not self.in_grouping_b(GermanStemmer.g_s_ending, 98, 116):
                    raise lab0()
                # delete, line 89
                if not self.slice_del():
                    return False

        except lab0: pass
        self.cursor = self.limit - v_1
        # do, line 93
        v_3 = self.limit - self.cursor
        try:
            # (, line 93
            # [, line 94
            self.ket = self.cursor
            # substring, line 94
            among_var = self.find_among_b(GermanStemmer.a_2)
            if among_var == 0:
                raise lab2()
            # ], line 94
            self.bra = self.cursor
            # call R1, line 94
            if not self.__r_R1():
                raise lab2()
            if among_var == 1:
                # (, line 96
                # delete, line 96
                if not self.slice_del():
                    return False

            elif among_var == 2:
                # (, line 99
                if not self.in_grouping_b(GermanStemmer.g_st_ending, 98, 116):
                    raise lab2()
                # hop, line 99
                c = self.cursor - 3
                if self.limit_backward > c or c > self.limit:
                    raise lab2()
                self.cursor = c
                # delete, line 99
                if not self.slice_del():
                    return False

        except lab2: pass
        self.cursor = self.limit - v_3
        # do, line 103
        v_4 = self.limit - self.cursor
        try:
            # (, line 103
            # [, line 104
            self.ket = self.cursor
            # substring, line 104
            among_var = self.find_among_b(GermanStemmer.a_4)
            if among_var == 0:
                raise lab3()
            # ], line 104
            self.bra = self.cursor
            # call R2, line 104
            if not self.__r_R2():
                raise lab3()
            if among_var == 1:
                # (, line 106
                # delete, line 106
                if not self.slice_del():
                    return False

                # try, line 107
                v_5 = self.limit - self.cursor
                try:
                    # (, line 107
                    # [, line 107
                    self.ket = self.cursor
                    # literal, line 107
                    if not self.eq_s_b(u"ig"):
                        self.cursor = self.limit - v_5
                        raise lab4()
                    # ], line 107
                    self.bra = self.cursor
                    # not, line 107
                    v_6 = self.limit - self.cursor
                    try:
                        # literal, line 107
                        if not self.eq_s_b(u"e"):
                            raise lab5()
                        self.cursor = self.limit - v_5
                        raise lab4()
                    except lab5: pass
                    self.cursor = self.limit - v_6
                    # call R2, line 107
                    if not self.__r_R2():
                        self.cursor = self.limit - v_5
                        raise lab4()
                    # delete, line 107
                    if not self.slice_del():
                        return False

                except lab4: pass
            elif among_var == 2:
                # (, line 110
                # not, line 110
                v_7 = self.limit - self.cursor
                try:
                    # literal, line 110
                    if not self.eq_s_b(u"e"):
                        raise lab6()
                    raise lab3()
                except lab6: pass
                self.cursor = self.limit - v_7
                # delete, line 110
                if not self.slice_del():
                    return False

            elif among_var == 3:
                # (, line 113
                # delete, line 113
                if not self.slice_del():
                    return False

                # try, line 114
                v_8 = self.limit - self.cursor
                try:
                    # (, line 114
                    # [, line 115
                    self.ket = self.cursor
                    # or, line 115
                    try:
                        v_9 = self.limit - self.cursor
                        try:
                            # literal, line 115
                            if not self.eq_s_b(u"er"):
                                raise lab9()
                            raise lab8()
                        except lab9: pass
                        self.cursor = self.limit - v_9
                        # literal, line 115
                        if not self.eq_s_b(u"en"):
                            self.cursor = self.limit - v_8
                            raise lab7()
                    except lab8: pass
                    # ], line 115
                    self.bra = self.cursor
                    # call R1, line 115
                    if not self.__r_R1():
                        self.cursor = self.limit - v_8
                        raise lab7()
                    # delete, line 115
                    if not self.slice_del():
                        return False

                except lab7: pass
            elif among_var == 4:
                # (, line 119
                # delete, line 119
                if not self.slice_del():
                    return False

                # try, line 120
                v_10 = self.limit - self.cursor
                try:
                    # (, line 120
                    # [, line 121
                    self.ket = self.cursor
                    # substring, line 121
                    if self.find_among_b(GermanStemmer.a_3) == 0:
                        self.cursor = self.limit - v_10
                        raise lab10()
                    # ], line 121
                    self.bra = self.cursor
                    # call R2, line 121
                    if not self.__r_R2():
                        self.cursor = self.limit - v_10
                        raise lab10()
                    # (, line 123
                    # delete, line 123
                    if not self.slice_del():
                        return False

                except lab10: pass
        except lab3: pass
        self.cursor = self.limit - v_4
        return True

    def _stem(self):
        # (, line 133
        # do, line 134
        v_1 = self.cursor
        # call prelude, line 134
        self.__r_prelude()
        self.cursor = v_1
        # do, line 135
        v_2 = self.cursor
        # call mark_regions, line 135
        self.__r_mark_regions()
        self.cursor = v_2
        # backwards, line 136
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # do, line 137
        # call standard_suffix, line 137
        self.__r_standard_suffix()
        self.cursor = self.limit_backward
        # do, line 138
        v_4 = self.cursor
        # call postlude, line 138
        self.__r_postlude()
        self.cursor = v_4
        return True


class lab0(BaseException): pass


class lab1(BaseException): pass


class lab2(BaseException): pass


class lab3(BaseException): pass


class lab4(BaseException): pass


class lab5(BaseException): pass


class lab6(BaseException): pass


class lab7(BaseException): pass


class lab8(BaseException): pass


class lab9(BaseException): pass


class lab10(BaseException): pass