import sys
import ast
import time
from itertools import zip_longest

class Polynomial:

    def __init__(self, coef_list):
        self.degree = len(coef_list) - 1
        self.coefficients = coef_list

    @staticmethod
    def add(p1, p2):
        result = []
        f = p1.coefficients
        g = p2.coefficients
        if len(f) >= len(g):
            result = f
            for i in range(0, len(g)):
                result[i] = f[i] + g[i]
        else:
            result = g
            for i in range(0, len(f)):
                result[i] = f[i] + g[i]
        result = [x % int(n) for x in result]        
        return Polynomial(result)             

    @staticmethod
    def multiply(p1, p2):
        result = [0] * (p1.degree + p2.degree + 1)
        f = p1.coefficients
        g = p2.coefficients
        for i in range(0, len(f)):
            for j in range(0, len(g)):
                result[i+j] += f[i] * g[j]
        result = [x % int(n) for x in result]
        return Polynomial(result)

    @staticmethod
    def divide(p1, p2):          
        def inverse(x):
            for i in range(1, int(n)):
                r = (i * x) % int(n)
                if r == 1:
                    break
            else:
                raise ZeroDivisionError
            return i       
        if p1.degree < p2.degree:
            return p1
        f = p1.coefficients
        g = p2.coefficients
        g_lead_coef = g[-1]
        g_deg = p2.degree
        while len(f) >= len(g):
            f_lead_coef = f[-1]
            tmp_coef = f_lead_coef * inverse(g_lead_coef)
            tmp_exp = len(f) - 1 - g_deg
            tmp = []
            for _ in range(tmp_exp):
                tmp.append(0)
            tmp.append(tmp_coef)
            tmp_poly = Polynomial(tmp)
            sub = Polynomial.multiply(p2, tmp_poly)
            f = [x - y for x, y in zip(f, sub.coefficients)]
            f = [x % int(n) for x in f]
            while f and f[-1] == 0:
                f.pop()
        return Polynomial(f)


n = 2


def normalize_byte(data):
    while len(data) != 8:
        if len(data) < 8:
            data = str(0) + data
        else:
            data.replace(data[0], '')
    return data


def encode(in_data):
    data = in_data
    data = list(data)
    data_binary = [bin(ord(char)).replace('b', '') for char in data]
    data_binary = [normalize_byte(byte) for byte in data_binary]
    data_binary = [int(bit) for bit in list(''.join(data_binary))]
    data_binary.reverse()

    M = [0] * 16 + data_binary
    L = [0] * (len(data_binary)) + [1] * 16
    G = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]
    FCS_poly = Polynomial.divide(Polynomial.add(Polynomial(M), Polynomial(L)), Polynomial(G))
    FCS = FCS_poly.coefficients + [0] * (16 - len(FCS_poly.coefficients))

    FCS.reverse()
    data_binary.reverse()
    data_binary = data_binary + FCS
    data_binary = [data_binary[i:i+8] for i in range(0, len(data_binary), 8)]
    data = [chr(int(''.join(map(str, byte)), 2)) for byte in data_binary]

    return ''.join(data)


def check_fcs(in_data):
    data = in_data
    data = list(data)
    data_binary = [bin(ord(char)).replace('b', '') for char in data]
    data_binary = [normalize_byte(byte) for byte in data_binary]
    data_binary = [int(bit) for bit in list(''.join(data_binary))]
    data_binary.reverse()

    C = [0] * 16 + data_binary
    L = [0] * len(data_binary) + [1] * 16
    G = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]
    S = Polynomial.divide(Polynomial.add(Polynomial(C), Polynomial(L)), Polynomial(G))

    if S.coefficients == []:
        return True

    return False


def main():
    try:
        if sys.argv[1] == '-e' or sys.argv[1] == '-encode':
            print(encode(sys.argv[2]))
        elif sys.argv[1] == '-c' or sys.argv[1] == '-check':
            print(check_fcs(sys.argv[2]))
        else:
            raise IndexError
    except IndexError:
        print("To encode: python3 CRC16.py -e [argument]\nTo check FCS: python3 CRC16.py -c [argument]")


if __name__ == "__main__":
    main()