package de.unidue.iem.tdr.nis.client;

/**
 * Created by tu on 15/05/17.
 */
public class Loesungsmethoden {

    /**
     * Staendig geteilt die kleinste moegliche Primzahl rechnen
     */
    public String factorization(int num) {
        // 126 / 2 = 63 -> nicht weiter durch 2 teilbar, naechste p
        // 63 / 3 = 21 -> weiter durch 3 teilbar, 3 weiternutzen
        // 21 / 3 = 7 -> nicht weiter durch 3 teilbar, naechste p
        // 7 / 7 = 1 -> fertig
        // returns 2, 3, 3, 7;
        StringBuilder sb = new StringBuilder();
        int result = num;
        int prime = 2;
        while (result != 1) {
            prime = 2;
            while (!devideable(result, prime)) {
                prime = getNextPrime(prime, num);
            }
            result /= prime;
            sb.append(prime).append("*");
        }
        sb.deleteCharAt(sb.length() - 1);
        return sb.toString();
    }

    private boolean devideable(int devidable, int by) {
        return (devidable % by) == 0;
    }

    private int getNextPrime(int initPrime, int cap) {
        for (int i = initPrime; i <= cap; i++) {
            if (isPrime(i) && !(i == initPrime || i == cap)) {
                return i;
            }
        }
        System.exit(0);
        return 0;
    }

    private boolean isPrime(int possPrime) {
        if (possPrime == 0) {
            return false;
        }
        for (int i = 1; i <= possPrime; i++) {
            if (!(i == 1 || i == possPrime)) {
                return !devideable(possPrime, i);
            }
        }
        return true;
    }

    public String stringXOR(String one, String two) {
        if (!(one.length() == two.length())) {
            String appendable = "";
            if (one.length() < two.length()) {
                for (int i = 0; i < two.length() - one.length(); i++) {
                    appendable += "0";
                }
                one = appendable + one;
            } else {
                for (int i = 0; i < one.length() - two.length(); i++) {
                    appendable += "0";
                }
                two = appendable + two;
            }
        }
        char firstBit;
        char secondBit;
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < one.length(); i++) {
            firstBit = one.charAt(i);
            secondBit = two.charAt(i);
            result.append(charXOR(firstBit, secondBit));
        }
        return result.toString();
    }

    private char charXOR(char a, char b) {
        if (a == b) {
            return '0';
        } else if (a != b) {
            return '1';
        }
        return '.';
    }

    public String stringConv(String hex) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < hex.length(); i++) {
            String bite = hexConv(hex.charAt(i));
            result.append(bite);
        }
        return result.toString();
    }

    private String hexConv(char hex) {
        switch (hex) {
            case '0':
                return "0000";
            case '1':
                return "0001";
            case '2':
                return "0010";
            case '3':
                return "0011";
            case '4':
                return "0100";
            case '5':
                return "0101";
            case '6':
                return "0110";
            case '7':
                return "0111";
            case '8':
                return "1000";
            case '9':
                return "1001";
            case 'a':
                return "1010";
            case 'b':
                return "1011";
            case 'c':
                return "1100";
            case 'd':
                return "1101";
            case 'e':
                return "1110";
            case 'f':
                return "1111";
            default:
                return "empty";
        }
    }

    public int MOD(int a, int b) {
        // 21 mod 10
        // 21 - 10 = 11
        // 11 - 10 = 1
        // oops 1 - 10 is negative 👍
        while ((a - b) > 0) {
            a -= b;
        }
        return a;
    }

    public String decrypt_vigenere(String c_msg, String key) {
        char[][] vigArray = getVigenereTable();
        char[] c_msgArray = c_msg.toCharArray();
        char[] keyArray = key.toCharArray();
        StringBuilder de_msg = new StringBuilder();
        for(int i = 0; i<c_msgArray.length; i++){
            for (int j = 0; j < vigArray.length; j++) {
                if (c_msgArray[i]==vigArray[keyArray[][j]]){
                    de_msg.append(c_msgArray);
                }
            }
        }
        return de_msg.toString();
    }

    private char[][] getVigenereTable() {
        char[][] vigTable = new char[26][26];
        for (int i = vigTable.length-1; i >= 0; i--) {
            vigTable[vigTable.length-1-i] = vigenereArray(i+1);
        }
        return vigTable;
    }

    private char[] vigenereArray(int rot) {
        char[] vigenereTable = new char[26];
        char[] asciiTable = getASCIITable();
        if(rot%26==0){
            return asciiTable;
        }
        for (int i = 0; i < vigenereTable.length; i++) {
            vigenereTable[(i+rot) % vigenereTable.length ] = getASCIITable()[i];
        }
        return vigenereTable;
    }

    private char[] getASCIITable() {
        char[] table = new char[26];
        int j = 0;
        for (int i = 1; i <= 26; i++) {
            table[j] = getAsciiLetter(i);
            j++;
        }
        return table;
    }

    private char getAsciiLetter(int ord) {
        if (ord > 26 || ord <= 0) {
            ord = -96;
        }
        ord = ord + 96;
        return (char) ord;
    }

    private int getAsciiNumber(char chr){
        return (int) chr;
    }

    public static void main(String[] args) {
        Loesungsmethoden lm = new Loesungsmethoden();
        int index = 0;
        for(char[] sub: lm.getVigenereTable()){
            for(char i: sub){
                System.out.print(i);
            }
            System.out.println();
        }
    }
}