/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package jr;

/**
 *
 * @author zorael
 */
public class Sandbox {
    static String letters ="abcdefghijklmnopqrstuvwxyzåäö";

    public static void main(String[] args) throws java.util.InputMismatchException {
        // skapa, initiera Scanner
        java.util.Scanner in = new java.util.Scanner(System.in);

        // skapa, initiera message och key
        String message = "";
        int key = 0;

        // skapa boolean som endast blir true om man lyckats med inmatning
        boolean successfulInput = false;

        try {
            // inmatning av meddelande och nyckel
            System.out.print("Meddelande att encrypta: ");
            message = in.nextLine();
            System.out.print("Nyckel: ");
            key = in.nextInt();

            // sätt successfulInput till true så att programmet går vidare
            successfulInput = true;
        } catch (java.util.InputMismatchException e) {
            System.out.println("Felinmatat. Skämmes.");
        }

        if (successfulInput) {
            // om den kommit så här långt fungerade inmatningen
            System.out.println("------------"); // separator

            // mata ut originalmeddelandet
            System.out.println("Message: \"" + message + "\"");

            // mata ut meddelandet i små bokstäver
            String lowercaseMessage = message.toLowerCase();
            System.out.println("Lowercase: \"" + lowercaseMessage + "\"");

            // encrypta och mata ut resultatet
            String encryptedMessage = encrypt(lowercaseMessage, key);
            System.out.println("Encrypted: \"" + encryptedMessage + "\"");

            // decrypta och mata ut resultatet
            String decryptedMessage = decrypt(lowercaseMessage, key);
            System.out.println("Decrypted: \"" + decryptedMessage + "\"");

            // decrypta det enkrypterade; alltså, "ångra". ska bli samma som
            // originalmeddelandet
            String decryptedEncryptedMessage = decrypt(encryptedMessage, key);
            System.out.println("Decrypted encrypted: \""
                    + decryptedEncryptedMessage
                    + "\" (ska vara samma som lowercase message)");
        }
    }

    public static String encrypt(String thisMessage, int key) {
        // skapa, initiera StringBuilder att lägga till färdiga bokstäver i
        StringBuilder encryptedMessage = new StringBuilder();

        // iterera genom alla bokstäver i thisMessage
        for (int index = 0; index < thisMessage.length(); index++) {
            // välj ut nuvarande bokstav (för index), sätt som thisLetter
            char thisLetter = thisMessage.charAt(index);
            // åberopa shift på den bokstaven för att encrypta
            char encryptedLetter = shift(thisLetter, key);
            // lägg till encryptedLetter i StringBuildern
            encryptedMessage.append(encryptedLetter);
        }
        // returnera som String
        return encryptedMessage.toString();
    }

    public static char shift(char thisChar, int key) {
        // hitta index för thisChar i letters, sätt som letterIndex
        int letterIndex = letters.indexOf(thisChar);

        // indexOf ger -1 om thisChar inte finns i letter, returnera isf
        // direkt den givna bokstaven (såsom uppgiften vill)
        if (letterIndex == -1) {
            return thisChar;
        }

        // bumpa letterIndex med given key
        letterIndex += key;
        // motsvarar som sagt letterIndex = letterIndex + key

        /* om nya letterIndex faller utanför de index letters har,
         * subtrahera med letters.length() för att "varva" så ö blir a om key 1
         * vidare, första index av letters är 0, men length() ger längd
         * såsom om första är 1, så subtrahera length() med 1
         */
        if (letterIndex > (letters.length() - 1))
            letterIndex -= letters.length();
        // på samma sätt, om negativt så addera med letters.length()
        else if (letterIndex < 0)
            letterIndex += letters.length();

        // returnera chiffrerad bokstav
        return letters.charAt(letterIndex);
    }

    public static String decrypt(String thisMessage, int key) {
        // när man dekrypterar ska key vara negativ (shiftBackwards)
        key = 0 - key;

        // skapa, initiera StringBuilder att lägga till färdiga bokstäver i
        StringBuilder decryptedMessage = new StringBuilder();

        // iterera genom alla bokstäver i thisMessage
        for (int index = 0; index < thisMessage.length(); index++) {
            // välj ut nuvarande bokstav (för index), sätt som thisLetter
            char thisLetter = thisMessage.charAt(index);
            // åberopa shift på den bokstaven för att decrypta
            char decryptedLetter = shift(thisLetter, key);
            // lägg till decryptedLetter i StringBuildern
            decryptedMessage.append(decryptedLetter);
        }
        // returnera som String
        return decryptedMessage.toString();
    }
}