package com.spider.framwork;

import java.util.Scanner;

/**螺旋矩阵的demo（面向像我一样数学不好，脑袋不大灵光的java初学者）
 * 思路：1、确定圈数的规律 2、确定方向的规律 3、确定每一圈的起始位置
 * 画四个模型图，从少到多，方便我们在其中摸索出数据递增时的规律
 * 1 2
 * 4 3
 *
 * 1 2 3
 * 8 9 4
 * 7 6 5
 *
 *  1  2  3 4
 * 12 13 14 5
 * 11 16 15 6
 * 10  9 8  7
 *
 * 1  2  3  4  5
 * 16 17 18 19 6
 * 15 24 25 20 7
 * 14 23 22 21 8
 * 13 12 11 10 9
 */
public class MatrixDemo {
    private int startNum = 1;
    //矩阵的一条边长，写这么长是因为矩阵这个单词不认识，多写几遍，顺便背个单词
    private int matrixSideLen;
    private int turnsNumber;

    //矩阵的本体，一个边长为变量的二维数组
    private int[][] matrix;

    //通过构造器获得矩阵的大小和边长
    public MatrixDemo(int matrixSideLen) {
        this.matrixSideLen = matrixSideLen;
        matrix = new int[matrixSideLen][matrixSideLen];
        /**
         * 根据获得圈数的方法
         * 思路：通过矩阵的大小递增，我们可以发现，圈数是边长每加到奇数值加一圈,偶数不变，所以可以猜测规律为(matrixSide+1)/2
         */
        turnsNumber = (matrixSideLen + 1) / 2;
        createMatrix();
        for(int i = 0; i < matrixSideLen; i++){
            for(int m = 0; m < matrixSideLen; m++){
                if(matrix[i][m] < 10){
                    System.out.print(String.valueOf(matrix[i][m]).concat("  "));
                }
                else{
                    System.out.print(String.valueOf(matrix[i][m]).concat(" "));
                }
            }
            System.out.println();
        }
    }

    /**
     * 获得当前圈数起始数值
     * @param turnIndex
     * @return
     */
    private int getCornerStartNumber(int turnIndex){
        int startIndex = 1;//设置初始值
        int sideNumber = matrixSideLen - 1;//因为每条边有一个数字是重叠的，所以-1，周长值的1/4;
        //获得当前圈数上层圈数的周长总和
        for(int i = 0; i<(turnsNumber - 1); i++){
            startIndex += sideNumber * 4;
            //因为每一层依次会少两个数字
            sideNumber -= 2;
            continue;
        }
        return startIndex;

    }

    /**
     * 获得当前圈每条边数字个数
     */
    private int getSideNumberCount(int turnIndex){
        return (matrixSideLen - 1) -(turnIndex - 1) * 2;
    }

    /**
     * 生成当前圈
     * @param turnIndex
     */
    private void createConcurrentTurn(int turnIndex){
        int startIndex = getCornerStartNumber(turnIndex);//获得当前圈起始值
        int sideNumberCount = getSideNumberCount(turnIndex);//获得每条边数字个数
        for(int i = 0; i < 4; i++){
            createSide(i, startIndex, sideNumberCount, turnIndex);
            continue;
        }
    }

    /**
     *
     * @param direction 方向
     * @param startIndex 起始值
     * @param sideNumberCount 边值
     * @param turnsIndex 圈定位
     */
    private void createSide(int direction, int startIndex, int sideNumberCount, int turnsIndex){
        int cell = 0;//数组列座标
        int row = 0;//数组行座标
        switch (direction){
            //→方向：行不变，列递增
            case 0:
                row  = turnsIndex - 1;
                cell = turnsIndex - 1;
                for(int i = 0; i < sideNumberCount; i++){
                    matrix[row][cell + i] = startNum;
                    startNum++;
                    continue;
                }
                break;
            //↓方向：列不变，行递增
            case 1:
                row = turnsIndex - 1;
                cell = turnsIndex + sideNumberCount - 1;
                for(int i = 0; i < sideNumberCount; i++){
                    matrix[row + i][cell] = startNum;
                    startNum++;
                    continue;
                }
                break;
            //←方向：行不变，列递减
            case 2:
                row = turnsIndex + sideNumberCount - 1;
                cell = turnsIndex + sideNumberCount - 1;
                for(int i = 0; i < sideNumberCount; i++){
                    matrix[row][cell - i] = startNum;
                    startNum++;
                    continue;
                }
                break;
            //↑方向:行递减，列不变
            case 3:
                row  = turnsIndex + sideNumberCount - 1;
                cell = turnsIndex - 1;
                for(int i = 0; i < sideNumberCount; i++) {
                    matrix[row - i][cell] = startNum;
                    startNum++;
                    continue;
                }
                break;
        }
    }

    private void createMatrix(){
        for(int i = 0; i < turnsNumber; i++){
            int temp = i + 1;
            createConcurrentTurn(temp);
        }
        if(matrixSideLen % 2 == 1){
            matrix[matrixSideLen / 2][matrixSideLen / 2] = matrixSideLen * matrixSideLen;
        }
    }

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        MatrixDemo matrixDemo = new MatrixDemo(scanner.nextInt());
    }
}