# Linear Feedback Shift Register
class LFSR:
    def __init__(self, poly):
        self.g = []     # mapping von g g[x] == g_x
        self.reg = []   # Register mit dem Zustand

        for ziffer in poly:
            self.reg.append(0)
            self.g.append(int(ziffer))

        # poly = str(n, n-1, ..., 0) => g = [0, ..., n-1, n]
        self.g.reverse()
        self.reg.reverse()

        # Entferne den letzten Eintrag, da dieser den Grad darstellt => Anzahl der Register = len(g) - 1
        self.g.pop()
        self.reg.pop()


    def get_reg_as_string(self):
        reg_string = ""

        for i in self.reg:
            reg_string = reg_string + str(i)

        return reg_string

    def shift(self, s_i):
        reg_old = self.reg.copy()           # alter Zustand, um überschreibungen zu vermeiden

        feedback = reg_old[-1] ^ int(s_i)

        for i, value in enumerate(self.g):
            if i == 0:
                self.reg[i] = feedback
            else:
                if value == 1:
                    self.reg[i] = reg_old[i - 1] ^ feedback
                else:
                    self.reg[i] = reg_old[i - 1]


def CRC_Parity(daten, g):
    schiebe_reg = LFSR(g)

    for s in daten:
        schiebe_reg.shift(s)

    return schiebe_reg.get_reg_as_string()


def channel_bsc(p, n):
    F = 0b0
    '''
    berechne Fehlersequenz F
    Achte auf Bedingung
    '''
    return F


def p_k_Fehler(p):
    n = 1000


def main():