package com.qianwen.smart.core.auto.factories;


import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedOptions;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.tools.FileObject;
import javax.tools.StandardLocation;

import com.qianwen.smart.core.auto.annotation.AutoIgnore;
import com.qianwen.smart.core.auto.common.AbstractBladeProcessor;
import com.qianwen.smart.core.auto.common.BootAutoType;
import com.qianwen.smart.core.auto.common.MultiSetMap;


@SupportedAnnotationTypes({"*"})
@SupportedOptions({"debug"})
public class AutoFactoriesProcessor extends AbstractBladeProcessor {
	private static final String FEIGN_CLIENT_ANNOTATION = "org.springframework.cloud.openfeign.FeignClient";
    private static final String FEIGN_AUTO_CONFIGURE_KEY = "com.qianwen.core.cloud.feign.BladeFeignAutoConfiguration";
    private static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    private static final String DEVTOOLS_RESOURCE_LOCATION = "META-INF/spring-devtools.properties";
    private final MultiSetMap<String, String> factories = new MultiSetMap<>();
    private Elements elementUtils;

  
  public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    this.elementUtils = processingEnv.getElementUtils();
  }
  
  protected boolean processImpl(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (roundEnv.processingOver()) {
      generateFactoriesFiles();
    } else {
      processAnnotations(annotations, roundEnv);
    } 
    return false;
  }
  
  private void processAnnotations(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    log(annotations.toString());
    Set<? extends Element> elementSet = roundEnv.getRootElements();
    log("All Element set: " + elementSet.toString());
    Set<TypeElement> typeElementSet = (Set<TypeElement>)elementSet.stream().filter(this::isClassOrInterface).filter(e -> e instanceof TypeElement).map(e -> (TypeElement)e).collect(Collectors.toSet());
    if (typeElementSet.isEmpty()) {
      log("Annotations elementSet is isEmpty");
      return;
    } 
    for (TypeElement typeElement : typeElementSet) {
      if (isAnnotation(this.elementUtils, typeElement, AutoIgnore.class.getName())) {
        log("Found @AutoIgnore annotationElement: " + typeElement.toString());
        continue;
      } else if (isAnnotation(this.elementUtils, typeElement, FEIGN_CLIENT_ANNOTATION)) {

    	  log("Found @FeignClient Element: " + typeElement.toString());
          ElementKind elementKind = typeElement.getKind();
          if (ElementKind.INTERFACE != elementKind) {
              fatalError("@FeignClient Element " + typeElement.toString() + " 不是接口。");
          } else {
              String factoryName = typeElement.getQualifiedName().toString();
              if (!this.factories.containsVal(factoryName)) {
                  log("读取到新配置 spring.factories factoryName：" + factoryName);
                  this.factories.put(FEIGN_AUTO_CONFIGURE_KEY, factoryName);
              }
          }

      }else {
          for (BootAutoType autoType : BootAutoType.values()) {
              String annotation = autoType.getAnnotationName();
              if (isAnnotation(this.elementUtils, typeElement, annotation)) {
                  log("Found @" + annotation + " Element: " + typeElement.toString());
                  String factoryName2 = typeElement.getQualifiedName().toString();
                  if (!this.factories.containsVal(factoryName2)) {
                      log("读取到新配置 spring.factories factoryName：" + factoryName2);
                      this.factories.put(autoType.getConfigureKey(), factoryName2);
                  }
              }
          }
      }

      
    } 
  }
  
  private void generateFactoriesFiles() {
	  if (this.factories.isEmpty()) {
          return;
      }
      Filer filer = this.processingEnv.getFiler();
      try {
          FileObject factoriesFile = filer.createResource(StandardLocation.CLASS_OUTPUT, "", FACTORIES_RESOURCE_LOCATION, new Element[0]);
          FactoriesFiles.writeFactoriesFile(this.factories, factoriesFile.openOutputStream());
          String classesPath = factoriesFile.toUri().toString().split("classes")[0];
          Path projectPath = Paths.get(new URI(classesPath)).getParent();
          String projectName = projectPath.getFileName().toString();
          FileObject devToolsFile = filer.createResource(StandardLocation.CLASS_OUTPUT, "", DEVTOOLS_RESOURCE_LOCATION, new Element[0]);
          FactoriesFiles.writeDevToolsFile(projectName, devToolsFile.openOutputStream());
      } catch (IOException | URISyntaxException e) {
          fatalError(e);
      }

  }
  
  private boolean isClassOrInterface(Element e) {
    ElementKind kind = e.getKind();
    return (kind == ElementKind.CLASS || kind == ElementKind.INTERFACE);
  }
  
  private boolean isAnnotation(Elements elementUtils, Element e, String annotationFullName) {
    List<? extends AnnotationMirror> annotationList = elementUtils.getAllAnnotationMirrors(e);
    for (AnnotationMirror annotation : annotationList) {
      if (isAnnotation(annotationFullName, annotation))
        return true; 
      Element element = annotation.getAnnotationType().asElement();
      if (element.toString().startsWith("java.lang"))
        continue; 
      if (isAnnotation(elementUtils, element, annotationFullName))
        return true; 
    } 
    return false;
  }
  
  private boolean isAnnotation(String annotationFullName, AnnotationMirror annotation) {
    return annotationFullName.equals(annotation.getAnnotationType().toString());
  }
}