package com.vincent.rsf.framework.generators;

import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.generators.constant.SqlOsType;
import com.vincent.rsf.framework.generators.domain.Column;
import com.vincent.rsf.framework.generators.utils.GeneratorUtils;
import org.springframework.core.io.ClassPathResource;

import java.io.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Created by vincent on 2019-06-18
 */
public class ReactGenerator {

    private static final String BASE_DIR = "src/main/";
    private static final String JAVA_DIR = BASE_DIR + "java/";
    private static final String XML_DIR = BASE_DIR + "resources/mapper/";
    private static final String HTML_DIR = BASE_DIR + "webapp/";
    private static final String[] ALL_TEMPLATES = new String[]{
            "Controller",
            "Service",
            "ServiceImpl",
            "Mapper",
            "Entity",
            "Xml",
            "Sql",
            "ReactCreate",
            "ReactEdit",
            "ReactList",
            "ReactPanel",
            "Index",
    };
    private static final ArrayList<String> SYSTEM_MODEL = new ArrayList<String>(){{
            add("User");
            add("Tenant");
    }};


    public String url;
    public String username;
    public String password;
    public String table;
    public String tableDesc;
    public String packagePath;
    public boolean controller = true;
    public boolean service = true;
    public boolean mapper = true;
    public boolean entity = true;
    public boolean xml = true;
    public boolean react = true;
    public boolean sql = true;
    public SqlOsType sqlOsType;
    public String backendPrefixPath;
    public String frontendPrefixPath;

    private List<Column> columns = new ArrayList<>();
    private String fullEntityName;          // 大写表名 - UserRole
    private String simpleEntityName;        // 小写表名 - userRole
    private String entityImport;            // Entity类Import
    private String entityContent;           // Entity内容
    private String primaryKeyColumn;        // 主键小驼峰 default：id
    private String majorColumn;             // 显示主键小驼峰 - name / uuid
    private String systemPackagePath;       // system 包路径
    private String systemPackage;           //
    private String itemName;                // 包路径最后一个元素： manager（com.vincent.rsf.manager.manager)

    private String reactCreateContent;      // ReactCreate字段
    private String reactEditContent;      // ReactCreate字段
    private String reactListContent;      // ReactList字段
    private String reactListFilterRContent;      // ReactListFilter字段
    private String reactPanelContent;           // ReactPanel字段
    private String reactLocaleContent;          // 国际化配置

    private void init() throws Exception {
        gainDbInfo();
        fullEntityName = GeneratorUtils.getNameSpace(table);
        simpleEntityName = fullEntityName.substring(0, 1).toLowerCase()+fullEntityName.substring(1);
        entityContent = createEntityMsg();
        primaryKeyColumn = createPrimaryMsg();
        majorColumn = createMajorMsg();
        String[] packagePathSplit = packagePath.split("\\.");
        systemPackagePath = packagePath.replaceAll(packagePathSplit[packagePathSplit.length-1], "system");
        String[] split = systemPackagePath.split("\\.");
        systemPackage = "";
        for (int i = 1; i <= split.length; i++) {
            if (i != split.length) {
                if (i == split.length - 1) {
                    systemPackage = systemPackage + split[i-1];
                } else {
                    systemPackage = systemPackage + split[i-1] + ".";
                }
            }
        }
        itemName = packagePathSplit[packagePathSplit.length - 1];

        reactCreateContent = createReactCreateContent();
        reactEditContent = createReactEditContent();
        reactListContent = createReactListContent();
        reactListFilterRContent = createReactListFilterRContent();
        reactPanelContent = createReactPanelContent();
        reactLocaleContent = createReactLocaleContent();
    }

    public void build() throws Exception {
        init();
        for (String template : ALL_TEMPLATES){
            boolean pass = false;
            String lowerCase = template.toLowerCase();
            String templatePath = lowerCase.contains("impl")?lowerCase.substring(0,lowerCase.length()-4)+"/"+lowerCase.substring(lowerCase.length()-4):lowerCase;
            String directory="";
            String fileName="";
            switch (template){
                case "Controller":
                    pass = controller;
                    directory = backendPrefixPath + JAVA_DIR + packagePath.replace(".", "/")+"/"+templatePath+"/";
                    fileName = fullEntityName+template+".java";
                    break;
                case "Service":
                    pass = service;
                    directory = backendPrefixPath + JAVA_DIR + packagePath.replace(".", "/")+"/"+templatePath+"/";
                    fileName = fullEntityName+template+".java";
                    break;
                case "ServiceImpl":
                    pass = service;
                    directory = backendPrefixPath + JAVA_DIR + packagePath.replace(".", "/")+"/"+templatePath+"/";
                    fileName = fullEntityName+template+".java";
                    break;
                case "Mapper":
                    pass = mapper;
                    directory = backendPrefixPath + JAVA_DIR + packagePath.replace(".", "/")+"/"+templatePath+"/";
                    fileName = fullEntityName+template+".java";
                    break;
                case "Entity":
                    pass = entity;
                    directory = backendPrefixPath + JAVA_DIR + packagePath.replace(".", "/")+"/"+templatePath+"/";
                    fileName = fullEntityName+".java";
                    break;
                case "Xml":
                    pass = xml;
                    directory = backendPrefixPath + XML_DIR + itemName + "/";
                    fileName = fullEntityName+"Mapper.xml";
                    break;
                case "Sql":
                    pass = sql;
                    directory = backendPrefixPath + JAVA_DIR;
                    fileName = simpleEntityName+".sql";
                    break;
                case "ReactCreate":
                    pass = react;
                    directory = frontendPrefixPath + "/src/page/" + simpleEntityName + "/";
                    fileName = fullEntityName + "Create.jsx";
                    break;
                case "ReactEdit":
                    pass = react;
                    directory = frontendPrefixPath + "/src/page/" + simpleEntityName + "/";
                    fileName = fullEntityName + "Edit.jsx";
                    break;
                case "ReactList":
                    pass = react;
                    directory = frontendPrefixPath + "/src/page/" + simpleEntityName + "/";
                    fileName = fullEntityName + "List.jsx";
                    break;
                case "ReactPanel":
                    pass = react;
                    directory = frontendPrefixPath + "/src/page/" + simpleEntityName + "/";
                    fileName = fullEntityName + "Panel.jsx";
                    break;
                case "Index":
                    pass = react;
                    directory = frontendPrefixPath + "/src/page/" + simpleEntityName + "/";
                    fileName = "index.jsx";
                    break;
                default:
                    break;
            }
            if (!pass){ continue; }
            String content = readFile(template);
            writeFile(content, directory, fileName, template);
        }
    }

    private String readFile(String template){
        StringBuilder txtContentBuilder=new StringBuilder();
        ClassPathResource classPath=new ClassPathResource("templates/react-admin/"+template + ".txt");

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(classPath.getInputStream()))) {
            String lineContent;
            while ((lineContent = reader.readLine()) != null) {
                txtContentBuilder.append(lineContent).append("\n");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return txtContentBuilder.toString();
    }

    private void writeFile(String content, String directory, String fileName, String template) throws IOException {
        File codeDirectory=new File(directory);
        if(!codeDirectory.exists()){
            codeDirectory.mkdirs();
        }

        File writerFile=new File(directory+fileName);
        if(!writerFile.exists()){
            content=content.
                    replaceAll("@\\{TABLENAME}", table)
                    .replaceAll("@\\{TABLEDESC}", tableDesc)
                    .replaceAll("@\\{ENTITYIMPORT}", entityImport)
                    .replaceAll("@\\{ENTITYCONTENT}", entityContent)
                    .replaceAll("@\\{ENTITYNAME}", fullEntityName)
                    .replaceAll("@\\{SIMPLEENTITYNAME}", simpleEntityName)
                    .replaceAll("@\\{UENTITYNAME}", simpleEntityName)
                    .replaceAll("@\\{COMPANYNAME}",packagePath)
                    .replaceAll("@\\{ITEMNAME}",itemName)
//                    .replaceAll("@\\{XMLCONTENT}", xmlContent)
                    .replaceAll("@\\{MAJORCOLUMN}", GeneratorUtils.firstCharConvert(majorColumn, false))    // majorColumn UpCase
                    .replaceAll("@\\{MAJORCOLUMN_LINE}", GeneratorUtils.humpToLine(majorColumn))
                    .replaceAll("@\\{MAJORCOLUMN_UP}", GeneratorUtils.firstCharConvert(majorColumn, false))
                    .replaceAll("@\\{MAJORCOLUMN_LOW}", GeneratorUtils.firstCharConvert(majorColumn, true))
                    .replaceAll("@\\{PRIMARYKEYCOLUMN}", GeneratorUtils.firstCharConvert(primaryKeyColumn, false))
                    .replaceAll("@\\{PRIMARYKEYCOLUMN0}", GeneratorUtils.firstCharConvert(primaryKeyColumn, true))
                    .replaceAll("@\\{UPCASEMARJORCOLUMN}", GeneratorUtils.firstCharConvert(primaryKeyColumn, false))
                    .replaceAll("@\\{SYSTEMPACKAGE}",systemPackage)

                    .replaceAll("@\\{REACTCREATECONTENT}",reactCreateContent)
                    .replaceAll("@\\{REACTEDITCONTENT}",reactEditContent)
                    .replaceAll("@\\{REACTLISTCONTENT}",reactListContent)
                    .replaceAll("@\\{REACTLISTFILTERCONTENT}",reactListFilterRContent)
                    .replaceAll("@\\{REACTPANELCONTENT}", reactPanelContent)
                    .replaceAll("@\\{REACTLOCALECONTENT}", reactLocaleContent)
            ;
            writerFile.createNewFile();
            BufferedWriter writer=new BufferedWriter(new FileWriter(writerFile));
            writer.write(content);
            writer.flush();
            writer.close();
            System.out.println(fullEntityName+template+" 源文件创建成功！");
        }else{
            System.out.println(fullEntityName+template+" 源文件已经存在创建失败！");
        }
    }

    private void gainDbInfo() throws Exception {
        Connection conn;
        if (null == this.sqlOsType) {
            throw new RuntimeException("请选择sqlOsType！");
        }
        if (null == this.table) {
            throw new RuntimeException("请输入table！");
        }
        if (null == this.tableDesc) {
            throw new RuntimeException("请输入tableDesc！");
        }
        switch (this.sqlOsType) {
            case MYSQL:
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                conn = DriverManager.getConnection("jdbc:mysql://"+url, username, password);
                this.columns = getMysqlColumns(conn, table, true, sqlOsType);
                break;
            case SQL_SERVER:
                Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver").newInstance();
                conn = DriverManager.getConnection("jdbc:sqlserver://"+url, username, password);
                this.columns = getSqlServerColumns(conn, table, true, sqlOsType);
                break;
            default:
                throw new RuntimeException("请指定数据库类型！");
        }

    }

    // mysql
    public static List<Column> getMysqlColumns(Connection conn, String table, boolean init, SqlOsType sqlOsType) throws Exception {
        List<Column> result = new ArrayList<>();
        PreparedStatement ps = conn.prepareStatement("select * from " + table);
        ResultSetMetaData meta = ps.executeQuery().getMetaData();
        // 单表字段数量
        int count = meta.getColumnCount();
        ResultSet resultSet = ps.executeQuery("show full columns from " + table);
        for (int i = 1; i < count + 1; i++) {
            String columnName = meta.getColumnName(i);
            if (resultSet.next() && columnName.equals(resultSet.getString("Field"))){
                result.add(new Column(
                        conn,
                        meta.getColumnName(i),
                        GeneratorUtils.getType(meta.getColumnType(i)),
                        resultSet.getString("Comment"),
                        resultSet.getString("Key").equals("PRI"),
                        resultSet.getString("Key").equals("PRI"),
                        resultSet.getString("Null").equals("NO"),
                        GeneratorUtils.getColumnLength(resultSet.getString("Type")),
                        init,
                        sqlOsType
                ));
            }
            result.forEach(column -> System.out.println(column.toString()));
        }
        return result;
    }

    // sqlserver
    public static List<Column> getSqlServerColumns(Connection conn, String table, boolean init, SqlOsType sqlOsType) throws Exception {
        List<Column> result = new ArrayList<>();
        PreparedStatement ps = conn.prepareStatement("select * from " + table);
        ResultSetMetaData meta = ps.executeQuery().getMetaData();
        // 单表字段数量
        int count = meta.getColumnCount();
        StringBuilder sql = new StringBuilder("SELECT \n" +
                "       'Field'= a.name,\n" +
                "       'Comment'= isnull(g.[value],''),\n" +
                "       'Key'= case when COLUMNPROPERTY( a.id,a.name,'IsIdentity')=1 then 'PRI' else '' end,\n" +
                "       'Main'= case when exists(SELECT 1 FROM sysobjects where xtype='PK' and parent_obj=a.id and name in (SELECT name FROM sysindexes WHERE indid in( SELECT indid FROM sysindexkeys WHERE id = a.id AND colid=a.colid))) then 'PRI' else '' end,"+
                "       'Type'= b.name,\n" +
                "       'Length'= COLUMNPROPERTY(a.id,a.name,'PRECISION'),\n" +
                "       'Decimals'= isnull(COLUMNPROPERTY(a.id,a.name,'Scale'),0),\n" +
                "       'Null'= case when a.isnullable=1 then 'Yes' else 'No' end,\n" +
                "       'Default' = isnull(e.text,'')\n" +
                "FROM  syscolumns a\n" +
                "LEFT JOIN  systypes b on a.xusertype=b.xusertype\n" +
                "INNER JOIN sysobjects d on  a.id=d.id  and d.xtype='U' and  d.name<>'dtproperties'\n" +
                "LEFT JOIN  syscomments e on  a.cdefault=e.id\n" +
                "LEFT JOIN  sys.extended_properties g on  a.id=G.major_id and a.colid=g.minor_id  \n" +
                "LEFT JOIN  sys.extended_properties f on  d.id=f.major_id and f.minor_id=0 where d.name = '")
                .append(table).append("' ORDER BY a.colorder ASC");
        ResultSet resultSet = conn.prepareStatement(sql.toString()).executeQuery();
        for (int i = 1; i < count + 1; i++) {
            String columnName = meta.getColumnName(i);
            if (resultSet.next() && columnName.equals(resultSet.getString("Field"))){
                result.add(new Column(
                        conn,
                        meta.getColumnName(i),
                        GeneratorUtils.getType(meta.getColumnType(i)),
                        resultSet.getString("Comment"),
                        resultSet.getString("Key").equals("PRI"),
                        resultSet.getString("Main").equals("PRI"),
                        resultSet.getString("Null").equals("No"),
                        GeneratorUtils.getColumnLength(resultSet.getString("Type")),
                        init,
                        sqlOsType
                ));
            }
        }
        result.forEach(column -> System.out.println(column.toString()));
        return result;
    }






















    /**********************************************************************************************/
    /************************************* Entity动态字段 *******************************************/
    /**********************************************************************************************/

    private String createEntityMsg(){
        if (Cools.isEmpty(systemPackagePath)) {
            String[] packagePathSplit = packagePath.split("\\.");
            systemPackagePath = packagePath.replaceAll(packagePathSplit[packagePathSplit.length-1], "system");
        }
        if (columns.isEmpty()){
            return null;
        }
        StringBuilder sb = new StringBuilder();
        StringBuilder entityIm = new StringBuilder();
        boolean setTableField = true;
        boolean setTableId = true;
        boolean setDateTimeFormat = true;
        for (Column column : columns){
//            System.out.println("------==========>");
//            System.out.println(column.getName());
//            System.out.println(column.getType());
            if (column.getType().equals("Date")){
                entityIm.append("import java.text.SimpleDateFormat;\n")
                        .append("import java.util.Date;\n");
            }

            // 注释
            if (!Cools.isEmpty(column.getComment())){
                sb.append("    /**\n")
                        .append("     * ")
                        .append(column.getWholeComment())
                        .append("\n")
                        .append("     */")
                        .append("\n");
            }

            // swagger
            sb.append("    @ApiModelProperty(value= \"")
                    .append(column.getWholeComment())
                    .append("\")\n");


            // 主键修饰
            if (column.isMainKey()){
                if (column.isOnly()){
                    sb.append("    ")
                            .append("@TableId(value = \"")
                            .append(column.getName())
                            .append("\", type = IdType.AUTO)")
                            .append("\n");
                } else {
                    sb.append("    ")
                            .append("@TableId(value = \"")
                            .append(column.getName())
                            .append("\", type = IdType.INPUT)")
                            .append("\n");
                }

            }

            if (column.getName().equals("deleted")) {
                entityIm.append("import com.baomidou.mybatisplus.annotation.TableLogic;\n");
                sb.append("    ")
                        .append("@TableLogic\n");
            }

            if ("Date".equals(column.getType())){
                if (setDateTimeFormat){
                    entityIm.append("import org.springframework.format.annotation.DateTimeFormat;").append("\n");
                    setDateTimeFormat = false;
                }
                sb.append("    ")
                        .append("@DateTimeFormat(pattern=\"yyyy-MM-dd HH:mm:ss\")")
                        .append("\n");
            }

            sb.append("    ")
                    .append("private ")
                    .append(column.getType())
                    .append(" ")
                    .append(column.getHumpName())
                    .append(";")
                    .append("\n")
                    .append("\n");
        }

        // default constructor
        sb.append("    public ").append(fullEntityName).append("() {}\n\n");
        // full constructor
        sb.append("    public ").append(fullEntityName).append("(");
        for (Column column : columns){
            if (column.isOnly()){ continue;}
            sb.append(column.getType()).append(" ").append(column.getHumpName()).append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        sb.append(") {\n");
        for (Column column : columns){
            if (column.isPrimaryKey()){ continue;}
            sb.append("        this.").append(column.getHumpName()).append(" = ").append(column.getHumpName()).append(";\n");
        }
        sb.append("    }\n\n");
        // constructor tips
        sb.append("//    ").append(fullEntityName).append(" ").append(simpleEntityName).append(" = new ").append(fullEntityName).append("(\n");
        for (int i = 0; i<columns.size(); i++) {
            if (columns.get(i).isOnly()){ continue;}
            sb.append("//            null");
            if (i < columns.size()-1){
                sb.append(",");
            }
            sb.append("    // ").append(columns.get(i).getComment()).append(columns.get(i).isNotNull()?"[非空]":"");
            if (i < columns.size()-1){
                sb.append("\n");
            }
        }
        sb.append("\n//    );\n\n");

        // get set
        for (Column column : columns){
            // 时间字段增加$格式化
            if ("Date".equals(column.getType())){
                sb.append("    public String get")
                        .append(column.getHumpName().substring(0, 1).toUpperCase()).append(column.getHumpName().substring(1))
                        .append("\\$")
                        .append("(){\n")
                        .append("        if (Cools.isEmpty(this.").append(column.getHumpName()).append(")){\n")
                        .append("            return \"\";\n")
                        .append("        }\n")
                        .append("        return new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\").format(this.")
                        .append(column.getHumpName())
                        .append(");\n")
                        .append("    }\n\n");
                // 枚举字段增加$格式化
            } else if (!Cools.isEmpty(column.getEnums())){
                if (!column.getHumpName().equals("deleted")) {
                    sb.append("    public String get")
                            .append(column.getHumpName().substring(0, 1).toUpperCase()).append(column.getHumpName().substring(1))
                            .append("\\$")
                            .append("(){\n")
                            .append("        if (null == this.").append(column.getHumpName()).append("){ return null; }\n")
                            .append("        switch (this.").append(column.getHumpName()).append("){\n");
                    for (Map<String, Object> map : column.getEnums()){
                        for (Map.Entry<String, Object> entry : map.entrySet()){
                            sb.append("            case ").append(entry.getKey()).append(":\n")
                                    .append("                return \"").append(entry.getValue()).append("\";\n");
                        }
                    }
                    sb.append("            default:\n")
                            .append("                return String.valueOf(this.").append(column.getHumpName()).append(");\n")
                            .append("        }\n")
                            .append("    }\n\n");
                }
            }

            // 外键修饰
            if (!Cools.isEmpty(column.getForeignKey()) && !column.getForeignKey().equals("Tenant")){
                sb.append("    public String get").append(column.getHumpName().substring(0, 1).toUpperCase()).append(column.getHumpName().substring(1)).append("\\$").append("(){\n")
                        .append("        ").append(column.getForeignKey()).append("Service service = SpringUtils.getBean(").append(column.getForeignKey()).append("Service.class);\n")
                        .append("        ").append(column.getForeignKey()).append(" ").append(GeneratorUtils.firstCharConvert(column.getForeignKey()))
                        .append(" = service.getById(this.").append(column.getHumpName()).append(");\n")
                        .append("        if (!Cools.isEmpty(").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append(")){\n")
                        .append("            return String.valueOf(").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append(".get").append(column.getForeignKeyMajor()).append("());\n")
                        .append("        }\n")
                        .append("        return null;\n")
                        .append("    }\n\n");
            }

        }
        entityImport = entityIm.toString();
        return sb.toString();
    }

    /**********************************************************************************************/
    /*********************************** Controller动态字段 *****************************************/
    /**********************************************************************************************/

    private String createPrimaryMsg(){
        String defaultMajor = "id";
        boolean havePrimary = false;
        for (Column column: columns){
            if (column.isPrimaryKey()){
                defaultMajor = column.getHumpName();
                havePrimary = true;
            }
        }
        if (!havePrimary) {
            for (Column column: columns){
                if (column.isMainKey()){
                    defaultMajor = column.getHumpName();
                }
            }
        }
        return defaultMajor;
    }

    private String createMajorMsg(){
        String defaultMajor = "id";
        for (Column column: columns){
            if (column.isPrimaryKey()){
                defaultMajor = column.getHumpName();
            }
            if (column.isMajor()){
                return column.getHumpName();
            }
        }
        return defaultMajor;
    }

    /**********************************************************************************************/
    /************************************** ReactCreat *******************************************/
    /**********************************************************************************************/

    private String createReactCreateContent() {
        StringBuilder sb = new StringBuilder();
        int count = 0;
        for (Column column : columns){
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }

            sb.append("                                <Grid item xs={6} display=\"flex\" gap={1}>\n");
            switch (column.getType()) {
                case "Boolean":
                    sb.append("                                    <BooleanInput\n");
                    sb.append("                                        label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                    if (columns.indexOf(column) == 1) {
                        sb.append("                                        autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                        validate={required()}\n");
                    }
                    sb.append("                                    />\n");
                    break;
                case "Short":
                case "Integer":
                case "Long":
                case "Double":
                    if (!Cools.isEmpty(column.getForeignKeyMajor())) {
                        sb.append("                                    <ReferenceInput\n");
                        sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                        sb.append("                                        reference=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append("\"\n");
                        if (count == 0) {
                            sb.append("                                        autoFocus\n");
                        }
                        sb.append("                                    >\n");
                        sb.append("                                        <AutocompleteInput\n");
                        sb.append("                                            label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                        sb.append("                                            optionText=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append("\"\n");
                        sb.append("                                            filterToQuery={(val) => ({ ").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append(": val })}\n");
                        if (column.isNotNull()) {
                            sb.append("                                            validate={required()}\n");
                        }
                        sb.append("                                        />\n");
                        sb.append("                                    </ReferenceInput>\n");
                    } else {
                        if (Cools.isEmpty(column.getEnums())) {
                            sb.append("                                    <NumberInput\n");
                            sb.append("                                        label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                            sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                            if (count == 0) {
                                sb.append("                                        autoFocus\n");
                            }
                            if (column.isNotNull()) {
                                sb.append("                                        validate={required()}\n");
                            }
                            sb.append("                                    />\n");
                        } else {
                            sb.append("                                    <SelectInput\n");
                            sb.append("                                        label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                            sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                            sb.append("                                        choices={[\n");
                            for (Map<String, Object> map : column.getEnums()) {
                                for (Map.Entry<String, Object> entry : map.entrySet()){
                                    sb.append("                                            { id: ").append(entry.getKey()).append(", name: '").append(entry.getValue()).append("' },\n");
                                }
                            }
                            sb.append("                                        ]}\n");
                            sb.append("                                    />\n");
                        }
                    }
                    break;
                case "String":
                    sb.append("                                    <TextInput\n");
                    sb.append("                                        label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                    sb.append("                                        parse={v => v}\n");
                    if (count == 0) {
                        sb.append("                                        autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                        validate={required()}\n");
                    }
                    sb.append("                                    />\n");
                    break;
                case "Date":
                    sb.append("                                    <DateInput\n");
                    sb.append("                                        label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                        source=\"").append(column.getHumpName()).append("\"\n");
                    if (count == 0) {
                        sb.append("                                        autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                        validate={required()}\n");
                    }
                    sb.append("                                    />\n");
                    break;
                default:
                    break;
            }

            sb.append("                                </Grid>\n");
            count++;
        }
        return sb.toString();
    }

    /**********************************************************************************************/
    /************************************** ReactEdit *******************************************/
    /**********************************************************************************************/

    private String createReactEditContent() {
        StringBuilder sb = new StringBuilder();
        int count = 0;
        for (int i = 0; i < columns.size(); i++) {
            Column column = columns.get(i);
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }

            sb.append("                        <Stack direction='row' gap={2}>\n");

            switch (column.getType()) {
                case "Boolean":
                    sb.append("                            <BooleanInput\n");
                    sb.append("                                label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                    if (columns.indexOf(column) == 1) {
                        sb.append("                                autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                validate={required()}\n");
                    }
                    sb.append("                            />\n");
                    break;
                case "Short":
                case "Integer":
                case "Long":
                case "Double":
                    if (!Cools.isEmpty(column.getForeignKeyMajor())) {
                        sb.append("                            <ReferenceInput\n");
                        sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                        sb.append("                                reference=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append("\"\n");
                        sb.append("                                perPage={REFERENCE_INPUT_PAGESIZE}\n");
                        if (count == 0) {
                            sb.append("                                autoFocus\n");
                        }
                        sb.append("                            >\n");
                        sb.append("                                <AutocompleteInput\n");
                        sb.append("                                    label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                        sb.append("                                    optionText=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append("\"\n");
                        sb.append("                                    filterToQuery={(val) => ({ ").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append(": val })}\n");
                        if (column.isNotNull()) {
                            sb.append("                                    validate={required()}\n");
                        }
                        sb.append("                                />\n");
                        sb.append("                            </ReferenceInput>\n");
                    } else {
                        if (Cools.isEmpty(column.getEnums())) {
                            sb.append("                            <NumberInput\n");
                            sb.append("                                label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                            sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                            if (count == 0) {
                                sb.append("                                autoFocus\n");
                            }
                            if (column.isNotNull()) {
                                sb.append("                                validate={required()}\n");
                            }
                            sb.append("                            />\n");
                        } else {
                            sb.append("                            <SelectInput\n");
                            sb.append("                                label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                            sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                            sb.append("                                choices={[\n");
                            for (Map<String, Object> map : column.getEnums()) {
                                for (Map.Entry<String, Object> entry : map.entrySet()){
                                    sb.append("                                    { id: ").append(entry.getKey()).append(", name: '").append(entry.getValue()).append("' },\n");
                                }
                            }
                            sb.append("                                ]}\n");
                            if (columns.indexOf(column) == 1) {
                                sb.append("                                autoFocus\n");
                            }
                            if (column.isNotNull()) {
                                sb.append("                                validate={required()}\n");
                            }
                            sb.append("                            />\n");
                        }
                    }
                    break;
                case "String":
                    sb.append("                            <TextInput\n");
                    sb.append("                                label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                    sb.append("                                parse={v => v}\n");
                    if (count == 0) {
                        sb.append("                                autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                validate={required()}\n");
                    }
                    sb.append("                            />\n");
                    break;
                case "Date":
                    sb.append("                            <DateInput\n");
                    sb.append("                                label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                    sb.append("                                source=\"").append(column.getHumpName()).append("\"\n");
                    if (count == 0) {
                        sb.append("                                autoFocus\n");
                    }
                    if (column.isNotNull()) {
                        sb.append("                                validate={required()}\n");
                    }
                    sb.append("                            />\n");
                    break;
                default:
                    break;
            }

            sb.append("                        </Stack>\n");
            count++;
        }

        return sb.toString();
    }

    /**********************************************************************************************/
    /************************************** ReactList ********************************************/
    /**********************************************************************************************/

    private String createReactListContent() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < columns.size(); i++) {
            Column column = columns.get(i);
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }
            switch (column.getType()) {
                case "Boolean":
                    sb.append("                    <BooleanField source=\"").append(column.getHumpName()).append("Bool\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" sortable={false} />\n");
                    break;
                case "Short":
                case "Integer":
                case "Long":
                case "Double":
                    if (!Cools.isEmpty(column.getForeignKeyMajor())) {
                        sb.append("                    <ReferenceField source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" reference=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append("\" link={false} sortable={false}>\n");
                        sb.append("                        <TextField source=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append("\" />\n");
                        sb.append("                    </ReferenceField>\n");
                    } else {
                        if (Cools.isEmpty(column.getEnums())) {
                            sb.append("                    <NumberField source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />\n");
                        } else {
                            sb.append("                    <TextField source=\"").append(column.getHumpName()).append("\\$").append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" sortable={false} />\n");
                        }
                    }
                    break;
                case "String":
                    sb.append("                    <TextField source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />\n");
                    break;
                case "Date":
                    sb.append("                    <DateField source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" showTime />\n");
                    break;
                default:
                    break;
            }
        }
        return sb.toString();
    }

    private String createReactListFilterRContent() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < columns.size(); i++) {
            Column column = columns.get(i);
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }
            switch (column.getType()) {
                case "Boolean":
                    sb.append("    <BooleanInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />,\n");
                    break;
                case "Short":
                case "Integer":
                case "Long":
                case "Double":
                    if (!Cools.isEmpty(column.getForeignKeyMajor())) {
                        sb.append("    <ReferenceInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" reference=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKey())).append("\">\n");
                        sb.append("        <AutocompleteInput label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" optionText=\"").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append("\" filterToQuery={(val) => ({ ").append(GeneratorUtils.firstCharConvert(column.getForeignKeyMajor())).append(": val })} />\n");
                        sb.append("    </ReferenceInput>,\n");
                    } else {
                        if (Cools.isEmpty(column.getEnums())) {
                            sb.append("    <NumberInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />,\n");
                        } else {
                            sb.append("    <SelectInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\"\n");
                            sb.append("        choices={[\n");
                            for (Map<String, Object> map : column.getEnums()) {
                                for (Map.Entry<String, Object> entry : map.entrySet()){
                                    sb.append("            { id: ").append(entry.getKey()).append(", name: '").append(entry.getValue()).append("' },\n");
                                }
                            }
                            sb.append("        ]}\n");
                            sb.append("    />,\n");
                        }
                    }
                    break;
                case "String":
                    sb.append("    <TextInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />,\n");
                    break;
                case "Date":
                    sb.append("    <DateInput source=\"").append(column.getHumpName()).append("\" label=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" />,\n");
                    break;
                default:
                    break;
            }
        }
        return sb.toString();
    }

    /**********************************************************************************************/
    /************************************** ReactPanel ********************************************/
    /**********************************************************************************************/

    private String createReactPanelContent() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < columns.size(); i++) {
            Column column = columns.get(i);
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }

            // 特殊显示
            boolean specialShow = false;
            if ("Date".equals(column.getType()) || !Cools.isEmpty(column.getEnums()) || !Cools.isEmpty(column.getForeignKeyMajor())) {
                specialShow = true;
            }

            sb.append("                        <Grid item xs={6}>\n");
            sb.append("                            <PanelTypography\n");
            sb.append("                                title=\"table.field.").append(simpleEntityName).append(".").append(column.getHumpName()).append("\" \n");
            sb.append("                                property={record.").append(column.getHumpName()).append(specialShow?"\\$":"").append("}\n");
            sb.append("                            />\n");
            sb.append("                        </Grid>\n");
        }

        return sb.toString();
    }

    /**********************************************************************************************/
    /************************************** Locale ********************************************/
    /**********************************************************************************************/

    private String createReactLocaleContent() {
        StringBuilder sb = new StringBuilder("{\n");
        for (int i = 0; i < columns.size(); i++) {
            Column column = columns.get(i);
            if (column.isPrimaryKey()
                    || column.getHumpName().equals("createTime")
                    || column.getHumpName().equals("createBy")
                    || column.getHumpName().equals("updateTime")
                    || column.getHumpName().equals("updateBy")
                    || column.getHumpName().equals("status")
                    || column.getHumpName().equals("deleted")
                    || column.getHumpName().equals("tenantId")
                    || column.getHumpName().equals("memo")
            ) {
                continue;
            }
            sb.append("    ").append(column.getHumpName()).append(": \"").append(column.getHumpName()).append("\",\n");
        }
        sb.append("},");
        return sb.toString();
    }

}