package com.uitls;


import java.util.Scanner;

/**
 * 输入模块
 */
public class inputModule {
    /**
     * 输入模块封装，用于ACM模式下的笔试题，包含了整型和字符型的单值返回、一维数组返回和二维数组返回
     */
    public static <T> T readInput(Scanner in,Class<T> clz,int flag,int n,int m){
        switch (flag) {
            case 0:
                // 单值处理逻辑
                if (Integer.class.equals(clz)) {//不能是int，因为clz.cast()强转之后是int的封装内Integer，int的话与指定的返回值类型不同
                    return clz.cast(in.nextInt());
                } else {
                    return clz.cast(in.next());
                }
            case 1:
                // 一维数组处理逻辑
                if (clz.isArray() && clz.getComponentType().equals(int.class)) {
//                    System.out.println(clz.getComponentType());
                    int[] res = new int[n];
                    for (int i = 0; i < n; i++) {
                        res[i] = in.nextInt();
                    }
                    return clz.cast(res);
                } else {
//                    System.out.println(clz.getComponentType());
                    String[] res = new String[n];
                    for (int i = 0; i < n; i++) {
                        res[i] = in.next();
                    }
                    return clz.cast(res);
                }
            case 2:
                // 二维数组处理逻辑
                if (clz.isArray() && clz.getComponentType().getComponentType().equals(int.class)) {//二维数组调用两次，因为当调用该方法的类对象是一个嵌套数组类对象时，返回嵌套数组的最内层组件类型，即class [I
                    int[][] res = new int[n][m];
                    for (int i = 0; i < n; i++) {
                        for (int j = 0; j < m; j++) {
                            res[i][j] = in.nextInt();
                        }
                    }
                    return clz.cast(res);
                } else {
                    String[][] res = new String[n][m];
                    for (int i = 0; i < n; i++) {
                        for (int j = 0; j < m; j++) {
                            res[i][j] = in.next();
                        }
                    }
                    return clz.cast(res);
                }
            default:
                throw new IllegalArgumentException("Invalid flag: " + flag);
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        //模拟测试1：长度为n的数组
        int n = readInput(in, Integer.class, 0, 0, 0);
        int[] arr = readInput(in, int[].class, 1, n, 0);
        System.out.println("输入的整型一维数组为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

        //模拟测试2：长度为n的字符串
        int n = readInput(in, Integer.class, 0, 0, 0);
        String[] str = readInput(in,String[].class,1,n,0);
        System.out.println("输入的字符型一维数组为：");
        for (String s : str) {
            System.out.print(s + " ");
        }

        //模拟测试3：nxm的二维整型数组
        int n = readInput(in, Integer.class, 0, 0, 0);
        int m = readInput(in,Integer.class,0,0,0);
        int[][] arr = readInput(in, int[][].class, 2, n, m);
        System.out.println("输入的二维整型数组为：");
        for (int i = 0; i < n; i++) {
            for(int j =0;j< m ; j++){
                System.out.print(arr[i][j] + " ");
            }
        }

        //模拟测试4：nxm二维字符型数组
        int n = readInput(in, Integer.class, 0, 0, 0);
        int m = readInput(in,Integer.class,0,0,0);
        String[][] arr = readInput(in, String[][].class, 2, n, m);
        System.out.println("输入的二维字符型数组为：");
        for (int i = 0; i < n; i++) {
            for(int j =0;j< m ; j++){
                System.out.print(arr[i][j] + " ");
            }
        }

        in.close();
    }

}