package org.apache.karaf.boot.jpa.impl;

import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;
import javax.tools.FileObject;
import javax.tools.StandardLocation;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

import org.apache.karaf.boot.jpa.PersistentUnit;
import org.apache.karaf.boot.jpa.Property;
import org.apache.karaf.boot.jpa.Provider;

import javanet.staxutils.IndentingXMLStreamWriter;

public class JpaProcessor extends AbstractProcessor {

    private boolean useHibernate;

    public JpaProcessor() {
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return new HashSet<String>(Arrays.asList(
                PersistentUnit.class.getName()
        ));
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Map<PersistentUnit, List<? extends AnnotationMirror>> units = new HashMap<PersistentUnit, List<? extends AnnotationMirror>>();
        for (Element elem : roundEnv.getElementsAnnotatedWith(PersistentUnit.class)) {
            PersistentUnit pu = elem.getAnnotation(PersistentUnit.class);
            units.put(pu, elem.getAnnotationMirrors());
        }
        if (!units.isEmpty()) {
            try {
                FileObject o = processingEnv.getFiler().createResource(StandardLocation.SOURCE_OUTPUT,
                                                                       "", "META-INF/persistence.xml");
                process(o.openWriter(), units);
                processingEnv.getMessager().printMessage(Kind.NOTE, "Generated META-INF/persistence.xml");
            } catch (Exception e) {
                processingEnv.getMessager().printMessage(Kind.ERROR, "Error: " + e.getMessage());
            }
            try (PrintWriter w = appendResource("META-INF/org.apache.karaf.boot.bnd")) {
                w.println("Private-Package: META-INF.*");
                w.println("Meta-Persistence: META-INF/persistence.xml");
                if (useHibernate) {
                    w.println("Import-Package: org.hibernate.proxy, javassist.util.proxy");
                }
            } catch (Exception e) {
                processingEnv.getMessager().printMessage(Kind.ERROR, "Error writing to META-INF/org.apache.karaf.boot.bnd: " + e.getMessage());
            }
        }
        return true;
    }

    public void process(Writer writer, Map<PersistentUnit, List<? extends AnnotationMirror>> units) throws Exception {
        Set<String> puNames = new HashSet<String>();
        XMLOutputFactory xof =  XMLOutputFactory.newInstance();
        XMLStreamWriter w = new IndentingXMLStreamWriter(xof.createXMLStreamWriter(writer));
        w.setDefaultNamespace("http://java.sun.com/xml/ns/persistence");
        w.writeStartDocument();
        w.writeStartElement("persistence");
        w.writeAttribute("verson", "2.0");
        
        //w.println("<persistence version=\"2.0\" xmlns=\"http://java.sun.com/xml/ns/persistence\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd\">");
        for (PersistentUnit pu : units.keySet()) {
            if (pu.name() == null || pu.name().isEmpty()) {
                throw new IOException("Missing persistent unit name");
            }
            if (!puNames.add(pu.name())) {
                throw new IOException("Duplicate persistent unit name: " + pu.name());
            }
            w.writeStartElement("persistence-unit");
            w.writeAttribute("name", pu.name());
            w.writeAttribute("transaction-type", pu.transactionType().toString());
            writeElement(w, "description", pu.description());
            String providerName = getProvider(pu);
            writeElement(w, "provider", providerName);
            writeElement(w, "jta-data-source", pu.jtaDataSource());
            writeElement(w, "non-jta-data-source", pu.nonJtaDataSource());
            Map<String, String> props = new HashMap<>();
            addProperties(pu, props);
            addAnnProperties(units.get(pu), props);
            if (props.size() > 0) {
                w.writeStartElement("properties");
                for (String key : props.keySet()) {
                    w.writeEmptyElement("property");
                    w.writeAttribute("name", key);
                    w.writeAttribute("value", props.get(key));
                }
                w.writeEndElement();
            }
            w.writeEndElement();
        }
        w.writeEndElement();
        w.writeEndDocument();
        w.flush();
        w.close();
    }

    private void addProperties(PersistentUnit pu, Map<String, String> props) {
        if (pu.properties() == null) {
            return;
        }
        for (Property property : pu.properties()) {
            props.put(property.name(), property.value());
        }
    }

    private void addAnnProperties(List<? extends AnnotationMirror> annotations, Map<String, String> props)
        throws XMLStreamException {
        for (AnnotationMirror annMirror : annotations) {

            String name = null;
            for (AnnotationMirror a : processingEnv.getElementUtils().getAllAnnotationMirrors(annMirror.getAnnotationType().asElement())) {
                if (a.toString().startsWith("@org.apache.karaf.boot.jpa.PersistentUnit.ProviderProperty")) {
                    name = a.getElementValues().values().iterator().next().getValue().toString();
                    break;
                }
            }
            if (name != null) {
                String value = annMirror.getElementValues().values().iterator().next().getValue().toString();
                props.put(name, value);
            }
//                            processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation: " + annMirror);
//                            processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation type: " + annMirror.getAnnotationType());
//                            processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation annot: " + annMirror.getAnnotationType().getAnnotationMirrors());
//                            processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation annot: " + processingEnv.getElementUtils().getAllAnnotationMirrors(annMirror.getAnnotationType().asElement()));
//                            processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation values: " + annMirror.getElementValues());
//                            if (annMirror.getAnnotationType().getAnnotation(PersistentUnit.ProviderProperty.class) != null) {
//                                processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation ok");
//                            } else {
//                                processingEnv.getMessager().printMessage(Kind.MANDATORY_WARNING, "Annotation nok");
//                            }
        }
    }

    private void writeElement(XMLStreamWriter w, String localName, String content) throws XMLStreamException {
        if (content != null && !content.isEmpty()) {
            w.writeStartElement(localName);
            w.writeCharacters(content);
            w.writeEndElement();
        }
    }

    private String getProvider(PersistentUnit pu) throws IOException {
        if (pu.provider() != Provider.Default && pu.providerName() != null && !pu.providerName().isEmpty()) {
            throw new IOException("At most one of provider and providerName can be used");
        }
        if (pu.provider() != null) {
            switch (pu.provider()) {
            case Hibernate:
                useHibernate = true;
                return "org.hibernate.jpa.HibernatePersistenceProvider";
            default:
                // TODO
                throw new IOException("Unsupported provider: " + pu.provider());
            }
        } else if (pu.providerName() != null) {
            return pu.providerName();
        } else {
            return null;
        }
    }

    private PrintWriter appendResource(String resource) throws IOException {
        try {
            FileObject o = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "",
                                                                   resource);
            return new PrintWriter(o.openWriter());
        } catch (Exception e) {
            try {
                FileObject o = processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "",
                                                                    resource);
                CharArrayWriter baos = new CharArrayWriter();
                try (Reader r = o.openReader(true)) {
                    char[] buf = new char[4096];
                    int l;
                    while ((l = r.read(buf)) > 0) {
                        baos.write(buf, 0, l);
                    }
                }
                o.delete();
                o = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", resource);
                Writer w = o.openWriter();
                w.write(baos.toCharArray());
                return new PrintWriter(w);
            } catch (Exception e2) {
                e2.addSuppressed(e);
                e2.printStackTrace();
                throw e2;
            }
        }
    }
}