package com.yuanchu.limslaboratory.commandLineRunner;

import com.yuanchu.limslaboratory.annotation.AuthHandler;
import com.yuanchu.limslaboratory.mapper.MenuMapper;
import com.yuanchu.limslaboratory.mapper.RoleManageMapper;
import com.yuanchu.limslaboratory.utils.ArrayListUtil;
import com.yuanchu.limslaboratory.utils.MyClassUtil;
import com.yuanchu.limslaboratory.utils.SpringUtil;
import io.swagger.annotations.ApiOperation;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;

import java.lang.reflect.Method;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author 张宾
 * @Date 2023/8/28
 */
@Component
@Order(1)
@Slf4j
public class ResolutionRequestsCommandLineRunner implements CommandLineRunner {

    @Autowired
    private RoleManageMapper roleManageMapper;

    @SneakyThrows
    @Override
    public void run(String... args) throws Exception {
        log.info("容器生成之后执行");
        List<Class<?>> classList = MyClassUtil.getClassList("com.yuanchu.limslaboratory.controller");
        List<Map<String, String>> requestListInfo = new ArrayList<Map<String, String>>();
        classList.stream().forEach(c -> {
            Method[] methods = c.getMethods();
            //去掉对象方法
            List<Method> methodList = Arrays.stream(methods)
                    .filter(m -> !"notify".equals(m.getName()) && !"getClass".equals(m.getName())
                            && !"hashCode".equals(m.getName()) && !"toString".equals(m.getName())
                            && !"equals".equals(m.getName()) && !"wait".equals(m.getName()) && !"notifyAll".equals(m.getName()))
                    .collect(Collectors.toList());

            for (int i = 0; i < methodList.size(); i++) {
                Method method = methodList.get(i);
                boolean annotationPresent = method.isAnnotationPresent(AuthHandler.class);
                if (annotationPresent&&method.getAnnotation(AuthHandler.class).isAdd()) {
                    //获取类上请求地址
                    RequestMapping annotation = c.getAnnotation(RequestMapping.class);
                    StringBuilder builder = new StringBuilder();
                    String apiInfo = null;
                    builder.append(annotation.value()[0]);
                    //获取方法上注解
                    if (method.isAnnotationPresent(PostMapping.class)) {
                        PostMapping post = method.getAnnotation(PostMapping.class);
                        builder.append(post.value()[0]);
                    }
                    if (method.isAnnotationPresent(GetMapping.class)) {
                        GetMapping get = method.getAnnotation(GetMapping.class);
                        builder.append(get.value()[0]);
                    }
                    if (method.isAnnotationPresent(DeleteMapping.class)) {
                        DeleteMapping delete = method.getAnnotation(DeleteMapping.class);
                        builder.append(delete.value()[0]);
                    }
                    if (method.isAnnotationPresent(PutMapping.class)) {
                        PutMapping put = method.getAnnotation(PutMapping.class);
                        builder.append(put.value()[0]);
                    }
                    if (method.isAnnotationPresent(ApiOperation.class)) {
                        ApiOperation api = method.getAnnotation(ApiOperation.class);
                        apiInfo = api.value();
                    }
                    Map<String, String> map = new HashMap<String, String>();
                    AuthHandler auth = method.getAnnotation(AuthHandler.class);
                    map.put("menuId", String.valueOf(auth.menuId().getId()));
                    map.put("type",String.valueOf(auth.type().getNum()));
                    map.put("url", builder.toString());
                    map.put("name", apiInfo);
                    requestListInfo.add(map);
                }
            }
        });
        List<Map<String, String>> allInterfaces = roleManageMapper.getAllInterfaces();
        List<Map<String, String>> differentMaps = requestListInfo.stream()
                .filter(map1 -> allInterfaces.stream()
                        .map(map2 -> map2.get("url"))  // 获取指定键的值
                        .noneMatch(value2 -> value2.equals(map1.get("url")))  // 查找不同的值
                ).collect(Collectors.toList());
        if(differentMaps.size()>0){

            int insertInterfaceList = roleManageMapper.insertInterfaceList(differentMaps);
            if (insertInterfaceList>0) log.info(String.valueOf(differentMaps));log.info("新增接口成功！");
        }else {
            log.info("无需增加新的接口！");
        }

    }


}