import java.util.Arrays;
import java.util.BitSet;
import java.util.InputMismatchException;
import java.util.Random;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

import acm.program.ConsoleProgram;

//import acm.program.ConsoleProgram;
// (16,7) 9,8,1,0  czyli czesc informacyjna
public class kodowanie extends ConsoleProgram {

    private static final long serialVersionUID = 1L;
    public String choice_s;
    static int choice_i = 0;
    int d = 1000, t, l;
    // long wielomian_generujacy;
    // long dzielna_l;
    // long jebany_szajs_wcie;
    // String zakodowany_string;
    String binary;
    private Scanner input;// to nam pilnuje czy bzdur nie wklepujemy
    String stringset;// to jest nasze zakodowane slowo
    String wielomian_generujacy_s = "11000000011";
    // long modulo[];
    BitSet bsh[]; // macierz kontrolna h transponowana
    BitSet bs[]; // macierz generujaca
    BitSet reszta[];
    long macierz_generujaca[];
    int bin_l = 8;
    int dlugosc_n = bin_l + wielomian_generujacy_s.length() - 1;

    public void run() {
        setSize(800, 600);
        // dzielna_l = 0;
        // String binary_l_f = "";
        // String cz_info=readLine("podaj informacje");

        ArrayList<String> tablica_ascii = new ArrayList<>();// do tego potrzebna
                                                            // jest jre 1.7
        String filename = "tablica_ascii.txt";
        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = br.readLine()) != null)
                tablica_ascii.add(line);

        } catch (IOException e) {
            println("nie ma takiego pliku");
        }

        HashMap<String, String> mapa_ascii = new HashMap<String, String>();

        for (String konkretny_znak : tablica_ascii) {
            int i = konkretny_znak.lastIndexOf(",");
            String bin = konkretny_znak.substring(0, i).trim();
            String znak = konkretny_znak.substring(i + 1);
            mapa_ascii.put(znak, bin);

        }

        // String binary = readLine("podaj ciag dlugosci 7: ");

        macierz_generujaca = new long[bin_l];

        // tu na stale mamy podany nasz

        long dzielna = (long) java.lang.Math.pow(2,
                wielomian_generujacy_s.length() - 1);// 0b10000000000;
        long dzielnik = Long.parseLong(wielomian_generujacy_s, 2);// 0b11000000011;
        // zwraca dlugosc ciagu binary
        int dlugosc_n = wielomian_generujacy_s.length() + bin_l - 1;// zwraca
                                                                    // dlugosc
                                                                    // calego
                                                                    // ciagu
        int j = bin_l;

        bs = new BitSet[bin_l];// macierz generujaca
        reszta = new BitSet[wielomian_generujacy_s.length()]; // reszta z
                                                                // dzielenia
                                                                // (nie pamietam
                                                                // zmiennej
        BitSet bsf = BitSet.valueOf(new long[] { 0 });// koncowy wynik
        for (int i = bin_l - 1; i >= 0; i--) {
            bs[i] = BitSet.valueOf(new long[] { (long) java.lang.Math.pow(2,
                    dlugosc_n - j) });
            BitSet bs1 = BitSet.valueOf(new long[] { dzielna });
            BitSet bs2 = BitSet.valueOf(new long[] { dzielnik });
            bs1.xor(bs2);
            reszta[i] = bs1;
            bs[i].xor(bs1);

            dzielna = (int) bitSetToInt(bs1);
            dzielna *= 2;
            j--;

        }
        while (true) {
            boolean czyNieDziala = false;
            println("1- kodowanie");
            println("2- dorzuc bledy");
            println("3- dekodowanie");
            println("4- exit");
            do {
                input = new Scanner(System.in);
                println("co wybierasz ");
                try {
                    choice_i = Integer.parseInt(readLine("podaj i"));
                    // choice_i = input.nextInt();
                    if (choice_i < 5)
                        czyNieDziala = false;
                } catch (NumberFormatException n) {
                    println("Zle wpisane dane");
                    czyNieDziala = true;

                }

            } while (czyNieDziala || choice_i > 4 || choice_i < 0);
            switch (choice_i) {
            case 1: {
                koder(bsf, mapa_ascii);
                break;
            }
            case 2: {
                bledy();
                break;
            }
            case 3: {
                dekoder(mapa_ascii);
                break;
            }
            case 4: {
                System.exit(0);
            }
            }
        }
    }

    private void koder(BitSet bsf, HashMap<String, String> mapa_ascii) {

        String pytanie = readLine("podaj znak (uwaga obslugiwane sa tylko znaki z zakresu <32-126>: ");
        pytanie.trim();// trim usuwa nam spacje na poczatku i na koncu
        char x[] = pytanie.toCharArray();
        for (int i = 0; i < pytanie.length(); i++) {
            String znaczek = String.valueOf(x[i]);
            if (!mapa_ascii.containsKey(znaczek)) {

            } else {
                binary = (mapa_ascii.get(znaczek));// tutaj mamy binarny
                                                    // odpowiednik naszej litery
            }
        }
        println("string binary=" + binary);
        char wgc[] = binary.toCharArray();
        for (int i = 0; i < bin_l; i++) {

            if (wgc[i] == '1')// (BigInteger.valueOf(Long.parseLong(binary,2)).testBit(i))//(wgc[i]=='1')
            {
                bsf.xor(bs[i]);
                // println("bsf"+bsf.toString());
            }

        }
        println("bsf" + bsf);
        long longset = bitSetToInt(bsf);
        stringset = Long.toBinaryString(longset);

        while (stringset.length() < dlugosc_n) {
            stringset = '0' + stringset;
        }
        println("stringset" + stringset);

    }

    public void dekoder(HashMap<String, String> mapa_ascii) {
        BitSet gotowe[] = new BitSet[(int) java.lang.Math.pow(2, bin_l)];
        // gotowe[] = BitSet.valueOf(new long[] { (1});
        BitSet slowa_mozliwe[] = new BitSet[(int) java.lang.Math.pow(2, bin_l)];
        BitSet bsr[] = new BitSet[bin_l];
        for (int i = 0; i < bin_l; i++) {
            bsr[i] = bs[bin_l - i - 1];
        }

        for (int i = 0; i < (int) java.lang.Math.pow(2, 8); i++) {
            slowa_mozliwe[i] = BitSet.valueOf(new long[] { (long) (i) });
            gotowe[i] = BitSet.valueOf(new long[] { 0 });
            // println("slowa_mozliwe" + slowa_mozliwe[i]);
            // long longset = bitSetToInt(slowa_mozliwe[i]);
            // String slowa_mozliwe_s = Long.toBinaryString(longset);

            // char wgc[] = slowa_mozliwe_s.toCharArray();

            for (int j = 0; j < 8; j++) {

                if (slowa_mozliwe[i].get(j) == true)// (BigInteger.valueOf(Long.parseLong(binary,2)).testBit(i))//(wgc[i]=='1')
                {
                    gotowe[i].xor(bsr[j]);

                }
            }
            // println("bsf"+gotowe[i]);
        }

        for (int i = 1; i < (int) java.lang.Math.pow(2, bin_l); i++) {
            int waga = 0;
            for (int j = 0; j < dlugosc_n; j++) {

                if (gotowe[i].get(j) == true) {
                    waga++;
                }

            }
            if (waga < d)
                d = waga;
        }
        println("waga=" + d);
        l = d - 1;
        t = (int) (l / 2);
        println("t, l: " + t + "," + l);

        bsh = new BitSet[dlugosc_n];

        for (int i = 0; i < bin_l; i++) {
            bsh[i] = reszta[i];
        }
        int miejsce = (int) java.lang.Math.pow(2,
                wielomian_generujacy_s.length() - 2);
        for (int i = bin_l; i < dlugosc_n; i++) {
            bsh[i] = BitSet.valueOf(new long[] { miejsce });
            miejsce = miejsce / 2;
        }
        BitSet bshr[] = new BitSet[dlugosc_n];
        for (int i = 0; i < dlugosc_n; i++) {
            bshr[i] = bsh[dlugosc_n - i - 1];
        }
        BitSet syndrom = BitSet.valueOf(new long[] { 0 });
        BitSet nasza_litera = BitSet.valueOf(new long[] { Long.parseLong(
                stringset, 2) });

        for (int i = 0; i < dlugosc_n; i++) {
            // println(bshr[i]);
        }
        for (int i = 0; i < dlugosc_n; i++) {

            if (nasza_litera.get(i) == true)// (BigInteger.valueOf(Long.parseLong(binary,2)).testBit(i))//(wgc[i]=='1')
            {
                syndrom.xor(bshr[i]);

            }

        }
        char tab_przesunieta[] = new char[dlugosc_n];
        // char tab_pusta[] = new char[dlugosc_n];
        // int przesuniecie = 0;
        char naprawiamy_blad[] = stringset.toCharArray();
        println("syndrom:" + syndrom);
        int ile = 0;// sprawdzamy gdzie mmay blad
        int gdzie = 0;
        for (int i = 0; i < dlugosc_n; i++)

        {
            if (syndrom.get(i) == true) {
                gdzie = dlugosc_n - i - 1;
                ile++;
            }
        }
        println("bledow mielismy: " + ile);
        println("gdzie: " + gdzie);
        // println("dlugosc stringseta " + stringset.length() + "dlugosc n " +
        // dlugosc_n);

        if (ile == t) {
            // char naprawiamy_blad[]= stringset.toCharArray();
            if (naprawiamy_blad[gdzie] == '1') {
                naprawiamy_blad[gdzie] = '0';
            } else {
                naprawiamy_blad[gdzie] = '1';
            }
            stringset = new String(naprawiamy_blad);
            println("naprawione cacko:" + stringset);
            String przycietystring = new String(naprawiamy_blad)
                    .substring(0, 8);
            println(przycietystring);
            // println(mapa_ascii.get(przycietystring));
            for (String o : mapa_ascii.keySet()) {
                if (mapa_ascii.get(o).equals(przycietystring)) {
                    println("odkodowany znaczek to " + o);
                }
            }

        } else if (ile > t && ile <= l) {
            for (int j = 0; j < dlugosc_n; j++) {
                println("obracanie" + j);
                println("slowo pierwotne " + stringset);
                for (int i = 1; i < dlugosc_n; i++) {

                    tab_przesunieta[dlugosc_n - 1] = naprawiamy_blad[0];
                    tab_przesunieta[i - 1] = naprawiamy_blad[i];
                }
                naprawiamy_blad = tab_przesunieta;
                // println("tab_przesunieta  "+new String(tab_przesunieta));
                println("przesuniete      " + new String(naprawiamy_blad));
                tab_przesunieta = new char[dlugosc_n];
                nasza_litera = BitSet.valueOf(new long[] { Long.parseLong(
                        new String(naprawiamy_blad), 2) });
                for (int k = 0; k < dlugosc_n; k++) {
                    // println(bshr[i]);
                }
                for (int l = 0; l < dlugosc_n; l++) {

                    if (nasza_litera.get(l) == true)// (BigInteger.valueOf(Long.parseLong(binary,2)).testBit(i))//(wgc[i]=='1')
                    {
                        syndrom.xor(bshr[l]);

                    }
                }
                println("syndrom:" + syndrom);
                ile = 0;
                gdzie = 0;
                // int ile=0;//sprawdzamy gdzie mmay blad
                // int gdzie=0;
                for (int m = 0; m < dlugosc_n; m++)

                {
                    if (syndrom.get(m) == true) {
                        gdzie = dlugosc_n - m - 1;
                        ile++;
                    }
                }
                println("bledow mielismy: " + ile);
                println("gdzie: " + gdzie);
                // println("dlugosc stringseta "+ stringset.length()+
                // "dlugosc n "+ dlugosc_n);
                syndrom = BitSet.valueOf(new long[] { 0 });
                if (ile == t) {
                    println("j - ilosc przesuniec powrotnych" + j);
                    // char naprawiamy_blad[]= stringset.toCharArray();
                    if (naprawiamy_blad[gdzie] == '1') {
                        naprawiamy_blad[gdzie] = '0';
                    } else {
                        naprawiamy_blad[gdzie] = '1';
                    }
                    for (int a = 0; a < j + 1; a++) {
                        for (int i = 1; i < dlugosc_n; i++) {
                            tab_przesunieta[0] = naprawiamy_blad[dlugosc_n - 1];
                            tab_przesunieta[i] = naprawiamy_blad[i - 1];
                        }
                        naprawiamy_blad = tab_przesunieta;
                        tab_przesunieta = new char[dlugosc_n];
                        println(new String(naprawiamy_blad));
                    }

                    // stringset = new String(naprawiamy_blad);
                    println("naprawione cacko:" + new String(naprawiamy_blad));
                    String przycietystring = new String(naprawiamy_blad)
                            .substring(0, 8);
                    println(przycietystring);
                    mapa_ascii.get(przycietystring);
                    for (String o : mapa_ascii.keySet()) {
                        if (mapa_ascii.get(o).equals(przycietystring)) {
                            println("odkodowany znaczek to " + o);
                        }
                    }
                    break;
                }
            }
            // println("blad nienaprawialny");
        } else {
            println("za duzo bledow");
        }

    }

    public void bledy() {
        println("stringset  bezbledny\n " + stringset);
        int dokad = (stringset.length() - 1);
        println("dokad" + dokad);
        char generator_bledow[] = stringset.toCharArray();
        Random rand = new Random();
        int blad = rand.nextInt((dokad) + 1) + 0; // int blad =
                                                    // rand.nextInt((dokad-bin_l)+1)+bin_l;
        println("blad=" + blad);
        if (generator_bledow[blad] == '1') {
            generator_bledow[blad] = '0';
        } else {
            generator_bledow[blad] = '1';
        }
        stringset = new String(generator_bledow);
        println("blad=" + blad);
        println("stringset z bledem\n " + stringset);
    }

    public static long bitSetToInt(BitSet bitSet) // to sluzy to zadmiany z
                                                    // bitseta na inta, fajna
                                                    // sprawa prawda nie?
    {
        long bitInteger = 0;
        for (int i = 0; i < 32; i++)
            if (bitSet.get(i))
                bitInteger |= (1 << i);
        return bitInteger;
    }

}