package tech.riemann.ims;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.ConstVal;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.BeetlTemplateEngine;
import org.nutz.lang.Lang;
import org.nutz.lang.Strings;
import org.nutz.lang.util.NutMap;
import tech.riemann.ims.entity.IdBaseEntity;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;

public class MysqlGenerator {

    static String jdbcUrl = "jdbc:mysql://mysql.riemann.tech:13307/hx_jxc?characterEncoding=UTF-8";
    static String user = "hx_jxc";
    static String password = "BBSzc7cnbAhLAenT";
    static String packageName = "tech.riemann";
    static String module = "ims";

    static Mode mode = Mode.BOTH;

    public enum Mode {
        NUTZ,
        MYBATIS,
        BOTH
    }

    public static String[] prefixes(String... addOn) {
        List<String> pool = Lang.array2list("abcdefghijklmnopqrstuvwxyz".toCharArray(), char.class)
                                .stream()
                                .map(c -> c + "")
                                .toList();

        List<String> prefixes = pool.stream().map(item -> item + "_").collect(Collectors.toList());

        pool.stream().forEach(item -> {
            pool.stream().forEach(item1 -> {
                prefixes.add(String.format("%s%s_", item, item1));
            });
        });
        if (Lang.isNotEmpty(addOn)) {
            Arrays.stream(addOn).forEach(add -> {
                Arrays.stream(Lang.collection2array(prefixes)).forEach(p -> {
                    prefixes.add(String.format("%s%s_", p, add));
                });
            });
        }
        return Lang.collection2array(prefixes);
    }

    /**
     * RUN THIS TO GEN CODE
     */
    public static void main(String[] args) {

        String projectPath = System.getProperty("user.dir");
        List<String> relationTables = Lang.list();

        NutMap.NEW()
               .addv("material", Lang.array("t_stocktaking_scan_exceptional_data"))
              .entrySet()
              .stream()
              .forEach(e -> {

                  FastAutoGenerator.create(jdbcUrl, user, password)
                                   .globalConfig(builder -> {
                                       builder
                                              .author("mayong)")
                                              .enableSpringdoc()
                                              .commentDate(() -> LocalDateTime.now()
                                                                              .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss",
                                                                                                                  Locale.CHINESE)))
                                              .disableOpenDir()
                                              .dateType(DateType.TIME_PACK)
                                              .outputDir(projectPath + "/src/main/java");
                                   })
                                   .injectionConfig(builder -> builder.customMap(Collections.singletonMap("mode", mode)))
                                   .packageConfig(builder -> {
                                       builder.parent(packageName)
                                              .moduleName(module)
                                              .entity(String.format("entity.%s", e.getKey()))
                                              .mapper(String.format("mapper.%s", e.getKey()))
                                              .service(String.format("service.%s", e.getKey()))
                                              .serviceImpl(String.format("service.%s.impl", e.getKey()))
                                              .controller(String.format("controller.platform.%s", e.getKey()))
                                              .pathInfo(Collections.singletonMap(OutputFile.xml,
                                                                                 String.format("%s/src/main/resources/mapper_",
                                                                                               projectPath)));
                                   })
                                   .strategyConfig(builder -> {
                                       builder.addTablePrefix("t_")
                                              .addFieldPrefix(prefixes(e.getKey()))
                                              .addInclude((String[]) e.getValue()) // 指定表生成
                                              .entityBuilder()
                                              .javaTemplate(String.format("templates/%s/entity.java", mode.name().toLowerCase()))
                                              .enableLombok()
                                              .enableFileOverride()
                                              .enableChainModel()
                                              .enableRemoveIsPrefix()
                                              .enableTableFieldAnnotation()
                                              .superClass(IdBaseEntity.class)
                                              .addSuperEntityColumns(
                                                                     "id",
                                                                     "created_by",
                                                                     "created_time",
                                                                     "updated_by",
                                                                     // "f_budget_id",
                                                                     // "f_matter_id",
                                                                     // "f_remark",
                                                                     "updated_time")
                                              .naming(NamingStrategy.underline_to_camel)
                                              .controllerBuilder()
                                              .template(String.format("templates/%s/controller.java", mode.name().toLowerCase()))
                                              .enableRestStyle()
                                              .enableHyphenStyle()
                                              .convertFileName(entityName -> {
                                                  boolean isRelation = relationTables.stream().anyMatch(item -> {
                                                      String name = NamingStrategy.capitalFirst(
                                                                                                NamingStrategy.underlineToCamel(
                                                                                                                                item.replace(String.format("t_%s_",
                                                                                                                                                           e.getKey()),
                                                                                                                                             "")));
                                                      return Strings.equals(entityName, name);
                                                  });
                                                  return isRelation ? null : entityName + ConstVal.CONTROLLER;
                                              })
                                              .mapperBuilder()
                                              .mapperTemplate(String.format("/templates/%s/mapper.java", mode.name().toLowerCase()))
                                              .mapperXmlTemplate(mode == Mode.NUTZ ? ""
                                                                                   : String.format("/templates/%s/mapper.xml", mode.name().toLowerCase()))
                                              .convertMapperFileName(entityName -> mode == Mode.NUTZ ? entityName + "Repository" : entityName + ConstVal.MAPPER)
                                              .convertXmlFileName(entityName -> mode == Mode.NUTZ ? null : entityName + ConstVal.MAPPER)
                                              .superClass(BaseMapper.class)
                                              .enableBaseResultMap()
                                              .enableBaseColumnList()
                                              .serviceBuilder()
                                              .serviceTemplate(String.format("/templates/%s/service.java", mode.name().toLowerCase()))
                                              .serviceImplTemplate(String.format("/templates/%s/serviceImpl.java", mode.name().toLowerCase()))
                                              .convertServiceFileName(entityName -> (mode == Mode.NUTZ ? "" : "I")
                                                                                    + entityName
                                                                                    + ConstVal.SERVICE)
                                              .convertServiceImplFileName(entityName -> entityName + ConstVal.SERVICE_IMPL);
                                   })
                                   .templateEngine(new BeetlTemplateEngine())
                                   .execute();
              });

    }
}