/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.cxf.maven_plugin;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlElementRef;

import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.XMLFilterImpl;

import com.sun.codemodel.CodeWriter;
import com.sun.codemodel.JCodeModel;
import com.sun.istack.SAXParseException2;
import com.sun.tools.xjc.ErrorReceiver;
import com.sun.tools.xjc.Language;
import com.sun.tools.xjc.Options;
import com.sun.tools.xjc.api.SpecVersion;
import com.sun.tools.xjc.model.Model;
import com.sun.tools.xjc.outline.Outline;
import com.sun.tools.xjc.reader.internalizer.AbstractReferenceFinderImpl;
import com.sun.tools.xjc.reader.internalizer.DOMForest;
import com.sun.tools.xjc.reader.xmlschema.parser.XMLSchemaInternalizationLogic;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import org.apache.xml.resolver.CatalogManager;
import org.apache.xml.resolver.tools.CatalogResolver;
import org.sonatype.plexus.build.incremental.BuildContext;

/**
 * 
 */
public class XSDToJavaRunner {
    static Class<?> modelLoaderClass;
    
    final String[] args;
    final List<String> cpList;
    final XJCErrorListener listener;
    final File xsdFile;
    
    public XSDToJavaRunner(String[] args, XJCErrorListener listener,
                           File file, List<String> cp) {
        this.args = args;
        this.listener = listener;
        this.xsdFile = file;
        this.cpList = cp;
    }
    
    private static File getFile(String s, XJCErrorListener l) throws Exception {
        File f = new File(s);
        if (f.exists()) {
            return f;
        }
        try {
            URI uri = new URI(s);
            f = new File(uri);
            return f;
        } catch (Throwable t) {
            if (l != null) {
                l.debug("Could not find a file for " + s);
            }
            return null;
        }
    }
    
    public int run() throws Exception {
        List<URL> urls = new ArrayList<URL>();
        for (String s : cpList) {
            File file = getFile(s, listener);
            if (file != null) {
                urls.add(file.toURI().toURL());
            }
        }
        for (int x = 0; x < args.length - 1; x++) {
            if ("-classpath".equals(args[x])) {
                File file = getFile(args[x + 1], listener);
                if (file != null && file.exists()) {
                    cpList.add(file.getAbsolutePath());
                    urls.add(file.getAbsoluteFile().toURI().toURL());
                }
                x++;
            }
        }

        try (URLClassLoader loader = new URLClassLoader(urls.toArray(new URL[0]),
                                                      this.getClass().getClassLoader())) {
            final CatalogManager cm = new CatalogManager();
            cm.setUseStaticCatalog(false);
            cm.setIgnoreMissingProperties(true);
            final CatalogResolver catResolver = new CatalogResolver(cm) {
                public InputSource resolveEntity(String publicId, String systemId) {
                    final String resolved = getResolvedEntity(publicId, systemId);
                    if (resolved == null) {
                        return null;
                    }
                    InputSource iSource = new InputSource(resolved);
                    iSource.setPublicId(publicId);
                    try {
                        final URL url;
                        if (resolved.startsWith("classpath:")) {
                            url = loader.getResource(resolved.substring("classpath:".length()));
                            iSource.setSystemId(url.toExternalForm());
                        } else {
                            url = new URL(resolved);
                        }
                        InputStream iStream = url.openStream();
                        iSource.setByteStream(iStream);

                        //System.out.println("Resolved: " + publicId + " " + systemId + " " + url);
                        return iSource;
                    } catch (Exception e) {
                        listener.warning(xsdFile, e);
                        return null;
                    }
                }
            };
            final Options opt = new Options() {
                @Override
                public void addCatalog(File catalogFile) throws IOException {
                    if (entityResolver == null) {
                        entityResolver = catResolver;
                    }
                    catResolver.getCatalog().parseCatalog(catalogFile.getPath());
                }
            };

            for (URL url : urls) {
                opt.classpaths.add(url);
            }
            if (checkXmlElementRef()) {
                opt.target = SpecVersion.V2_1;
            }
            opt.setSchemaLanguage(Language.XMLSCHEMA);
            // set up the context class loader so that the user-specified plugin
            // on classpath can be loaded from there with jaxb-xjc 2.3.0
            ClassLoader origLoader = Thread.currentThread().getContextClassLoader();
            try {
                Thread.currentThread().setContextClassLoader(opt.getUserClassLoader(origLoader));
                opt.parseArguments(args);
            } finally {
                Thread.currentThread().setContextClassLoader(origLoader);
            }
            Model model = loadModel(opt); 
            if (model == null) {
                listener.message(xsdFile, "Failed to create model");
                return -1;
            }
            Outline outline = model.generateCode(opt, listener);
            if (outline == null) {
                listener.message(xsdFile, "Failed to generate code");
                return -1;
            }

            // then print them out
            try {
                CodeWriter cw = opt.createCodeWriter();
                model.codeModel.build(cw);
            } catch (IOException e) {
                listener.error(e);
                return -1;
            }
        }
        return 0;
    }

    private synchronized Class<?> getModelLoaderClass() {
        if (modelLoaderClass == null) {
            try {
                ClassPool pool = ClassPool.getDefault();
                CtClass cc = pool.get("com.sun.tools.xjc.ModelLoader");
                cc.setName("com.sun.tools.xjc.ModelLoader");
                for (CtMethod m : cc.getMethods()) {
                    if (m.getName().equals("buildDOMForest")) {
                        m.insertBefore("$1 = new " + CustomizedLogic.class.getName() + "();");
                    }
                }
                modelLoaderClass = cc.toClass();
            } catch (Throwable t) {
                try {
                    modelLoaderClass = Class.forName("com.sun.tools.xjc.ModelLoader");
                } catch (ClassNotFoundException e) {
                    //ignore
                }
            }
        }
        return modelLoaderClass;
    }
    
    private Model loadModel(Options opt) {
        try {
            return (Model)getModelLoaderClass()
                .getMethod("load", Options.class, JCodeModel.class, ErrorReceiver.class)
                .invoke(null, opt, new JCodeModel(), listener);
        } catch (Exception e) {
            listener.error("Failed to create model", e);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static class CustomizedLogic extends XMLSchemaInternalizationLogic {
        private static final class ReferenceFinder extends AbstractReferenceFinderImpl {
            private Locator locator;

            ReferenceFinder(DOMForest parent) {
                super(parent);
            }
            
            @Override
            public void setDocumentLocator(Locator l) {
                super.setDocumentLocator(l);
                locator = l;
            }
            
            @Override
            public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
                throws SAXException {
                if (getContentHandler() != null) {
                    getContentHandler().startElement(namespaceURI, localName, qName, atts);
                }

                String relativeRef = findExternalResource(namespaceURI, localName, atts);
                if (relativeRef == null) {
                    return; // not found
                }
                try {
                    // absolutize URL.
                    String lsi = locator.getSystemId();
                    String ref;
                    URI relRefURI = new URI(relativeRef);
                    if (relRefURI.isAbsolute()) {
                        ref = relativeRef;
                    } else {
                        if (lsi.startsWith("jar:")) {
                            int bangIdx = lsi.indexOf('!');
                            if (bangIdx > 0) {
                                ref = lsi.substring(0, bangIdx + 1)
                                        + new URI(lsi.substring(bangIdx + 1)).resolve(new URI(relativeRef)).toString();
                            } else {
                                ref = relativeRef;
                            }
                        } else {
                            ref = new URI(lsi).resolve(new URI(relativeRef)).toString();
                        }
                    }

                    if (parent != null) {
                        ref = Options.normalizeSystemId(ref);

                        if (parent.get(ref) != null) {
                            return;
                        }
                        
                        InputSource is = null;
                        
                        // allow entity resolver to find the actual byte stream.
                        if (parent.getEntityResolver() != null) {
                            is = parent.getEntityResolver().resolveEntity(null, ref);
                        }
                        if (is == null) {
                            is = new InputSource(ref);
                        } else {
                            ref = is.getSystemId();
                        }
                        if (parent.get(ref) != null) {
                            is.getByteStream().close();
                            return;
                        }
                        parent.parse(ref, is, false);
                    }
                } catch (URISyntaxException e) {
                    String msg = e.getMessage();
                    if (new File(relativeRef).exists()) {
                        msg = "Filename is not a URI " + ' ' + msg;
                    }

                    SAXParseException spe = new SAXParseException2(
                            "Unable to parse " + relativeRef + ": " + msg,
                            locator, e);

                    fatalError(spe);
                    throw spe;
                } catch (IOException e) {
                    SAXParseException spe = new SAXParseException2(
                            "Unable to parse " + relativeRef + ": " + e.getMessage(),
                            locator, e);

                    fatalError(spe);
                    throw spe;
                }
            }
            
            protected String findExternalResource(String nsURI, String localName, Attributes atts) {
                if ("http://www.w3.org/2001/XMLSchema".equals(nsURI)
                    && ("import".equals(localName) || "include".equals(localName))) {
                    return atts.getValue("schemaLocation");
                }
                return null;
            }
        }

        public XMLFilterImpl createExternalReferenceFinder(DOMForest parent) {
            return new ReferenceFinder(parent);
        }
    }
    
    private boolean checkXmlElementRef() {
        try {
            //check the version of JAXB-API that is actually being picked up
            //so we can set target=2.1 if the 2.1 version of XmlElementRef is picked up
            XmlElementRef.class.getMethod("required");
        } catch (Throwable t) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        BuildContext context = new XJCBuildContext();
        XJCErrorListener listener = new XJCErrorListener(context);

        List<String> cplist = new ArrayList<String>();
        
        File outputFile = getFile(args[args.length - 1], listener);
        if (outputFile == null) {
            outputFile = new File(args[args.length - 1]);
        }
        int i = new XSDToJavaRunner(args, listener, outputFile, cplist).run();
        System.exit(i);
    }

}