// Defines tasks for building the VDL tool and generating VDL files.

package io.v.vdl

import org.gradle.api.InvalidUserDataException
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.artifacts.ProjectDependency
import org.gradle.api.file.FileCollection
import org.gradle.api.tasks.Copy
import org.gradle.api.tasks.Delete
import org.gradle.api.tasks.Exec
import org.gradle.language.jvm.tasks.ProcessResources

import java.util.jar.JarEntry
import java.util.jar.JarFile

class VdlPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.extensions.create('vdl', VdlConfiguration)

        def extractTask = project.task('extractVdl', type: Copy) {
            from {
                getVdlToolJarFiles(project, project.buildscript.configurations.classpath)
            }
            into { new File(project.buildDir, 'vdltool') }
        }
        def clearVdlOutputTask = project.task('clearVdlOutput', type: Delete) {
            delete { project.vdl.outputPath }
            delete { project.vdl.transitiveVdlDir }
        }
        def generateTask = project.task('generateVdl', type: Exec) {
        }
        def vdlTask = project.task('vdl') {
            group = "Build"
            description('Generates Java vdl source using the vdl tool')
        }
        def prepareTask = project.task('prepareVdl') {
            doLast {
                List<String> vdlPaths = extractTransitiveVdlFilesAndGetInputPaths(project).asList()
                List<String> outDirs = getJavaOutDirs(project)

                generateTask.environment(VDLROOT: getVdlRootPath(project))
                generateTask.environment(VDLPATH: vdlPaths.join(":"))
                String vdlToolPath = 'build/vdltool/vdl-' + getOsName()
                if (project.vdl.vdlToolPath != "") {
                    vdlToolPath = project.vdl.vdlToolPath
                }
                List<String> commandLine = [vdlToolPath,
                                            'generate',
                                            '--lang=java',
                                            '--java-out-dir=' + outDirs.join(",")
                ]
                if (!project.vdl.packageTranslations.isEmpty()) {
                    commandLine.add('--java-out-pkg=' + project.vdl.packageTranslations.join(','))
                }
                commandLine.add('all')
                generateTask.commandLine(commandLine)
            }
        }
        def removeVdlRootTask = project.task('removeVdlRoot', type: Delete) {
            onlyIf { !project.vdl.generateVdlRoot }
            delete { project.vdl.outputPath + '/io/v/v23/vdlroot/' }
        }
        extractTask.dependsOn(prepareTask)
        generateTask.dependsOn(clearVdlOutputTask)
        generateTask.dependsOn(extractTask)
        removeVdlRootTask.dependsOn(generateTask)
        vdlTask.dependsOn(removeVdlRootTask)

        if (project.vdl.formatGeneratedVdl) {
            def formatTask = project.task('formatGeneratedVdlFiles', type: FormatTask) {
                format project.fileTree({ project.vdl.outputPath }).include('**/*.java')
            }
            formatTask.dependsOn(removeVdlRootTask)
            vdlTask.dependsOn(formatTask)
        }
        if (project.plugins.hasPlugin('com.android.library')
                || project.plugins.hasPlugin('com.android.application')) {
            project.tasks.'preBuild'.dependsOn(vdlTask)
            project.android.sourceSets.main.java.srcDir({ project.vdl.outputPath })
        }

        if (project.plugins.hasPlugin('java')) {
            project.compileJava.dependsOn(vdlTask)
            project.sourceSets.main.java.srcDir({ project.vdl.outputPath })
        }

        if (project.hasProperty('clean')) {
            project.clean.delete({ project.vdl.outputPath })
            project.clean.delete({ project.vdl.transitiveVdlDir })
        }

        project.afterEvaluate({
            if (project.plugins.hasPlugin('java')) {
                // Add VDL files in VDL input paths to project resources.
                project.vdl.inputPaths.each {
                    project.sourceSets.main.resources.srcDirs(it).include('**/*.vdl')
                }

                // Ensure that empty directories are not copied.
                project.tasks.withType(ProcessResources, {
                    it.setIncludeEmptyDirs(false)
                })
            }
        })
    }

    public static String getVdlRootPath(Project project) {
        if (null == project.vdl.vdlRootPath || "".equals(project.vdl.vdlRootPath)) {
            // Look in the transitive VDL files, it should be there so long as the project depends
            // on VDL.
            File candidateVdlRoot = new File(
                    new File(project.getProjectDir(), project.vdl.transitiveVdlDir), 'v.io/v23/vdlroot')
            if (candidateVdlRoot.exists() && candidateVdlRoot.isDirectory()) {
                return candidateVdlRoot.getPath()
            }

            throw new InvalidUserDataException('could not determine a value for VDLROOT, '
                    + 'you should check to ensure your project depends on vanadium')
        } else {
            return project.vdl.vdlRootPath
        }
    }

    public static Set<String> extractTransitiveVdlFilesAndGetInputPaths(Project project) {
        Set<String> result = new LinkedHashSet<>(project.vdl.inputPaths)
        // Go through the dependencies of all configurations looking for jar files containing
        // VDL files.
        project.configurations.each({
            it.each({
                if (it.getName().endsWith('.jar') && it.exists()) {
                    if (extractVdlFiles(it, new File(project.getProjectDir(), project.vdl.transitiveVdlDir))) {
                        result.add(project.vdl.transitiveVdlDir)
                    }
                }
            })
        })

        // Now recursively descend through the project's project dependencies looking for
        // VDL projects.
        Set<String> projectInputPaths = new LinkedHashSet<>()
        addVdlInputPathsForProject(project, projectInputPaths)
        // Copy any VDL files in any input path to the transitive VDL directory.
        project.copy {
            projectInputPaths.each({
                from(it) {
                    include '**/*.vdl'
                    include '**/vdl.config'
                    includeEmptyDirs = false
                }
            })

            into project.vdl.transitiveVdlDir
        }
        if (!projectInputPaths.isEmpty()) {
            result.add(project.vdl.transitiveVdlDir)
        }
        return result
    }

    public static List<String> getJavaOutDirs(Project project) {
        List<String> result = new ArrayList<>()
        for (String inputPath : project.vdl.inputPaths) {
            if (!inputPath.startsWith(project.vdl.transitiveVdlDir)) {
                result.add(inputPath + '->' + project.vdl.outputPath)
            }
        }
        result.add(project.vdl.transitiveVdlDir + "->" + project.vdl.transitiveVdlDir)
        return result
    }

    /**
     * Extracts any vdl files in the given jar file to the given destination directory. Returns
     * {@code true} if any files were extracted.
     */
    private static boolean extractVdlFiles(File jarFile, File destination) {
        JarFile jar = new JarFile(jarFile)
        Enumeration<JarEntry> entries = jar.entries()
        boolean extracted = false
        while (entries.hasMoreElements()) {
            JarEntry entry = entries.nextElement()
            if (entry.isDirectory() || !entry.getName().endsWith('.vdl')) {
                continue
            }
            // Create the file's directory.
            File destinationFile = new File(destination, entry.getName())
            destinationFile.getParentFile().mkdirs()
            InputStream input = jar.getInputStream(entry)
            OutputStream output = new FileOutputStream(destinationFile)
            copyStream(input, output)
            extracted = true
            input.close()
            output.close()
        }
        return extracted
    }

    private static void copyStream(InputStream source, OutputStream destination) {
        byte[] buffer = new byte[1 << 16]
        while (true) {
            int r = source.read(buffer)
            if (r == -1) {
                return
            }
            destination.write(buffer, 0, r)
        }
    }

    /**
     * Returns a list of {@link java.io.File} instances representing VDL binaries.
     */
    static List<File> getVdlToolJarFiles(Project project, FileCollection files) {
        List<File> result = new ArrayList<File>()

        for (File file : files.findAll({
            it.name.contains 'gradle-plugin'
        })) {
            project.zipTree(file).findAll({ it.name.startsWith("vdl-") }).each({
                result.add(project.resources.text.fromArchiveEntry(file, it.name).asFile())
            })
        }

        return result
    }

    private static void addVdlInputPathsForProject(Project project, Set<String> inputPaths) {
        if (project == null) {
            return
        }
        Object extension = project.extensions.findByName('vdl')
        if (extension != null) {
            extension.inputPaths.each {
                File newPath = new File(it)
                if (!newPath.isAbsolute()) {
                    newPath = new File(project.getProjectDir(), it)
                }
                inputPaths.add(newPath.getAbsolutePath())
            }
        }
        project.configurations.each({
            it.dependencies.each({
                if (it instanceof ProjectDependency) {
                    addVdlInputPathsForProject(it.getDependencyProject(), inputPaths)
                }
            })
        })
    }

    private static isMacOsX() {
        return System.properties['os.name'].toLowerCase().contains("os x")
    }

    private static isLinux() {
        return System.properties['os.name'].toLowerCase().contains("linux")
    }

    static String getOsName() {
        if (isLinux()) {
            return "linux";
        } else if (isMacOsX()) {
            return "macosx";
        } else {
            throw new IllegalStateException("Unsupported operating system " + System.properties.'os.name')
        }
    }
}

class VdlConfiguration {
    List<String> inputPaths = []
    String vdlRootPath = ""
    String outputPath = "generated-src/vdl"
    String transitiveVdlDir = "generated-src/transitive-vdl"
    String vdlToolPath = ""
    List<String> packageTranslations = ["v.io->io/v"]
    boolean formatGeneratedVdl = true

    // If true, code generated for the vdlroot vdl package will be emitted.
    // Typically, users will want to leave this set to false as they will
    // already get the vdlroot package by depending on the :lib project.
    boolean generateVdlRoot = false;
}