public interface ProcessorLoader {
    ProcessorBean load(ProcessorDefinition definition);
}

@Getter
@Setter
@ToString
@Accessors(chain = true)
public class ProcessorDefinition implements Serializable {
    /**
     * 后臺配置的處理器類型
     */
    private String processorType;
    /**
     * 后臺配置的處理器信息
     */
    private String processorInfo;
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        ProcessorDefinition that = (ProcessorDefinition) o;
        return Objects.equals(processorType, that.processorType) && Objects.equals(processorInfo, that.processorInfo);
    }
    @Override
    public int hashCode() {
        return Objects.hash(processorType, processorInfo);
    }
}

@Getter
@Setter
@Accessors(chain = true)
public class ProcessorBean {
    /**
     * 真正用來執(zhí)行邏輯的處理器對象
     */
    private transient BasicProcessor processor;
    /**
     * 加載該處理器對象的 classLoader，可空，空則使用 {@link Object#getClass()#getClassLoader() 代替}
     */
    private transient ClassLoader classLoader;
}

@Slf4j
public class PowerJobProcessorLoader implements ProcessorLoader {
    private final List<ProcessorFactory> processorFactoryList;
    private final Map<ProcessorDefinition, ProcessorBean> def2Bean = new ConcurrentHashMap<>(128);
    public PowerJobProcessorLoader(List<ProcessorFactory> processorFactoryList) {
        this.processorFactoryList = processorFactoryList;
    }
    @Override
    public ProcessorBean load(ProcessorDefinition definition) {
        return def2Bean.computeIfAbsent(definition, ignore -> {
            final String processorType = definition.getProcessorType();
            log.info("[ProcessorFactory] start to load Processor: {}", definition);
            for (ProcessorFactory pf : processorFactoryList) {
                final String pfName = pf.getClass().getSimpleName();
                if (!Optional.ofNullable(pf.supportTypes()).orElse(Collections.emptySet()).contains(processorType)) {
                    log.info("[ProcessorFactory] [{}] can't load type={}, skip!", pfName, processorType);
                    continue;
                }
                log.info("[ProcessorFactory] [{}] try to load processor: {}", pfName, definition);
                try {
                    ProcessorBean processorBean = pf.build(definition);
                    if (processorBean != null) {
                        log.info("[ProcessorFactory] [{}] load processor successfully: {}", pfName, definition);
                        return processorBean;
                    }
                } catch (Throwable t) {
                    log.error("[ProcessorFactory] [{}] load processor failed: {}", pfName, definition, t);
                }
            }
            throw new PowerJobException("fetch Processor failed, please check your processorType and processorInfo config");
        });
    }
}

public interface ProcessorFactory {
    /**
     * 支持的處理器類型，類型不匹配則跳過該 ProcessorFactory 的加載邏輯
     * 對應的是控制臺的'處理器類型' TAB，不做任何定制的情況下，取值范圍為 {@link ProcessorType#name()}
     * @return 支持的處理器類型
     */
    Set<String> supportTypes();
    /**
     * 根據處理器定義構建處理器對象
     * 注意：Processor 為單例對象，即 PowerJob 對每一個 ProcessorBean 只調用一次 build 方法
     * @param processorDefinition 處理器定義
     * @return null or ProcessorBean
     */
    ProcessorBean build(ProcessorDefinition processorDefinition);
}

@Slf4j
public class BuiltInDefaultProcessorFactory implements ProcessorFactory {
    @Override
    public Set<String> supportTypes() {
        return Sets.newHashSet(ProcessorType.BUILT_IN.name());
    }
    @Override
    public ProcessorBean build(ProcessorDefinition processorDefinition) {
        String className = processorDefinition.getProcessorInfo();
        try {
            Class<?> clz = Class.forName(className);
            BasicProcessor basicProcessor = (BasicProcessor) clz.getDeclaredConstructor().newInstance();
            return new ProcessorBean()
                    .setProcessor(basicProcessor)
                    .setClassLoader(basicProcessor.getClass().getClassLoader());
        }catch (Exception e) {
            log.warn("[ProcessorFactory] load local Processor(className = {}) failed.", className, e);
        }
        return null;
    }
}

@Slf4j
public class JarContainerProcessorFactory implements ProcessorFactory {
    private final WorkerRuntime workerRuntime;
    public JarContainerProcessorFactory(WorkerRuntime workerRuntime) {
        this.workerRuntime = workerRuntime;
    }
    @Override
    public Set<String> supportTypes() {
        return Sets.newHashSet(ProcessorType.EXTERNAL.name());
    }
    @Override
    public ProcessorBean build(ProcessorDefinition processorDefinition) {
        String processorInfo = processorDefinition.getProcessorInfo();
        String[] split = processorInfo.split("#");
        String containerName = split[0];
        String className = split[1];
        log.info("[ProcessorFactory] try to load processor({}) in container({})", className, containerName);
        OmsContainer omsContainer = OmsContainerFactory.fetchContainer(Long.valueOf(containerName), workerRuntime);
        if (omsContainer != null) {
            return new ProcessorBean()
                    .setProcessor(omsContainer.getProcessor(className))
                    .setClassLoader(omsContainer.getContainerClassLoader());
        } else {
            log.warn("[ProcessorFactory] load container failed. processor info : {}", processorInfo);
        }
        return null;
    }
}

@Slf4j
public abstract class AbstractBuildInSpringProcessorFactory implements ProcessorFactory {
    protected final ApplicationContext applicationContext;
    protected AbstractBuildInSpringProcessorFactory(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
    @Override
    public Set<String> supportTypes() {
        return Sets.newHashSet(ProcessorType.BUILT_IN.name());
    }
    protected boolean checkCanLoad() {
        try {
            ApplicationContext.class.getClassLoader();
            return applicationContext != null;
        } catch (Throwable ignore) {
        }
        return false;
    }
    @SuppressWarnings("unchecked")
    protected static <T> T getBean(String className, ApplicationContext ctx) throws Exception {
        // 0. 嘗試直接用 Bean 名稱加載
        try {
            final Object bean = ctx.getBean(className);
            if (bean != null) {
                return (T) bean;
            }
        } catch (Exception ignore) {
        }
        // 1. ClassLoader 存在，則直接使用 clz 加載
        ClassLoader classLoader = ctx.getClassLoader();
        if (classLoader != null) {
            return (T) ctx.getBean(classLoader.loadClass(className));
        }
        // 2. ClassLoader 不存在(系統(tǒng)類加載器不可見)，嘗試用類名稱小寫加載
        String[] split = className.split("\\.");
        String beanName = split[split.length - 1];
        // 小寫轉大寫
        char[] cs = beanName.toCharArray();
        cs[0] += 32;
        String beanName0 = String.valueOf(cs);
        log.warn("[SpringUtils] can't get ClassLoader from context[{}], try to load by beanName:{}", ctx, beanName0);
        return (T) ctx.getBean(beanName0);
    }
}

@Slf4j
public class BuiltInSpringProcessorFactory extends AbstractBuildInSpringProcessorFactory {
    public BuiltInSpringProcessorFactory(ApplicationContext applicationContext) {
        super(applicationContext);
    }
    @Override
    public ProcessorBean build(ProcessorDefinition processorDefinition) {
        try {
            boolean canLoad = checkCanLoad();
            if (!canLoad) {
                log.info("[ProcessorFactory] can't find Spring env, this processor can't load by 'BuiltInSpringProcessorFactory'");
                return null;
            }
            String processorInfo = processorDefinition.getProcessorInfo();
            //用于區(qū)分方法級別的參數
            if (processorInfo.contains("#")) {
                return null;
            }
            BasicProcessor basicProcessor = getBean(processorInfo, applicationContext);
            return new ProcessorBean()
                    .setProcessor(basicProcessor)
                    .setClassLoader(basicProcessor.getClass().getClassLoader());
        } catch (NoSuchBeanDefinitionException ignore) {
            log.warn("[ProcessorFactory] can't find the processor in SPRING");
        } catch (Throwable t) {
            log.warn("[ProcessorFactory] load by BuiltInSpringProcessorFactory failed. If you are using Spring, make sure this bean was managed by Spring", t);
        }
        return null;
    }
}

@Slf4j
public class BuildInSpringMethodProcessorFactory extends AbstractBuildInSpringProcessorFactory {
    private static final List<String> jobHandlerRepository = new LinkedList<>();
    private final static String DELIMITER = "#";
    public BuildInSpringMethodProcessorFactory(ApplicationContext applicationContext) {
        super(applicationContext);
    }
    @Override
    public ProcessorBean build(ProcessorDefinition processorDefinition) {
        try {
            boolean canLoad = checkCanLoad();
            if (!canLoad) {
                log.info("[ProcessorFactory] can't find Spring env, this processor can't load by 'BuildInSpringMethodProcessorFactory'");
                return null;
            }
            String processorInfo = processorDefinition.getProcessorInfo();
            if (!processorInfo.contains(DELIMITER)) {
                log.info("[ProcessorFactory] can't parse processorDefinition, this processor can't load by 'BuildInSpringMethodProcessorFactory'");
                return null;
            }
            String[] split = processorInfo.split(DELIMITER);
            String methodName = split[1];
            String className = split[0];
            Object bean = getBean(className,applicationContext);
            Method[] methods = bean.getClass().getDeclaredMethods();
            for (Method method : methods) {
                PowerJobHandler powerJob = method.getAnnotation(PowerJobHandler.class);
                if (powerJob == null) {
                    continue;
                }
                String name = powerJob.name();
                //匹配到和頁面定義相同的methodName
                if (!name.equals(methodName)) {
                    continue;
                }
                if (name.trim().length() == 0) {
                    throw new RuntimeException("method-jobhandler name invalid, for[" + bean.getClass() + "#" + method.getName() + "] .");
                }
                if (containsJobHandler(name)) {
                    throw new RuntimeException("jobhandler[" + name + "] naming conflicts.");
                }
                method.setAccessible(true);
                registerJobHandler(methodName);
                MethodBasicProcessor processor = new MethodBasicProcessor(bean, method);
                return new ProcessorBean()
                        .setProcessor(processor)
                        .setClassLoader(processor.getClass().getClassLoader());
            }
        } catch (NoSuchBeanDefinitionException ignore) {
            log.warn("[ProcessorFactory] can't find the processor in SPRING");
        } catch (Throwable t) {
            log.warn("[ProcessorFactory] load by BuiltInSpringProcessorFactory failed. If you are using Spring, make sure this bean was managed by Spring", t);
        }
        return null;
    }
    public static void registerJobHandler(String name) {
        jobHandlerRepository.add(name);
    }
    private boolean containsJobHandler(String name) {
        return jobHandlerRepository.contains(name);
    }
}