import java.util.Scanner;

public class HillCipher{

    static final int MOD = 26;

    static int mod(int x) {
        return ((x % MOD) + MOD) % MOD;
    }

    static int modInverse(int a) {
        a = mod(a);

        for (int i = 1; i < MOD; i++) {
            if ((a * i) % MOD == 1) {
                return i;
            }
        }

        return -1;
    }

    static int[][] inverseMatrix(int[][] key) {

        int determinant =
                key[0][0] * key[1][1]
              - key[0][1] * key[1][0];

        determinant = mod(determinant);

        int determinantInverse = modInverse(determinant);

        if (determinantInverse == -1) {
            throw new IllegalArgumentException(
                    "Key matrix has no inverse modulo 26"
            );
        }

        int[][] inverse = new int[2][2];

        inverse[0][0] = mod(key[1][1] * determinantInverse);
        inverse[0][1] = mod(-key[0][1] * determinantInverse);
        inverse[1][0] = mod(-key[1][0] * determinantInverse);
        inverse[1][1] = mod(key[0][0] * determinantInverse);

        return inverse;
    }

    static String encrypt(String text, int[][] key) {

        text = text.toUpperCase().replaceAll("[^A-Z]", "");

        if (text.length() % 2 != 0) {
            text += "X";
        }

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < text.length(); i += 2) {

            int p1 = text.charAt(i) - 'A';
            int p2 = text.charAt(i + 1) - 'A';

            int c1 = mod(key[0][0] * p1 +
                         key[0][1] * p2);

            int c2 = mod(key[1][0] * p1 +
                         key[1][1] * p2);

            result.append((char) (c1 + 'A'));
            result.append((char) (c2 + 'A'));
        }

        return result.toString();
    }

    static String decrypt(String cipherText, int[][] key) {

        int[][] inverseKey = inverseMatrix(key);

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < cipherText.length(); i += 2) {

            int c1 = cipherText.charAt(i) - 'A';
            int c2 = cipherText.charAt(i + 1) - 'A';

            int p1 = mod(inverseKey[0][0] * c1 +
                         inverseKey[0][1] * c2);

            int p2 = mod(inverseKey[1][0] * c1 +
                         inverseKey[1][1] * c2);

            result.append((char) (p1 + 'A'));
            result.append((char) (p2 + 'A'));
        }

        return result.toString();
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int[][] key = new int[2][2];

        System.out.println("Enter 2x2 key matrix:");

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                key[i][j] = sc.nextInt();
            }
        }

        sc.nextLine();

        System.out.print("Enter plaintext: ");
        String plaintext = sc.nextLine();

        try {

            int determinant =
                    mod(key[0][0] * key[1][1]
                      - key[0][1] * key[1][0]);

            int determinantInverse = modInverse(determinant);

            int[][] inverseKey = inverseMatrix(key);

            String encrypted = encrypt(plaintext, key);
            String decrypted = decrypt(encrypted, key);

            System.out.println("\nDeterminant mod 26: "
                    + determinant);

            System.out.println("Determinant inverse: "
                    + determinantInverse);

            System.out.println("\nInverse Key Matrix:");

            System.out.println(
                    inverseKey[0][0] + " "
                  + inverseKey[0][1]
            );

            System.out.println(
                    inverseKey[1][0] + " "
                  + inverseKey[1][1]
            );

            System.out.println("\nEncrypted: " + encrypted);
            System.out.println("Decrypted: " + decrypted);

        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }

        sc.close();
    }
}