Narimanova_LR2

//Class Starter.java

package od.igor.petrov;

import java.util.Scanner;

public class Starter {
    public static void main(String ... args){
        Scanner scanner = new Scanner(System.in);
        String key = null;
        String message = null;
        int choise = 0;
        System.out.println("Begin here (c) By Kravchenko Stanislav");
        System.out.println("Put the key");
        key = scanner.nextLine();
        System.out.println("Put the message");
        message = scanner.nextLine();
        System.out.println("\t1 - Crypt message\n\t2 - Decrypt message");
        choise = scanner.nextInt();
        switch (choise) {
        case 1:
            Cryptor.doCryptAndPrint(key, message);
            break;
        case 2:
            Decryptor.doDecryptAndPrint(key, message);
            break;
        default:
            System.out.println("Got a mistake");
            break;
        }
    }
}
//
//===============================================================
//
//Class Cryptor.java
package od.igor.petrov;

/**
 * @author Igor Petrov, Gaidarji Gennadiy, Kravchenko Stanislav, AE081
 * Lab. work 2.
 */

import java.util.Arrays;

public class Cryptor {

    private Cryptor(String key, String message){
        this.key = key;
        this.message = message;
    }

    /**
     * Permutation cipher algorithm
     * @refer http://en.wikipedia.org/wiki/Permutation_cipher
     */
    protected void cryptIt() {

        char[][] firstCaseCryptedMessage = new char[arrayHeightCalculatorLogic()][key.length()];
        char[][] lastCaseCryptedMessage = new char[arrayHeightCalculatorLogic()][key.length()];

        //PHASE 1. Preparation
        int reservCounter = 0;
        for(int i = 0; i < arrayHeightCalculatorLogic() ; i++){
            for(int j = 0; j <  key.length() && reservCounter < message.length(); j++){
                firstCaseCryptedMessage[i][j] = message.charAt(i*key.length() + j);
                reservCounter++;
            }
        }

        char[] myTemporaryKey = key.toCharArray();
        Arrays.sort(myTemporaryKey);


        //PHASE 2. Changing matrix
        int index = 0;
        for(int i = 0; i < myTemporaryKey.length; i++){
            index = key.indexOf(myTemporaryKey[i]);
            for(int j = 0; j < arrayHeightCalculatorLogic(); j++){
                //System.out.printf("Try to move %d,%d to %d,%d\n", j, i, j, index);
                lastCaseCryptedMessage[j][i] = firstCaseCryptedMessage[j][index];
            }
        }

        setCryptedMessage(lastCaseCryptedMessage);

    }


    /**
     *
     * @return maximum height of newborn message array
     */
    protected int arrayHeightCalculatorLogic(){
        int tmp = message.length() % key.length();
        int result = (message.length() - tmp) / key.length();
        if(tmp != 0){
            result++;
        }
        return result;
    }

    /**
     * Generates from array-view message to String Object
     * @param msg
     */
    protected void setCryptedMessage(char [][] msg) {
        StringBuffer buff = new StringBuffer();
        for(int i = 0; i < arrayHeightCalculatorLogic(); i++){
            for(int j = 0; j <  key.length(); j++){
                buff.append(msg[i][j]);
            }
        }
        cryptedMessage = buff.toString();
    }

    protected boolean isValid() {
        char[] myKey = key.toCharArray();
        Arrays.sort(myKey);
        for(int i = 0; i < myKey.length - 1; i++){
            if(myKey[i] == myKey[++i]){
                return false;
            }
        }
        return true;
    }


    /**
     * The only public-accessed method to crypt the message
     * @param key to be used ass pass-key
     * @param message - message to be crypted
     */
    public static void doCryptAndPrint(String key, String message){
        Cryptor cryptor = new Cryptor(key, message);
        cryptor.cryptIt();

        if(cryptor.isValid()){
            StringBuffer buff = new StringBuffer();
            buff.append("You entered message: ");
            buff.append(message);
            buff.append("\n");
            buff.append("You entered key: ");
            buff.append(key);
            buff.append("\nCription finished!\n");
            buff.append(cryptor.cryptedMessage);

            System.out.println(buff.toString());
        } else {
            System.out.println("Inconsistent key. Do not repeat symbols");
        }
    }

    private String key = null;
    private String message = null;
    private String cryptedMessage = null;
}
//
//===============================================================
//
//Class Decryptor.java

package od.igor.petrov;

/**
 * @author Igor Petrov, Gaidarji Gennadiy, Kravchenko Stanislav, AE081
 * Lab. work 2.
 */

import java.util.Arrays;

public class Decryptor {
    private Decryptor(String key, String message){
        this.key = key;
        this.message = message;
    }

    protected void decryptIt() {
        char[][] cryptedMessage = new char[arrayHeightCalculatorLogic()][key.length()];
        char[][] decryptedMessage = new char[arrayHeightCalculatorLogic()][key.length()];

        for(int k = 0, i = 0, j = 0; k < message.length(); k++){
            cryptedMessage[i][j] = message.charAt(k);
            j++;
            if(j == key.length()){
                j = 0;
                i++;
            }
        }

        char[] myTemporarySortedKey = key.toCharArray();
        Arrays.sort(myTemporarySortedKey);

        int index = 0;
        for(int i = 0; i < myTemporarySortedKey.length; i++){
            index = key.indexOf(myTemporarySortedKey[i]);
            for(int j = 0; j < arrayHeightCalculatorLogic(); j++){
                decryptedMessage[j][index] = cryptedMessage[j][i];
            }
        }

        setDecryptedMessage(decryptedMessage);
    }

    protected int arrayHeightCalculatorLogic(){
        int tmp = message.length() % key.length();
        int result = (message.length() - tmp) / key.length();
        if(tmp != 0){
            result++;
        }
        return result;
    }

    protected void setDecryptedMessage(char [][] msg) {
        StringBuffer buff = new StringBuffer();
        for(int i = 0; i < arrayHeightCalculatorLogic(); i++){
            for(int j = 0; j <  key.length(); j++){
                buff.append(msg[i][j]);
            }
        }
        decryptedMessage = buff.toString();
    }

    protected boolean isValid() {
        char[] myKey = key.toCharArray();
        Arrays.sort(myKey);
        for(int i = 0; i < myKey.length - 1; i++){
            if(myKey[i] == myKey[++i]){
                return false;
            }
        }
        return true;
    }

    public static void doDecryptAndPrint(String key, String message){
        Decryptor decryptor = new Decryptor(key, message);
        decryptor.decryptIt();

        if(decryptor.isValid()){
            StringBuffer buff = new StringBuffer();
            buff.append("You entered message: ");
            buff.append(message);
            buff.append("\n");
            buff.append("You entered key: ");
            buff.append(key);
            buff.append("\nDecription finished\n");
            buff.append(decryptor.decryptedMessage);

            System.out.println(buff.toString());
        } else {
            System.out.println("Inconsistent key. Do not repeat symbols");
        }
    }

    private String key = null;
    private String message = null;
    private String decryptedMessage = null;
}
// THE END
//========================