package de.tasmiro.utils;
 
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.util.Map;
import java.util.TreeMap;
 
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.XMLOutputter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.core.util.HierarchicalStreams;
import com.thoughtworks.xstream.io.xml.JDom2Reader;
import com.thoughtworks.xstream.io.xml.JDom2Writer;
 
/**
 * Helps to maintain migrations.
 * 
 * Inspired by com.pmease.commons.xmt. But totally rewritten
 * to be much simpler and based on JDom2.
 * 
 * In spite of xmt, the name of the migration method does not
 * matter. Just put an @Migration(version) annotation before it,
 * ensure it's static and it expects an Element parameter.
 */
public class XStreamMigrations {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(XStreamMigrations.class);
 
    private final XStream xstream;
    private final XMLOutputter writer;
    private final SAXBuilder builder;
 
    public XStreamMigrations() {
        this(new XStream());
    }
 
    public XStreamMigrations(XStream xstream) {
        this(xstream, new SAXBuilder(), new XMLOutputter());
    }
 
    public XStreamMigrations(XStream xstream, SAXBuilder builder, XMLOutputter writer) {
        this.xstream = xstream;
        this.writer = writer;
        this.builder = builder;
    }
 
    public XStream getXStream() {
        return this.xstream;
    }
 
    public XMLOutputter getWriter() {
        return this.writer;
    }
 
    public SAXBuilder getBuilder() {
        return this.builder;
    }
 
    public Object fromXML(File in) throws JDOMException, IOException {
        return fromXML(builder.build(in));
    }
 
    public Object fromXML(URL in) throws JDOMException, IOException {
        return fromXML(builder.build(in));
    }
 
    public Object fromXML(String in) throws JDOMException, IOException {
        return fromXML(builder.build(in));
    }
 
    public Object fromXML(Reader in) throws JDOMException, IOException {
        return fromXML(builder.build(in));
    }
 
    public Object fromXML(InputStream in) throws JDOMException, IOException {
        return fromXML(builder.build(in));
    }
 
    public Object fromXML(Document doc) {
        return fromXML(doc.getRootElement());
    }
 
    public Object fromXML(Element rootElement) {
        String version = rootElement.getAttributeValue("version", "0");
        JDom2Reader reader = new JDom2Reader(rootElement);
        Class<?> clazz = HierarchicalStreams.readClassType(reader, xstream.getMapper());
        migrate(clazz, rootElement, Integer.parseInt(version));
        return xstream.unmarshal(reader);
    }
 
    public void toXML(Object obj, OutputStream out) throws IOException {
        Element rootElement = new Element("container");
        xstream.marshal(obj, new JDom2Writer(rootElement));
        rootElement.setAttribute("version", "" + getVersion(obj.getClass()));
        Document doc = new Document(rootElement.getChildren().get(0).detach());
        this.writer.output(doc, out);
    }
 
    private int getVersion(Class<?> clazz) {
        int maxVersion = 0;
        for (Method m : clazz.getDeclaredMethods()) {
            Migration migration = m.getAnnotation(Migration.class);
            if (migration != null) {
                int version = migration.version();
                if ((m.getModifiers() & Modifier.STATIC) != 0) {
                    Class<?>[] params = m.getParameterTypes();
                    if (params.length == 1 && params[0].isAssignableFrom(Element.class)) {
                        if (version > maxVersion) {
                            maxVersion = version;
                        }
                    } else {
                        LOGGER.warn("Ignoring @Migration(" + version + ") on method with wrong parameter count or type " + m.toGenericString());
                    }
                } else {
                    LOGGER.warn("Ignoring @Migration(" + version + ") on non-static method " + m.toGenericString());
                }
            }
        }
        return maxVersion;
    }
 
    private void migrate(Class<?> clazz, Element rootElement, int version) {
        Map<integer, method=""> methods = new TreeMap<integer, method="">();
        for (Method m : clazz.getDeclaredMethods()) {
            if ((m.getModifiers() & Modifier.STATIC) != 0) {
                Migration migration = m.getAnnotation(Migration.class);
                if (migration != null) {
                    int v = migration.version();
                    if (v > version) {
                        Class<?>[] params = m.getParameterTypes();
                        if (params.length == 1 && params[0].isAssignableFrom(Element.class)) {
                            Method oldMethod = methods.put(v, m);
                            if (oldMethod != null) {
                                throw new RuntimeException("In class " + clazz.getName() + ": Duplicate migration versions defined for " + m.toGenericString() + " and " + oldMethod.toGenericString());
                            }
                        }
                    }
                }
            }
        }
 
        // Invoke all methods
        for (Method m : methods.values()) {
            try {
                m.invoke(null, rootElement);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                LOGGER.error("Failed to invoke migration " + m.toGenericString(), e);
            }
        }
    }
 
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public static @interface Migration {
        int version();
    }
}