Matrix Rotation

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'matrixRotation' function below.
     *
     * The function accepts following parameters:
     *  1. 2D_INTEGER_ARRAY matrix
     *  2. INTEGER r
     */

    public static void matrixRotation(List<List<Integer>> matrix, int r) {
    // Write your code here
        List<List<Integer>> layers = layers(matrix);

        /*for (List<Integer> list : layers) {
            System.out.println(list);
        }*/

        for (int i = 0; i < layers.size(); i++) {
            layers.set(i, rotateA(layers.get(i), r));
        }

        /*for (List<Integer> list : layers) {
            System.out.println(list);
        }*/

        int[][] rotated = layersToMatrix(layers, matrix);

        for (int[] row : rotated) {
            for (int i : row) {
                System.out.print(i + " ");
            }
            System.out.println("");
        }
    }

    public static int[][] layersToMatrix(List<List<Integer>> layers, List<List<Integer>> matrix) {
        int[][] result = new int[matrix.size()][matrix.get(0).size()];
        int rows = result.length;
        int columns = result[0].length;
        int start = 0;
        int row;
        int column;

        int topStop, rightStop, bottomStop, leftStop;

        for (List<Integer> layer : layers) {
            row = start;
            column = start;
            topStop = columns - 1;
            rightStop = topStop + rows - 1;
            bottomStop = rightStop + columns - 1;
            leftStop = bottomStop + rows - 1;

            for (int i = 0; i < topStop; i++) {
                try {
                result[row][column] = layer.get(i);
                column++;
                } catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println(layer);
                    System.out.println(layer.get(i));
                    System.out.println("row " + row);
                    System.out.println("column " + column);
                    System.out.println("top " + topStop);
                    System.out.println("right " + rightStop);
                    System.out.println("bottom " + bottomStop);
                    System.out.println("left " + leftStop);
                }
            }

            for (int i = topStop; i < rightStop; i++) {
                result[row][column] = layer.get(i);
                row++;
            }

            for (int i = rightStop; i < bottomStop; i++) {
                result[row][column] = layer.get(i);
                column--;
            }

            for (int i = bottomStop; i < leftStop; i++) {
                result[row][column] = layer.get(i);
                row--;
            }
            start++;
            columns-=2;
            rows-=2;
        }

        return result;
    }

    /*public static void layersToMatrix(List<List<Integer>> layers, List<List<Integer>> matrix) {
        int rows = matrix.size();
        int columns = matrix.get(0).size();
        int start = 0;
        int endColumn = columns-1;
        int endRow = rows - 1;
        int row = 0;
        int column = 0;

        for (List<Integer> layer : layers) {
            for (int i = 0; i < columns; i++) {
                matrix.get(row).set(column, layer.get(i));
                column++;
            }

            column--;
            //row++;

            for (int i = columns; i < columns + rows; i++) {
                matrix.get(row).set(column, layer.get(i));
                row++;
            }

            row--;
            //column--;

            for (int i = columns + rows; i < columns - 2 + rows * 2; i++) {
                matrix.get(row).set(column, layer.get(i));
                column--;
            }

            column++;
            //row++;

            for (int i = columns - 2  + rows * 2; i < (columns-2) * 2 + rows * 2; i++) {
                matrix.get(row).set(column, layer.get(i));
               row++;
            }

            rows -= 2;
            columns -=2;
            start++;
            row = start;
            column = start;
        }
        //return matrix;
    }*/

    public static List<Integer> rotateA(List<Integer> layer, int r) {
        int[] rotation = new int[layer.size()];

        int shift = 0;
        int index;

        r = r % layer.size();
        if (r == 0) {
            return layer;
        }

        for (int i = 0; i < layer.size(); i++) {
            shift = Math.abs(i - r);
            index = i - r < 0 ?
                layer.size() - shift : i - r;
            rotation[index] = layer.get(i);
        }

        return Arrays.stream(rotation)
            .mapToObj(i -> Integer.valueOf(i))
            .collect(Collectors.toList());
    }

    /*public static void rotate(List<Integer> layer, int r) {
        int index = 0;
        int shift = 0;
        int current = 0;
        int temp = layer.get(0);

        r = r % layer.size();
        if (r == 0) {
            return;
        }

        for (int i = 0; i < layer.size(); i++) {
            current = temp;
            shift = Math.abs(index - r);
            index = index - r < 0 ?
                layer.size() - shift : index - r;
            temp = layer.get(index);
            layer.set(index, current);
        }

    }*/

    public static List<List<Integer>> layers(List<List<Integer>> matrix) {
        List<List<Integer>> layers = new ArrayList<>();
        int start = 0;
        int endRow = matrix.size()-1-start;
        int endColumn = matrix.get(start).size()-start;

        while (start < endRow && start < endColumn) {
            List<Integer> layer = new ArrayList<>();

            layer.addAll(top(matrix, start, endColumn));
            layer.addAll(right(matrix, start, endRow, endColumn));
            layer.addAll(bottom(matrix, start, endRow, endColumn));
            layer.addAll(left(matrix, start, endRow));

            layers.add(layer);

            start++;
            endColumn--;
            endRow--;
        }

        return layers;
    }

    public static List<Integer> top(List<List<Integer>> matrix, int start, int endColumn){
        return matrix.get(start).subList(start, endColumn);
    }

    public static List<Integer> right(List<List<Integer>> matrix, int start, int endRow, int endColumn){
        List<Integer> result = new ArrayList<>();
        for (int i = start+1; i < endRow; i++) {
            result.add(matrix.get(i).get(endColumn-1));
        }
        return result;
    }

    public static List<Integer> bottom(List<List<Integer>> matrix, int start, int endRow, int endColumn){
        List<Integer> result = matrix.get(endRow).subList(start, endColumn);
        Collections.reverse(result);
        return result;
    }

    public static List<Integer> left(List<List<Integer>> matrix, int start, int endRow){
        List<Integer> result = new ArrayList<>();
        for (int i = endRow-1; i > start; i--) {
            result.add(matrix.get(i).get(start));
        }
        return result;
    }

}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        String[] firstMultipleInput = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");

        int m = Integer.parseInt(firstMultipleInput[0]);

        int n = Integer.parseInt(firstMultipleInput[1]);

        int r = Integer.parseInt(firstMultipleInput[2]);

        List<List<Integer>> matrix = new ArrayList<>();

        IntStream.range(0, m).forEach(i -> {
            try {
                matrix.add(
                    Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
                        .map(Integer::parseInt)
                        .collect(toList())
                );
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        });

        Result.matrixRotation(matrix, r);

        bufferedReader.close();
    }
}