import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/**
 * `RowColumnTransposition` class implements a row-column transposition cipher using a 5x5 matrix and a random key.
 *
 * This class provides methods to encrypt and decrypt a phrase using the transposition cipher.
 * The encryption process involves rearranging the characters of the phrase based on the random key.
 * The decryption process involves reversing the rearrangement using the same random key.
 */
public class RowColumnTransposition {

    // The 5x5 matrix used for the transposition cipher.
    private char[][] matrix;

    // The random key used for encryption and decryption.
    private int[] key;

    /**
     * Constructor to initialize the matrix and generate a random key.
     */
    public RowColumnTransposition() {
        // Initialize the matrix with empty characters.
        matrix = new char[5][5];
        for (char[] row : matrix) {
            Arrays.fill(row, ' ');
        }

        // Generate a random key.
        key = generateRandomKey();
    }

    /**
     * Generates a random key consisting of five unique digits.
     *
     * @return Returns an array of five unique digits.
     */
    private int[] generateRandomKey() {
        int[] key = new int[5];
        Random random = new Random();

        // Generate five unique random digits.
        for (int i = 0; i < 5; i++) {
            int digit;
            do {
                digit = random.nextInt(10);
            } while (containsDigit(key, digit));
            key[i] = digit;
        }

        return key;
    }

    /**
     * Checks if an array contains a specific digit.
     *
     * @param array The array to check.
     * @param digit The digit to search for.
     * @return Returns true if the array contains the digit, false otherwise.
     */
    private boolean containsDigit(int[] array, int digit) {
        for (int num : array) {
            if (num == digit) {
                return true;
            }
        }
        return false;
    }

    /**
     * Encrypts a phrase using the row-column transposition cipher.
     *
     * @param phrase The phrase to encrypt.
     * @return Returns the encrypted phrase.
     */
    public String encrypt(String phrase) {
        // Remove any spaces from the phrase.
        phrase = phrase.replaceAll("\\s", "");

        // Pad the phrase with spaces to make its length a multiple of 25.
        int padding = (25 - (phrase.length() % 25)) % 25;
        phrase += " ".repeat(padding);

        // Create a character array to hold the encrypted phrase.
        char[] encrypted = new char[phrase.length()];

        // Rearrange the characters based on the key.
        for (int i = 0; i < phrase.length(); i++) {
            int keyIndex = i % 5;
            int matrixIndex = keyIndex * 5 + key[keyIndex];
            encrypted[matrixIndex] = phrase.charAt(i);
        }

        return new String(encrypted);
    }

    /**
     * Decrypts an encrypted phrase using the row-column transposition cipher.
     *
     * @param encrypted The encrypted phrase to decrypt.
     * @return Returns the decrypted phrase.
     */
    public String decrypt(String encrypted) {
        // Create a character array to hold the decrypted phrase.
        char[] decrypted = new char[encrypted.length()];

        // Reverse the rearrangement based on the key.
        for (int i = 0; i < encrypted.length(); i++) {
            int keyIndex = i % 5;
            int matrixIndex = keyIndex * 5 + key[keyIndex];
            decrypted[i] = encrypted.charAt(matrixIndex);
        }

        return new String(decrypted);
    }

    /**
     * Prints the matrix and the key.
     */
    public void printMatrixAndKey() {
        System.out.println("Matrix:");
        for (char[] row : matrix) {
            System.out.println(Arrays.toString(row));
        }
        System.out.println("Key: " + Arrays.toString(key));
    }

    /**
     * Main method to interact with the user and demonstrate the usage of the RowColumnTransposition class.
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Create an instance of RowColumnTransposition.
        RowColumnTransposition transposition = new RowColumnTransposition();

        // Print the matrix and the key.
        transposition.printMatrixAndKey();

        // Get the user's choice.
        System.out.println("What do you want to do?");
        System.out.println("1. Encrypt a phrase");
        System.out.println("2. Decrypt an encrypted phrase");
        int choice = scanner.nextInt();
        scanner.nextLine(); // Consume the newline character

        if (choice == 1) {
            // Encrypt a phrase.
            System.out.println("Enter the phrase to encrypt:");
            String phrase = scanner.nextLine();
            String encrypted = transposition.encrypt(phrase);
            System.out.println("Encrypted phrase: " + encrypted);
        } else if (choice == 2) {
            // Decrypt an encrypted phrase.
            System.out.println("Enter the encrypted phrase to decrypt:");
            String encrypted = scanner.nextLine();
            String decrypted = transposition.decrypt(encrypted);
            System.out.println("Decrypted phrase: " + decrypted);
        } else {
            System.out.println("Invalid choice. Please choose 1 or 2.");
        }
    }
}