/*
* Copyright 2013 The Android Open Source Project
*
* Licensed 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 com.example.android.samples.build

import freemarker.cache.FileTemplateLoader
import freemarker.cache.MultiTemplateLoader
import freemarker.cache.TemplateLoader
import freemarker.template.Configuration
import freemarker.template.DefaultObjectWrapper
import freemarker.template.Template
import org.gradle.api.GradleException
import org.gradle.api.file.FileVisitDetails
import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.OutputDirectory
import org.gradle.api.tasks.SourceTask
import org.gradle.api.tasks.TaskAction


class ApplyTemplates extends SourceTask {
    /**
     * Freemarker context object
     */
    def Configuration cfg = new freemarker.template.Configuration()

    /**
     * The root directory for output files. All output file paths
     * are assumed to be relative to this root.
     */
    @OutputDirectory
    public outputDir = project.projectDir

    /**
     * Include directory. The templates in this directory will not be
     * processed directly, but will be accessible to other templates
     * via the <#include> directive.
     */
    def include = project.file("$project.projectDir/templates/include")

    /**
     * List of file extensions that indicate a file to be processed, rather
     * than simply copied.
     */
    def extensionsToProcess = ['ftl']

    /**
     * List of file extensions that should be completely ignored by this
     * task. File extensions that appear in neither this list nor the list
     * specified by {@link #extensionsToProcess} are copied into the destination
     * without processing.
     */
    def extensionsToIgnore = ['ftli']

    /**
     * A String -> String closure that transforms a (relative) input path into a
     * (relative) output path. This closure is responsible for any alterations to
     * the output path, including pathname substitution and extension removal.
     */
    Closure<String> filenameTransform

    /**
     * The hash which will be passed to the freemarker template engine. This hash
     * is used by the freemarker script as input data.
     * The hash should contain a key named "meta". The template processor will add
     * processing data to this key.
     */
    def parameters

    /**
     * The main action for this task. Visits each file in the source directories and
     * either processes, copies, or ignores it. The action taken for each file depends
     * on the contents of {@link #extensionsToProcess} and {@link #extensionsToIgnore}.
     */
    @TaskAction
    def applyTemplate() {
        // Create a list of Freemarker template loaders based on the
        // source tree(s) of this task. The loader list establishes a virtual
        // file system for freemarker templates; the template language can
        // load files, and each load request will have its path resolved
        // against this set of loaders.
        println "Gathering template load locations:"
        def List loaders = []
        source.asFileTrees.each {
            src ->
                println "    ${src.dir}"
                loaders.add(0, new FileTemplateLoader(project.file(src.dir)))
        }

        // Add the include path(s) to the list of loaders.
        println "Gathering template include locations:"
        include = project.fileTree(include)
        include.asFileTrees.each {
            inc ->
                println "    ${inc.dir}"
                loaders.add(0, new FileTemplateLoader(project.file(inc.dir)))
        }
        // Add the loaders to the freemarker config
        cfg.setTemplateLoader(new MultiTemplateLoader(loaders.toArray(new TemplateLoader[1])))

        // Set the wrapper that will be used to convert the template parameters hash into
        // the internal freemarker data model. The default wrapper is capable of handling a
        // mix of POJOs/POGOs and XML nodes, so we'll use that.
        cfg.setObjectWrapper(new DefaultObjectWrapper())

        // This is very much like setting the target SDK level in Android.
        cfg.setIncompatibleEnhancements("2.3.20")

        // Add an implicit <#include 'common.ftl' to the top of every file.
        // TODO: should probably be a parameter instead of hardcoded like this.
        cfg.addAutoInclude('common.ftl')

        // Visit every file in the source tree(s)
        def processTree = source.getAsFileTree()
        processTree.visit {
            FileVisitDetails input ->
                def inputFile = input.getRelativePath().toString()
                def outputFile = input.getRelativePath().getFile(project.file(outputDir))
                // Get the input and output files, and make sure the output path exists
                def renamedOutput = filenameTransform(outputFile.toString())
                outputFile = project.file(renamedOutput)

                if (input.directory){
                    // create the output directory. This probably will have already been
                    // created as part of processing the files *in* the directory, but
                    // do it here anyway to support empty directories.
                    outputFile.mkdirs()
                } else {
                    // We may or may not see the directory before we see the files
                    // in that directory, so create it here
                    outputFile.parentFile.mkdirs()

                    // Check the input file extension against the process/ignore list
                    def extension = "NONE"
                    def extensionPattern = ~/.*\.(\w*)$/
                    def extensionMatch = extensionPattern.matcher(inputFile)
                    if (extensionMatch.matches()) {
                        extension = extensionMatch[0][1]
                    }
                    // If the extension is in the process list, put the input through freemarker
                    if (extensionsToProcess.contains(extension)){
                        print '[freemarker] PROCESS: '
                        println "$inputFile -> $outputFile"

                        try {
                            def Template tpl = this.cfg.getTemplate(inputFile)
                            def FileWriter out = new FileWriter(outputFile)

                            // Add the output file path to parameters.meta so that the freemarker
                            // script can access it.
                            parameters.meta.put("outputFile", "${outputFile}")
                            tpl.process(parameters, out)
                        } catch (e) {
                            println e.message
                            throw new GradleException("Error processing ${inputFile}: ${e.message}")
                        }
                    } else if (!extensionsToIgnore.contains(extension)) {
                        // if it's not processed and not ignored, then it must be copied.
                        print '[freemarker] COPY: '
                        println "$inputFile -> $outputFile"
                        input.copyTo(outputFile);
                    }
                }
        }
    }
}