import random
import commpy.channelcoding as cc
import numpy as np
import reedsolo as rs
import cv2
from matplotlib import pyplot as plt


def generate(n):
    code = [random.randint(0, 1) for i in range(n)]
    return code


def set_of_bites_to_list_of_bits(data):  # '100..0' = '1','0','0', ... '0',  set of 8bits as individual bit
    list = []
    for i in range(len(data)):
        for j in str(data[i]):
         list.append(int(j))

    return list


def list_of_bits_to_set_of_bits(data):  # '1','0','0', ... '0' = '100..0'  join bits as set of 8
    list = []
    for i in range(0, int(len(data) / 8)):
        string = ""
        for j in range(0, 8):
            string = string + str(data[i*8 + j])
        list.append(format(int(string, 2), '08b'))
    return list


def bsc(list, p):
    random.seed(9000)
    bsc_list = []
    for i in range(0, len(list)):
        string = ""
        list_sep = set_of_bites_to_list_of_bits(list[i])
        for j in range(0, 8):
            if (random.randint(0, 100) <= p * 100):
                if (list_sep[j] == 0):
                    string = string + "1"
                else:
                    string = string + "0"
            else:
                string = string + str(list_sep[j])
        bsc_list.append(format(int(string, 2), '08b'))
    return bsc_list


def coder(list):  # 0 = 000, 1 = 111
    code = []
    for i in range(0, len(list)):
        if (list[i] == 0):
            code.append(0)
            code.append(0)
            code.append(0)
        else:
            code.append(1)
            code.append(1)
            code.append(1)
    return code;


def decoder(list):  # 001 = 0, 101 = 1...
    code = []
    count = 0
    for i in range(0, len(list) + 1):
        if (i % 3 == 0 and i != 0):
            if (count > 1):
                code.append(0)
            else:
                code.append(1)
            count = 0
        if (i < len(list) and list[i] == 0):
            count += 1
    return code


def change_int(int):  # 0 = 1, 1 = 0
    return 1 if int == 0 else 0


def gilbert(list, good, bad):
    random.seed(9000)
    code = []
    flag_good = True
    for i in range(0, len(list)):
        if (flag_good):
            if (random.randint(0, 99) > good * 100):
                code.append(change_int(list[i]))
                flag_good = False
            else:
                code.append(list[i])
        else:
            if (random.randint(0, 99) < bad * 100):
                code.append(change_int(list[i]))
            else:
                code.append(list[i])
                flag_good = True


    return code

def read(path):  # read img
    with open(path, "rb") as imageFile:
        file = imageFile.read()
        bytes = bytearray(file)
    return bytes


def byte_to_bit(data):  # data - list of bytes (0 : 255), 5 = 00000101, byte into 8 bits long
    new_data = []
    for i in range(0, len(data)):
        new_data.append(format(data[i], '08b'))
    return new_data


def bit_to_byte(data):  # data - list of numbers 8 bits long, 00000101 = 5
    new_data = []
    for i in range(0, len(data)):
        new_data.append(int(str(data[i]), 2))
    return new_data


def save(data, name):  # data - list of bytes(0 : 255), save as img
    f = open(name+".bmp", "wb")
    f.write(bytearray(data))

    f.close()

def diff(data1, data2):
    counter = 0
    for i in range(0, len(data1)):
        if(data1[i] != data2[i]):
            counter = counter + 1
    return counter

# def diff(data1, data2, code_name):
#     # tmr, hamming, interleave, viterbieg, turbocodes, LDPC, RS
#     counter = 0
#     for i in range(0, len(data1)):
#         if(data1[i] != data2[i]):
#             counter += 1
#     print(code_name + " Error counter: " + str(counter))

def przeplot(string_bits):
 wynik = []
 for i in range(int(len(string_bits)/8)):
  for k in range(8):
   wynik.append(string_bits[int(len(string_bits)/8)*k+i])
 return wynik

def rozplot(string_bits):
 wynik = []
 for i in range(8):
  for k in range(int(len(string_bits)/8)):
   wynik.append(string_bits[i+8*k])
 return wynik



class Hamming:
    G = np.array([[1, 1, 0, 1], [1, 0, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
    H = np.array([[1, 0, 1, 0, 1, 0, 1], [0, 1, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 1]])
    H = H.transpose()
    list_of_data = [0, 0, 0, 0]   #i1, i2, i3, i4     wyznaczamy w ktorym miejscu sa bity, ktore zawieraja dane
    diff = 0
    for i in range(0, len(G)):
        count = 0
        for j in range(0, len(G[i])):
            if(G[i][j] == 1):
                count = count + 1
        if(count == 1):
            for j in range(0, len(G[i])):
                if (G[i][j] == 1):
                    list_of_data[j] = i

    def code(temp_data):
     data = []
     for i in range(0, len(temp_data)):
      for j in range(0, len(temp_data[i])):
             data.append(int(temp_data[i][j]))
     list = []
     length = int(len(data)/4)
     for i in range(0, length*4, 4):                                   # dzielimy dane na macierze po 4 bity
         fragment = np.array([data[i], data[i+1], data[i+2], data[i+3]])
         list.append(fragment)
     Hamming.diff = len(data) - length*4
     if(Hamming.diff != 0):                                                   # przypadek, kiedy ilosc bitow nie dzieli sie
         temp_data = []
         temp_diff = Hamming.diff                                              # przez 4 bez reszty,
         for i in range(length * 4, length * 4 + 4):                  # brakujace bity wypelniamy zerami
             if(temp_diff > 0):
                 temp_diff = temp_diff - 1
                 temp_data.append(data[i])
             else:
                 temp_data.append(0)
         fragment = np.array([temp_data[0], temp_data[1], temp_data[2], temp_data[3]])
         list.append(fragment)
                                                             # list zawiera teraz liste macierze o wymiarach 4x1 (czyli wektor)
     for i in range(0, len(list)):
      list[i] = list[i].dot(Hamming.G.transpose())                          # przemnazamy kazda macierz 4x1 z macierza G
      for j in range(0, len(list[i])):
          list[i][j] = list[i][j] % 2                           # od razu sprawdzamy parzystosc
     temp_list = []
     for i in range(0, len(list)):
         for j in range(0, len(list[i])):
             temp_list.append(list[i][j])
     return temp_list


    def decode(temp_list):
     list = []
     for i in range(0, len(temp_list)):
        for j in range(0, len(temp_list[i])):
                list.append(int(temp_list[i][j]))
     data = []
     for i in range(0, len(list), 7):
         data.append(np.array([list[i], list[i+1], list[i+2], list[i+3], list[i+4], list[i+5], list[i+6]]))
     sindrom = []
     sindrom_num = []
     for i in range(0, len(data)):
      string = ""
      sindrom.append(data[i].dot(Hamming.H))
      for j in range(0, len(sindrom[i])):
          sindrom[i][j] = sindrom[i][j] % 2
          string = string + str(sindrom[i][j])
      sindrom_num.append(int(string[::-1], 2))                  # wykrywamy blad

     for i in range(0, len(data)):
         if(sindrom_num[i] != 0):
             if(data[i][sindrom_num[i] - 1] == 0):               # naprawiamy
                 data[i][sindrom_num[i] - 1] = 1;
             else:
                 data[i][sindrom_num[i] - 1] = 0;
                                                                # data zawiera poprawiony kod(7 bit)
     temp_data = []
     for i in range(0, len(data)):
         temp_data.append(np.array([data[i][Hamming.list_of_data[0]],data[i][Hamming.list_of_data[1]],data[i][Hamming.list_of_data[2]],data[i][Hamming.list_of_data[3]]]))
                                                        # temp_data zawiera dane bez bitow pomocniczych
     list = []
     if(Hamming.diff != 0):
         for i in range(0, len(temp_data) - 1):
             for j in range(0, len(temp_data[i])):
                 list.append(temp_data[i][j])
         for i in range(0, Hamming.diff):
          list.append(temp_data[len(temp_data)-1][i])
     else:
         for i in range(0, len(temp_data)):
             for j in range(0, len(temp_data[i])):
                 list.append(temp_data[i][j])
     return list

def main_menu(data):
    checker = 0
    while(checker!='9'):
        print("1. Test TMR ")
        print("2. Test Hamming")
        print("3. Test Interleave")
        print("4. Test RS")
        print("5. Test Turbocode")
        print("6. Test LDPC")
        print("8. Clear console")
        print("9. Quit")
        checker = input("\\>")
        if (checker == '1'):
            test_tmr(data)
        if(checker == '2'):
            test_hamming(data)
        if(checker == '3'):
            test_interleave(data)
        if(checker == '4'):
            test_RS(data)
        if(checker == '5'):
            test_turbocode(data)
        if(checker == '6'):
            test_LDPC(data)
        if(checker == '7'):
            test_BCH(data)
        if(checker == '8'):
            print(chr(27) + "[2J") #clear console

def test_tmr(data):
    tmr_data = coder(set_of_bites_to_list_of_bits(data))
    gilbert_good = float(input("Gilbert_good : "))
    gilbert_bad = float(input("Gilbert_bad : "))
    bsc_p = float(input("BSC_probability : "))

    pure_data_gilbert = gilbert(set_of_bites_to_list_of_bits(data),gilbert_good, gilbert_bad)
    pure_data_bsc = bsc(data, bsc_p)

    tmr_gilbert = gilbert(tmr_data, gilbert_good, gilbert_bad)
    tmr_gilbert_decoded = decoder(tmr_gilbert)

    tmr_bsc = bsc(list_of_bits_to_set_of_bits(tmr_data), bsc_p)
    tmr_bsc_decoded = decoder(set_of_bites_to_list_of_bits(tmr_bsc))

    print("\nPure data, bsc errors : " + str(diff(data, pure_data_bsc)))
    print("Pure data, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(pure_data_gilbert))))
    print("TMR, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(tmr_gilbert_decoded))))
    print("TMR, bsc errors: " + str(diff(data, list_of_bits_to_set_of_bits(tmr_bsc_decoded))) + "\n")

    bytes_pure = bit_to_byte(header + data)
    bytes_pure_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(pure_data_gilbert))
    bytes_pure_bsc = bit_to_byte(header + pure_data_bsc)
    bytes_tmr_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(tmr_gilbert_decoded))
    bytes_tmr_bsc = bit_to_byte(header + list_of_bits_to_set_of_bits(tmr_bsc_decoded))

    save(bytes_pure, "pure")
    save(bytes_pure_gilbert, "pure_gilbert")
    save(bytes_pure_bsc, "pure_bsc")
    save(bytes_tmr_gilbert, "tmr_gilbert")
    save(bytes_tmr_bsc, "tmr_bsc")

    pure = cv2.imread('pure.bmp')
    pure_gilbert = cv2.imread('pure_gilbert.bmp')
    pure_bsc = cv2.imread('pure_bsc.bmp')
    tmr_gilbert = cv2.imread('tmr_gilbert.bmp')
    tmr_bsc = cv2.imread('tmr_bsc.bmp')

    plt.subplot(321),plt.imshow(pure),plt.title('pure')
    plt.subplot(323),plt.imshow(pure_gilbert),plt.title('pure_gilbert')
    plt.subplot(324),plt.imshow(pure_bsc),plt.title('pure_bsc')
    plt.subplot(325),plt.imshow(tmr_gilbert),plt.title('tmr_gilbert')
    plt.subplot(326),plt.imshow(tmr_bsc),plt.title('tmr_bsc')
    plt.tight_layout()
    plt.show()


def test_hamming(data):
    Hamming_encode_data_part = Hamming.code(data)
    gilbert_good = float(input("Gilbert_good : "))
    gilbert_bad = float(input("Gilbert_bad : "))
    bsc_p = float(input("BSC_probability : "))

    pure_data_gilbert = gilbert(set_of_bites_to_list_of_bits(data),gilbert_good, gilbert_bad)
    pure_data_bsc = bsc(data, bsc_p)

    Hamming_gilbert = gilbert(Hamming_encode_data_part, gilbert_good, gilbert_bad)
    Hamming_gilbert_decoded = list_of_bits_to_set_of_bits(Hamming.decode(list_of_bits_to_set_of_bits(Hamming_gilbert)))

    Hamming_bsc = bsc(list_of_bits_to_set_of_bits(Hamming_encode_data_part), bsc_p)
    Hamming_bsc_decoded = list_of_bits_to_set_of_bits(Hamming.decode(Hamming_bsc))

    print("\nPure data, bsc errors : " + str(diff(data, pure_data_bsc)))
    print("Pure data, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(pure_data_gilbert))))
    print("Hamming, gilbert errors: " + str(diff(data, Hamming_bsc_decoded)))
    print("Hamming, bsc errors: " + str(diff(data, Hamming_gilbert_decoded)) + "\n")

    bytes_pure = bit_to_byte(header + data)
    bytes_pure_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(pure_data_gilbert))
    bytes_pure_bsc = bit_to_byte(header + pure_data_bsc)
    bytes_Hamming_gilbert = bit_to_byte(header + Hamming_gilbert_decoded)
    bytes_Hamming_bsc = bit_to_byte(header + Hamming_bsc_decoded)

    save(bytes_pure, "pure")
    save(bytes_pure_gilbert, "pure_gilbert")
    save(bytes_pure_bsc, "pure_bsc")
    save(bytes_Hamming_gilbert, "Hamming_gilbert")
    save(bytes_Hamming_bsc, "Hamming_bsc")

    pure = cv2.imread('pure.bmp')
    pure_gilbert = cv2.imread('pure_gilbert.bmp')
    pure_bsc = cv2.imread('pure_bsc.bmp')
    Hamming_gilbert = cv2.imread('Hamming_gilbert.bmp')
    Hamming_bsc = cv2.imread('Hamming_bsc.bmp')

    plt.subplot(321),plt.imshow(pure),plt.title('pure')
    plt.subplot(323),plt.imshow(pure_gilbert),plt.title('pure_gilbert')
    plt.subplot(324),plt.imshow(pure_bsc),plt.title('pure_bsc')
    plt.subplot(325),plt.imshow(Hamming_gilbert),plt.title('Hamming_gilbert')
    plt.subplot(326),plt.imshow(Hamming_bsc),plt.title('Hamming_bsc')
    plt.tight_layout()
    plt.show()


def test_interleave(data):
    gilbert_good = float(input("Gilbert_good : "))
    gilbert_bad = float(input("Gilbert_bad : "))
    bsc_p = float(input("BSC_probability : "))

    pure_data_gilbert = gilbert(set_of_bites_to_list_of_bits(data),gilbert_good, gilbert_bad)
    pure_data_bsc = bsc(data, bsc_p)

    Hamming_encode_data_part = Hamming.code(data)
    interleaved_data = przeplot(Hamming_encode_data_part)

    deinterleaved_data_gilbert = rozplot(gilbert(interleaved_data, gilbert_good, gilbert_bad))
    hamm_deinterleaved_data_gilbert = list_of_bits_to_set_of_bits(Hamming.decode(list_of_bits_to_set_of_bits(deinterleaved_data_gilbert)))

    deinterleaved_data_bsc = rozplot(set_of_bites_to_list_of_bits(bsc(list_of_bits_to_set_of_bits(interleaved_data), bsc_p)))
    hamm_deinterleaved_data_bsc = Hamming.decode(list_of_bits_to_set_of_bits(deinterleaved_data_bsc))

    print("\nPure data, bsc errors : " + str(diff(data, pure_data_bsc)))
    print("Pure data, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(pure_data_gilbert))))
    print("Interleave, gilbert errors: " + str(diff(data, hamm_deinterleaved_data_gilbert)))
    print("Interleave, bsc errors: " + str(diff(data, list_of_bits_to_set_of_bits(hamm_deinterleaved_data_bsc))) + "\n")

    bytes_pure = bit_to_byte(header + data)
    bytes_pure_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(pure_data_gilbert))
    bytes_pure_bsc = bit_to_byte(header + pure_data_bsc)
    bytes_Interleave_gilbert = bit_to_byte(header + hamm_deinterleaved_data_gilbert)
    bytes_Interleave_bsc = bit_to_byte(header + list_of_bits_to_set_of_bits(hamm_deinterleaved_data_bsc))

    save(bytes_pure, "pure")
    save(bytes_pure_gilbert, "pure_gilbert")
    save(bytes_pure_bsc, "pure_bsc")
    save(bytes_Interleave_gilbert, "Interleave_gilbert")
    save(bytes_Interleave_bsc, "Interleave_bsc")

    pure = cv2.imread('pure.bmp')
    pure_gilbert = cv2.imread('pure_gilbert.bmp')
    pure_bsc = cv2.imread('pure_bsc.bmp')
    Interleave_gilbert = cv2.imread('Interleave_gilbert.bmp')
    Interleave_bsc = cv2.imread('Interleave_bsc.bmp')

    plt.subplot(321),plt.imshow(pure),plt.title('pure')
    plt.subplot(323),plt.imshow(pure_gilbert),plt.title('pure_gilbert')
    plt.subplot(324),plt.imshow(pure_bsc),plt.title('pure_bsc')
    plt.subplot(325),plt.imshow(Interleave_gilbert),plt.title('Interleave_gilbert')
    plt.subplot(326),plt.imshow(Interleave_bsc),plt.title('Interleave_bsc')
    plt.tight_layout()
    plt.show()



def test_RS(data):
    gilbert_good = float(input("Gilbert_good : "))
    gilbert_bad = float(input("Gilbert_bad : "))
    bsc_p = float(input("BSC_probability : "))

    pure_data_gilbert = gilbert(set_of_bites_to_list_of_bits(data),gilbert_good, gilbert_bad)
    pure_data_bsc = bsc(data, bsc_p)

    rs_class = rs.RSCodec(10)
    rs_enocoded_data = rs_class.encode(set_of_bites_to_list_of_bits(data))
    rs_gilbert_data = gilbert(rs_enocoded_data, gilbert_good, gilbert_bad)


    try:
        rs_gilbert_decoded = rs_class.decode(rs_gilbert_data)
        bytes_rs_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(rs_gilbert_decoded))
        save(bytes_rs_gilbert, "rs_gilbert")
        rs_gilbert = cv2.imread('rs_gilbert.bmp')
        plt.subplot(325),plt.imshow(rs_gilbert),plt.title('rs_gilbert')
        print("\nRS, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(rs_gilbert_decoded))))
    except:
        print("rs_gilbert: too much incorrect data! Can't decode")
        rs_gilbert_decoded = 0

#    try:
#        rs_bsc_decoded = rs_class.decode(rs_bsc_data)
#        bytes_rs_bsc = bit_to_byte(header + list_of_bits_to_set_of_bits(rs_bsc_decoded))
#        save(bytes_rs_bsc, "rs_bsc")
#        rs_bsc = cv2.imread('rs_bsc.bmp')
#        plt.subplot(325),plt.imshow(rs_bsc),plt.title('rs_bsc')
#        print("\nRS, bsc errors: " + str(diff(data, list_of_bits_to_set_of_bits(rs_gilbert_decoded))))
#    except:
#        print("rs_bsc: too much incorrect data! Can't decode")
#        rs_bsc_decoded = 0

    print("Pure data, bsc errors : " + str(diff(data, pure_data_bsc)))
    print("Pure data, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(pure_data_gilbert))))

    bytes_pure = bit_to_byte(header + data)
    bytes_pure_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(pure_data_gilbert))
    bytes_pure_bsc = bit_to_byte(header + pure_data_bsc)

    save(bytes_pure, "pure")
    save(bytes_pure_gilbert, "pure_gilbert")
    save(bytes_pure_bsc, "pure_bsc")

    pure = cv2.imread('pure.bmp')
    pure_gilbert = cv2.imread('pure_gilbert.bmp')
    pure_bsc = cv2.imread('pure_bsc.bmp')

    plt.subplot(321),plt.imshow(pure),plt.title('pure')
    plt.subplot(323),plt.imshow(pure_gilbert),plt.title('pure_gilbert')
    plt.subplot(324),plt.imshow(pure_bsc),plt.title('pure_bsc')
    plt.tight_layout()
    plt.show()

def test_turbocode(data):
    gilbert_good = float(input("Gilbert_good : "))
    gilbert_bad = float(input("Gilbert_bad : "))
    bsc_p = float(input("BSC_probability : "))

    pure_data_gilbert = gilbert(set_of_bites_to_list_of_bits(data),gilbert_good, gilbert_bad)
    pure_data_bsc = bsc(data, bsc_p)

    memory = np.array([2])
    g_matrix = np.array([[50, 40]])
    h_matrix = np.array([[10, 10]])
    interleaver = cc.RandInterlv(20, 100)
    Trellis1 = cc.Trellis(memory, g_matrix)
    Trellis2 = cc.Trellis(memory, h_matrix)

    turbo_encode_data = cc.turbo_encode(set_of_bites_to_list_of_bits(data), Trellis1, Trellis2, interleaver)

    turbo_gilbert = gilbert(turbo_encode_data, gilbert_good, gilbert_bad)

    turbo_bsc = bsc(list_of_bits_to_set_of_bits(turbo_encode_data), bsc_p)

    turbo_decode_gilbert = cc.turbo_decode(sys_symbols, non_sys_symbols_1, non_sys_symbols_2, trellis, noise_variance, number_iterations, interleaver)
    turbo_decode_bsc = cc.turbo(sys_symbols, non_sys_symbols_1, non_sys_symbols_2, trellis, noise_variance, number_iterations, interleaver)

    print("\nPure data, bsc errors : " + str(diff(data, pure_data_bsc)))
    print("Pure data, gilbert errors: " + str(diff(data, list_of_bits_to_set_of_bits(pure_data_gilbert))))
    print("Turbo, gilbert errors: " + str(diff(data, turbo_gilbert)))
    print("Turbo, bsc errors: " + str(diff(data, list_of_bits_to_set_of_bits(turbo_bsc))) + "\n")

    bytes_pure = bit_to_byte(header + data)
    bytes_pure_gilbert = bit_to_byte(header + list_of_bits_to_set_of_bits(pure_data_gilbert))
    bytes_pure_bsc = bit_to_byte(header + pure_data_bsc)
    bytes_turbo_gilbert = bit_to_byte(header + turbo_gilbert)
    bytes_turbo_bsc = bit_to_byte(header + list_of_bits_to_set_of_bits(turbo_bsc))

    save(bytes_pure, "pure")
    save(bytes_pure_gilbert, "pure_gilbert")
    save(bytes_pure_bsc, "pure_bsc")
    save(bytes_turbo_gilbert, "turbo_gilbert")
    save(bytes_turbo_bsc, "turbo_bsc")

    pure = cv2.imread('pure.bmp')
    pure_gilbert = cv2.imread('pure_gilbert.bmp')
    pure_bsc = cv2.imread('pure_bsc.bmp')
    turbo_gilbert = cv2.imread('turbo_gilbert.bmp')
    turbo_bsc = cv2.imread('turbo_bsc.bmp')

    plt.subplot(321),plt.imshow(pure),plt.title('pure')
    plt.subplot(323),plt.imshow(pure_gilbert),plt.title('pure_gilbert')
    plt.subplot(324),plt.imshow(pure_bsc),plt.title('pure_bsc')
    plt.subplot(325),plt.imshow(turbo_gilbert),plt.title('turbo_gilbert')
    plt.subplot(326),plt.imshow(turbo_bsc),plt.title('turbo_bsc')
    plt.tight_layout()
    plt.show()



def test_LDPC(data):
    print()
    #todo

def test_convolutional_codes(data):
    print()
    #todo

def int_to_string_list(data):
    str_data= []
    for i in data:
        str_data.append(str(i))
    return str_data

bytes = read("test4.bmp")
bits = byte_to_bit(bytes)
header = []
data_part = []
for i in range(0, len(bits)):
     if(i < 50):
      header.append(bits[i])
     else:
      data_part.append(bits[i])
del bytes[:]
data_list = set_of_bites_to_list_of_bits(data_part)

main_menu(data_part)


# turbocode_encoded_data = cc.turbo_encode(data_list,'','','')
# turbocode_gilbert_data_part = gilbert(turbocode_encoded_data, .99, .7)
# turbocode_decoded_data = cc.turbo_decode(turbocode_gilbert_data_part)
# turbocode_bits = header + list_of_bits_to_set_of_bits(turbocode_decoded_data)
# new_turbocode = bit_to_byte(turbocode_bits)
# save(new_turbocode, "turbocode")



# gilbert_data_part = gilbert(data_list, 0.98, .7)
# turbocode_encoded_data = cc.turbo_encode(data_list)
# turbocode_gilbert_data_part = gilbert(rs_enocoded_data, .99, .7)
# turbocode_decoded_data = cc.turbo_decode(turbocode_gilbert_data_part)
# turbocode_bits = header + list_of_bits_to_set_of_bits(turbocode_decoded_data)
# new_turbocode = bit_to_byte(turbocode_bits)
# save(new_rs, "turbocode")

# print(diff(gilbert_data_part, data_list))

# Hamming_encode_data_part = Hamming.code(data_part)
#
# interleaved_data = przeplot(Hamming_encode_data_part)
#
# deinterleaved_data = rozplot(gilbert(interleaved_data, .99, .7))
# hamm_deinterleaved_data = Hamming.decode(list_of_bits_to_set_of_bits(deinterleaved_data))    ### !!!
# # print(diff(hamm_deinterleaved_data, data_list))
# bits_interleaving = header + list_of_bits_to_set_of_bits(hamm_deinterleaved_data)
# bits_gilbert = header + list_of_bits_to_set_of_bits(gilbert_data_part)
# new_hamming = bit_to_byte(bits_interleaving)
# new_gilbert = bit_to_byte(bits_gilbert)
#
# save(new_gilbert, "gilbert_without_Hamming")
# save(new_hamming, "gilbert_with_Hamming")
#
# # print(str(hamm_deinterleaved_data))
#
#
#
# bsc_data_part = bsc(data_part, 0.01)
# Hamming_encode_data_part = Hamming.code(data_part)
# bsc_Hamming = bsc(list_of_bits_to_set_of_bits(Hamming_encode_data_part), 0.01)
# print((str(bsc_Hamming)))
# decoded_bsc_Hamming = list_of_bits_to_set_of_bits(Hamming.decode(bsc_Hamming))
#
# bits_bsc = header + bsc_data_part
# bits_bsc_Hamming = header + decoded_bsc_Hamming
# print(diff(data_part, bsc_data_part))
# print(diff(data_part, decoded_bsc_Hamming))
# new_bytes_bsc = bit_to_byte(bits_bsc)
# new_bytes_Hamming = bit_to_byte(bits_bsc_Hamming)
# save(new_bytes_bsc, "bsc_without_Hamming")
# save(new_bytes_Hamming, "bsc_with_Hamming")