/*
 * Copyright (c) 2010, Michael Bien. All rights reserved.
 * Copyright (c) 2013 JogAmp Community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Michael Bien nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Michael Bien BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.jogamp.gluegen.structgen;

import com.jogamp.common.util.PropertyAccess;
import com.jogamp.gluegen.CCodeUnit;
import com.jogamp.gluegen.GlueGen;
import com.jogamp.gluegen.JavaCodeUnit;
import com.jogamp.gluegen.JavaEmitter;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.tools.Diagnostic.Kind;
import javax.tools.FileObject;
import javax.tools.StandardLocation;

import jogamp.common.Debug;

/**
 * <p>
 * If the <i>header file</i> is absolute, the <i>root path</i> is the parent folder of the folder containing the package source, i.e.:
 * <pre>
 *  Header: /gluegen/src/junit/com/jogamp/test/structgen/TestStruct01.h
 *  Root:   /gluegen/src/junit/..
 *  Root:   /gluegen/src
 * </pre>
 * Otherwise the <i>user.dir</i> is being used as the <i>root path</i>
 * and the relative <i>header file</i> is appended to it.
 * </p>
 * The property <code>jogamp.gluegen.structgen.output</code> allows setting a default <i>outputPath</i>
 * for the generated sources, if the {@link ProcessingEnvironment}'s <code>structgen.output</code> option is not set.
 * <p>
 * If the <i>outputPath</i> is relative, it is appended to the <i>root path</i>,
 * otherwise it is taken as-is.
 * </p>
 * <p>
 * User can enable DEBUG while defining property <code>jogamp.gluegen.structgen.debug</code>.
 * </p>
 *
 * @author Michael Bien, et al.
 */
@SupportedAnnotationTypes(value = {"com.jogamp.gluegen.structgen.CStruct", "com.jogamp.gluegen.structgen.CStructs"})
@SupportedSourceVersion(SourceVersion.RELEASE_11)
public class CStructAnnotationProcessor extends AbstractProcessor {
    private static final String DEFAULT = "_default_";
    static final boolean DEBUG;

    static {
        Debug.initSingleton();
        DEBUG = PropertyAccess.isPropertyDefined("jogamp.gluegen.structgen.debug", true);
    }

    private static final String STRUCTGENOUTPUT_OPTION = "structgen.output";
    private static final String STRUCTGENPRAGMA_ONCE = "structgen.enable.pragma.once";
    private static final String STRUCTGENOUTPUT = PropertyAccess.getProperty("jogamp.gluegen."+STRUCTGENOUTPUT_OPTION, true, "gensrc");
    private static final String STRUCTGENPRAGMAONCE = PropertyAccess.getProperty("jogamp.gluegen."+STRUCTGENPRAGMA_ONCE, true, "true");

    private Filer filer;
    private Messager messager;
    private Elements eltUtils;
    private String outputPath;
    private boolean enablePragmaOnce;

    private final static Set<String> generatedStructs = new HashSet<String>();


    @Override
    public void init(final ProcessingEnvironment processingEnv) {
        super.init(processingEnv);

        filer = processingEnv.getFiler();
        messager = processingEnv.getMessager();
        eltUtils = processingEnv.getElementUtils();

        outputPath = processingEnv.getOptions().get(STRUCTGENOUTPUT_OPTION);
        outputPath = outputPath == null ? STRUCTGENOUTPUT : outputPath;

        final String enablePragmaOnceOpt = processingEnv.getOptions().get(STRUCTGENPRAGMAONCE);
        enablePragmaOnce = Boolean.parseBoolean(enablePragmaOnceOpt == null ? STRUCTGENPRAGMAONCE : enablePragmaOnceOpt);
    }

    private File locateSource(final String packageName, final String relativeName) {
        try {
            if( DEBUG ) {
                System.err.println("CStruct.locateSource.0: p "+packageName+", r "+relativeName);
            }
            final FileObject h = filer.getResource(StandardLocation.SOURCE_PATH, packageName, relativeName);
            if( DEBUG ) {
                System.err.println("CStruct.locateSource.1: h "+h.toUri());
            }
            final File f = new File( h.toUri().getPath() ); // URI is incomplete (no scheme), hence use path only!
            if( f.exists() ) {
                return f;
            }
        } catch (final IOException e) {
            if(DEBUG) {
                System.err.println("Caught "+e.getClass().getSimpleName()+": "+e.getMessage()); /* e.printStackTrace(); */
            }
        }
        return null;
    }

    @Override
    public boolean process(final Set<? extends TypeElement> annotations, final RoundEnvironment env) {
        final String user_dir = System.getProperty("user.dir");

        final Set<? extends Element> cStructsElements = env.getElementsAnnotatedWith(CStructs.class);
        for (final Element structsElement : cStructsElements) {
            final String packageName = eltUtils.getPackageOf(structsElement).toString();
            final CStructs cstructs = structsElement.getAnnotation(CStructs.class);
            if( null != cstructs ) {
                final CStruct[] cstructArray = cstructs.value();
                for(final CStruct cstruct : cstructArray) {
                    processCStruct(cstruct, structsElement, packageName, user_dir);
                }
            }
        }

        final Set<? extends Element> cStructElements = env.getElementsAnnotatedWith(CStruct.class);
        for (final Element structElement : cStructElements) {
            final String packageName = eltUtils.getPackageOf(structElement).toString();
            final CStruct cstruct = structElement.getAnnotation(CStruct.class);
            if( null != cstruct ) {
                processCStruct(cstruct, structElement, packageName, user_dir);
            }
        }
        return true;
    }

    private void processCStruct(final CStruct struct, final Element element, final String packageName, final String user_dir) {
        try {
            final String headerRelPath = struct.header();
            final Element enclElement = element.getEnclosingElement();
            final boolean isPackageOrType = null == enclElement;

            System.err.println("CStruct: "+struct+", package "+packageName+", header "+headerRelPath);
            if(DEBUG) {
                System.err.println("CStruct.0: user.dir: "+user_dir);
                System.err.println("CStruct.0: element: "+element+", .simpleName "+element.getSimpleName());
                System.err.print("CStruct.0: isPackageOrType "+isPackageOrType+", enclElement: "+enclElement);
                if( !isPackageOrType ) {
                	if(!enclElement.toString().equals("unnamed module"))
	                    System.err.println(", .simpleName "+enclElement.getSimpleName()+", .package "+eltUtils.getPackageOf(enclElement).toString());
                	else
	                    System.err.println(", .simpleName "+enclElement.getSimpleName()+", .package <unnamed modules have no package>");
                } else {
                    System.err.println("");
                }
            }
            if( isPackageOrType && struct.name().equals(DEFAULT) ) {
                throw new IllegalArgumentException("CStruct annotation on package or type must have name specified: "+struct+" @ "+element);
            }

            final File headerFile;
            {
                File f = locateSource(packageName, headerRelPath);
                if( null == f ) {
                    f = locateSource("", headerRelPath);
                    if( null == f ) {
                        // bail out
                        throw new RuntimeException("Could not locate header "+headerRelPath+", package "+packageName);
                    }
                }
                headerFile = f;
            }

            final String rootOut, headerParent;
            {
                final String root0 = headerFile.getAbsolutePath();
                headerParent = root0.substring(0, root0.length()-headerFile.getName().length()-1);
                rootOut = headerParent.substring(0, headerParent.length()-packageName.length()) + "..";
            }
            System.err.println("CStruct: "+headerFile+", abs: "+headerFile.isAbsolute()+", headerParent "+headerParent+", rootOut "+rootOut+", enablePragmaOnce "+enablePragmaOnce);

            generateStructBinding(element, struct, isPackageOrType, rootOut, packageName, headerFile, headerParent);
        } catch (final IOException ex) {
            throw new RuntimeException("IOException while processing!", ex);
        }
    }

    private void generateStructBinding(final Element element, final CStruct struct, final boolean isPackageOrType, final String rootOut, final String pakage, final File header, final String headerParent) throws IOException {
        final String declaredType = element.asType().toString();
        final boolean useStructName = !struct.name().equals(DEFAULT);
        final String structName = useStructName ? struct.name() : declaredType;
        final boolean useJavaName = !struct.jname().equals(DEFAULT);

        final String finalType = useJavaName ? struct.jname() : ( !isPackageOrType ? declaredType : structName );
        System.err.println("CStruct: Generating struct accessor for struct: "+structName+" -> "+finalType+" [struct.name "+struct.name()+", struct.jname "+struct.jname()+", declaredType "+declaredType+"]");
        if( generatedStructs.contains(finalType) ) {
            messager.printMessage(Kind.NOTE, "struct "+structName+" already defined elsewhere, skipping.", element);
            return;
        }

        final boolean outputDirAbs;
        {
            final File outputDirFile = new File(outputPath);
            outputDirAbs = outputDirFile.isAbsolute();
        }
        final String outputPath1 = outputDirAbs ? outputPath : rootOut + File.separator + outputPath;
        final String config = outputPath1 + File.separator + header.getName() + ".cfg";
        final File configFile = new File(config);
        if(DEBUG) {
            System.err.println("CStruct: OutputDir: "+outputPath+", is-abs "+outputDirAbs);
            System.err.println("CStruct: OutputPath: "+outputPath1);
            System.err.println("CStruct: ConfigFile: "+configFile);
        }

        FileWriter writer = null;
        try{
            writer = new FileWriter(configFile);
            writer.write("Package "+pakage+"\n");
            writer.write("EmitStruct "+structName+"\n");
            if( !useJavaName && (finalType != structName) ) {
                // We allow renaming the structType to the element's declaredType (FIELD annotation only)
                writer.write("RenameJavaType " + struct.name()+" " + declaredType +"\n");
            }
        } finally {
            if( null != writer ) {
                writer.close();
            }
        }
        final List<String> cfgFiles = new ArrayList<String>();
        cfgFiles.add(config);
        final List<String> includePaths = new ArrayList<String>();
        includePaths.add(headerParent);
        includePaths.add(outputPath1);
        final Reader reader;
        final String filename = header.getPath();
        try {
            reader = new BufferedReader(new FileReader(filename));
        } catch (final FileNotFoundException ex) {
            throw new RuntimeException("input file not found", ex);
        }
        if( DEBUG  ) {
            GlueGen.setDebug(true);
        }
        new GlueGen().run(reader, filename, AnnotationProcessorJavaStructEmitter.class,
                          includePaths, cfgFiles, outputPath1, false /* copyCPPOutput2Stderr */,
                          enablePragmaOnce /* enablePragmaOnce */, false /* preserveGeneratedCPP */);
        configFile.delete();
        generatedStructs.add(finalType);
    }

    public static class AnnotationProcessorJavaStructEmitter extends JavaEmitter {

        private boolean filter(final String simpleClassName) {
            if( generatedStructs.contains(simpleClassName) ) {
                System.err.println("skipping -> " + simpleClassName);
                return false;
            }

            // look for recursive generated structs... keep it DRY
            if( !simpleClassName.endsWith("32") &&
                !simpleClassName.endsWith("64") ) {
                System.err.println("generating -> " + simpleClassName);
                generatedStructs.add(simpleClassName);
            }
            return true;
        }

        @Override
        protected CCodeUnit openCUnit(final String filename, final String cUnitName) throws IOException {
            if( !filter(cUnitName) ) {
                return null;
            }
            return super.openCUnit(filename, cUnitName);
        }

        /**
         * @param filename the class's full filename to open w/ write access
         * @param packageName the package name of the class
         * @param simpleClassName the simple class name, i.e. w/o package name or c-file basename
         * @param generator informal optional object that is creating this unit, used to be mentioned in a warning message if not null.
         * @throws IOException
         */
        @Override
        protected JavaCodeUnit openJavaUnit(final String filename, final String packageName, final String simpleClassName) throws IOException {
            if( !filter(simpleClassName) ) {
                return null;
            }
            return super.openJavaUnit(filename, packageName, simpleClassName);
        }
    }

}
