package com.qianwen.core.scanner.modular;

import cn.hutool.core.util.StrUtil;
import io.swagger.annotations.ApiOperation;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.scanner.config.properties.ScannerProperties;
import com.qianwen.core.scanner.modular.annotation.DeleteResource;
import com.qianwen.core.scanner.modular.annotation.GetResource;
import com.qianwen.core.scanner.modular.annotation.PostResource;
import com.qianwen.core.scanner.modular.annotation.PutResource;
import com.qianwen.core.scanner.modular.constants.ConfigPrefixConstants;
import com.qianwen.core.scanner.modular.factory.ApiResourceFactory;
import com.qianwen.core.scanner.modular.model.ResourceDefinition;
import com.qianwen.core.scanner.modular.stereotype.ApiResource;
import com.qianwen.core.scanner.modular.util.AopTargetUtils;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/* loaded from: blade-starter-scanner-9.3.0.0-SNAPSHOT.jar:org/springblade/core/scanner/modular/ApiResourceScanner.class */
public class ApiResourceScanner implements BeanPostProcessor {
    private static final Logger log = LoggerFactory.getLogger(ApiResourceScanner.class);
    private ApiResourceFactory apiResourceFactory;
    private ScannerProperties scannerProperties;

    public ApiResourceScanner(ApiResourceFactory apiResourceFactory, ScannerProperties scannerProperties, String springApplicationName) {
        this.apiResourceFactory = apiResourceFactory;
        this.scannerProperties = scannerProperties;
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (!this.scannerProperties.getOpen().booleanValue()) {
            return bean;
        }
        if ("oauth2ClientContext".equals(beanName)) {
            return bean;
        }
        Object aopTarget = AopTargetUtils.getTarget(bean);
        if (aopTarget == null) {
            aopTarget = bean;
        }
        Class<?> clazz = aopTarget.getClass();
        boolean controllerFlag = getControllerFlag(clazz);
        if (!controllerFlag) {
            return bean;
        }
        List<ResourceDefinition> apiResources = doScan(clazz);
        persistApiResources(apiResources);
        return bean;
    }

    private boolean getControllerFlag(Class<?> clazz) {
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            if (RestController.class.equals(annotation.annotationType()) || Controller.class.equals(annotation.annotationType())) {
                return true;
            }
        }
        return false;
    }

    private List<ResourceDefinition> doScan(Class<?> clazz) {
        ApiResource classApiAnnotation = (ApiResource) clazz.getAnnotation(ApiResource.class);
        if (classApiAnnotation != null) {
            if (StrUtil.isEmpty(classApiAnnotation.code())) {
                String className = clazz.getSimpleName();
                int controllerIndex = className.indexOf("Controller");
                if (controllerIndex == -1) {
                    throw new IllegalArgumentException("controller class name is not illegal, it should end with Controller!");
                }
                String code = className.substring(0, controllerIndex);
                this.apiResourceFactory.bindResourceName(StrUtil.toUnderlineCase(code), classApiAnnotation.name());
            } else {
                this.apiResourceFactory.bindResourceName(StrUtil.toUnderlineCase(classApiAnnotation.code()), classApiAnnotation.name());
            }
        }
        ArrayList<ResourceDefinition> apiResources = new ArrayList<>();
        Method[] declaredMethods = clazz.getDeclaredMethods();
        if (declaredMethods != null && declaredMethods.length > 0) {
            for (Method declaredMethod : declaredMethods) {
                Annotation apiResource = (ApiResource) declaredMethod.getAnnotation(ApiResource.class);
                Annotation getResource = (GetResource) declaredMethod.getAnnotation(GetResource.class);
                Annotation postResource = (PostResource) declaredMethod.getAnnotation(PostResource.class);
                Annotation putResource = (PutResource) declaredMethod.getAnnotation(PutResource.class);
                Annotation deleteResource = (DeleteResource) declaredMethod.getAnnotation(DeleteResource.class);
                Annotation annotation = null;
                if (apiResource != null) {
                    annotation = apiResource;
                }
                if (getResource != null) {
                    annotation = getResource;
                }
                if (postResource != null) {
                    annotation = postResource;
                }
                if (putResource != null) {
                    annotation = putResource;
                }
                if (deleteResource != null) {
                    annotation = deleteResource;
                }
                if (annotation != null) {
                    ResourceDefinition definition = createDefinition(clazz, declaredMethod, annotation);
                    apiResources.add(definition);
                    log.debug("扫描到资源: " + definition);
                }
            }
        }
        return apiResources;
    }

    private void persistApiResources(List<ResourceDefinition> apiResources) {
        this.apiResourceFactory.registerDefinition(apiResources);
    }

    private ResourceDefinition createDefinition(Class<?> clazz, Method method, Annotation apiResource) {
        ApiOperation annotation;
        ResourceDefinition resourceDefinition = new ResourceDefinition();
        resourceDefinition.setClassName(clazz.getSimpleName());
        resourceDefinition.setMethodName(method.getName());
        String className = resourceDefinition.getClassName();
        int controllerIndex = className.indexOf("Controller");
        if (controllerIndex == -1) {
            throw new IllegalArgumentException("controller class name is not illegal, it should end with Controller!");
        }
        String modular = className.substring(0, controllerIndex);
        resourceDefinition.setControllerCode(modular);
        ApiResource classApiAnnotation = (ApiResource) clazz.getAnnotation(ApiResource.class);
        if (classApiAnnotation != null && Func.isNotEmpty(classApiAnnotation.moduleCode())) {
            resourceDefinition.setModuleCode(classApiAnnotation.moduleCode());
        }
        String code = (String) invokeAnnotationMethod(apiResource, "code", String.class);
        if (StrUtil.isEmpty(code)) {
            resourceDefinition.setCode(StrUtil.toUnderlineCase(modular) + this.scannerProperties.getLinkSymbol() + StrUtil.toUnderlineCase(method.getName()));
        } else {
            resourceDefinition.setCode(StrUtil.toUnderlineCase(modular) + this.scannerProperties.getLinkSymbol() + StrUtil.toUnderlineCase(code));
        }
        String name = (String) invokeAnnotationMethod(apiResource, "name", String.class);
        String[] path = (String[]) invokeAnnotationMethod(apiResource, "path", String[].class);
        String[] value = (String[]) invokeAnnotationMethod(apiResource, "value", String[].class);
        RequestMethod[] requestMethods = (RequestMethod[]) invokeAnnotationMethod(apiResource, "method", RequestMethod[].class);
        Boolean buttonFlag = (Boolean) invokeAnnotationMethod(apiResource, "buttonFlag", Boolean.class);
        resourceDefinition.setName(name);
        resourceDefinition.setButtonFlag(buttonFlag);
        if (CollectionUtil.isNotEmpty(Arrays.asList(path))) {
            if (!path[0].startsWith("/") && Func.isNotEmpty(path[0])) {
                path[0] = "/" + path[0];
            }
            resourceDefinition.setUrl(getControllerClassRequestPath(clazz) + path[0].replaceAll("\\{[^}]*\\}", "*"));
        } else if (CollectionUtil.isNotEmpty(Arrays.asList(value))) {
            if (!value[0].startsWith("/") && Func.isNotEmpty(value[0])) {
                value[0] = "/" + value[0];
            }
            resourceDefinition.setUrl(getControllerClassRequestPath(clazz) + value[0].replaceAll("\\{[^}]*\\}", "*"));
        } else {
            resourceDefinition.setUrl(getControllerClassRequestPath(clazz));
        }
        List<String> splitPath = StringUtil.splitTrim(resourceDefinition.getUrl(), ConfigPrefixConstants.SPLIT_CHAR.charValue());
        if (splitPath.size() > 1 && Func.isEmpty(resourceDefinition.getModuleCode())) {
            resourceDefinition.setModuleCode(splitPath.get(0));
        }
        if (Func.isEmpty(resourceDefinition.getModuleCode())) {
            resourceDefinition.setModuleCode(ConfigPrefixConstants.DEFAULT_MODULE_CODE);
        }
        String methodNames = "";
        for (RequestMethod requestMethod : requestMethods) {
            methodNames = methodNames + requestMethod.name() + ",";
        }
        resourceDefinition.setHttpMethod(StrUtil.removeSuffix(methodNames, ","));
        resourceDefinition.setCreateTime(new Date());
        if (Func.isEmpty(resourceDefinition.getName()) && (annotation = method.getAnnotation(ApiOperation.class)) != null) {
            resourceDefinition.setName(annotation.value());
        }
        return resourceDefinition;
    }

    private String getControllerClassRequestPath(Class<?> clazz) {
        String result;
        ApiResource controllerRequestMapping = (ApiResource) clazz.getDeclaredAnnotation(ApiResource.class);
        if (controllerRequestMapping == null) {
            result = "";
        } else {
            String[] paths = controllerRequestMapping.path();
            String[] values = controllerRequestMapping.value();
            if (paths.length > 0) {
                result = paths[0];
            } else if (values.length > 0) {
                result = values[0];
            } else {
                result = "";
            }
        }
        return "/" + result;
    }

    private <T> T invokeAnnotationMethod(Annotation apiResource, String methodName, Class<T> resultType) {
        try {
            Class<? extends Annotation> annotationType = apiResource.annotationType();
            Method method = annotationType.getMethod(methodName, new Class[0]);
            return (T) method.invoke(apiResource, new Object[0]);
        } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            log.error("扫描api资源时出错!", e);
            throw new RuntimeException("扫描api资源时出错!");
        }
    }
}