/*
 * Copyright 2010 the original author or authors.
 *
 * 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.
 */
import org.gradle.build.docs.UserGuideSectionVerifier
import org.gradle.build.docs.UserGuideTransformTask
import org.gradle.build.docs.ExtractSnippetsTask
import org.gradle.build.docs.AssembleSamplesDocTask
import org.gradle.build.docs.Docbook2Xhtml
import org.gradle.build.docs.dsl.source.GenerateDefaultImportsTask
import org.gradle.build.docs.dsl.docbook.AssembleDslDocTask
import org.gradle.build.docs.dsl.source.ExtractDslMetaDataTask
import org.gradle.build.docs.releasenotes.*
import org.gradle.build.docs.releasenotes.checks.*
import org.apache.tools.ant.filters.ReplaceTokens

apply plugin: 'base'
apply plugin: 'pegdown'
apply plugin: 'jsoup'
apply plugin: 'javascript-base'

repositories {
    maven { url 'file:///usr/share/maven-repo' }
    flatDir {
      dirs '/usr/share/javascript/jquery'
      dirs "${rootDir}/debian/additionalSrc/javascript"
    }
}

configurations {
    userGuideStyleSheets
    userGuideTask
    jquery
    jqueryTipTip
    fonts
}

dependencies {
    userGuideTask 'xalan:xalan2:debian', libraries.xerces
    userGuideTask module('xhtmlrenderer:core-renderer') {
        dependency 'itext:itext:2.0.8@jar'
    }
    userGuideTask 'xslthl:xslthl:2.0.1@jar'

    jquery "jquery:jquery.min:1.8.0@js"
    jqueryTipTip "com.drewwilson.code:jquery.tipTip:1.3:@js"

    testCompile libraries.groovy
    testCompile "org.pegdown:pegdown:1.1.0"
    testCompile libraries.jsoup
    testCompile "org.gebish:geb-spock:0.9.3"
    testCompile('org.seleniumhq.selenium:selenium-htmlunit-driver:2.42.2') {
        exclude group: 'org.apache.httpcomponents'
    }
    testCompile libraries.commons_httpclient
    testCompile 'org.apache.httpcomponents:httpmime:4.4.1'
    testCompile project(":core")
}

ext {
    srcDocsDir = file('src/docs')
    userguideSrcDir = new File(srcDocsDir, 'userguide')
    dslSrcDir = new File(srcDocsDir, 'dsl')
    docsDir = file("$buildDir/docs")
    userguideDir = new File(docsDir, 'userguide')
    distDocsDir = new File(buildDir, 'distDocs')
    samplesDir = file("$buildDir/samples")
    docbookSrc = new File(project.buildDir, 'src')
    samplesSrcDir = file('src/samples')
}

ext.outputs = [:]
outputs.samples = files(samplesDir) {
    builtBy 'samples'
}
outputs.distDocs = files(distDocsDir) {
    builtBy 'distDocs'
}
outputs.docs = files(docsDir) {
    builtBy 'javadocAll', 'userguide', 'dslHtml', 'releaseNotes'
}

tasks.withType(Docbook2Xhtml) {
    dependsOn userguideStyleSheets
    classpath = configurations.userGuideTask
    stylesheetsDir = userguideStyleSheets.destinationDir
}
tasks.withType(UserGuideTransformTask) {
    dependsOn samples, dslDocbook
    snippetsDir = samples.snippetsDir
    linksFile = dslDocbook.linksFile
    websiteUrl = 'http://www.gradle.org'

    if (name in ["pdfUserguideDocbook", "userguideFragmentSrc"]) {
        // These will only be valid for releases, but that's ok
        javadocUrl = "http://www.gradle.org/docs/${->version}/javadoc"
        dsldocUrl = "http://www.gradle.org/docs/${->version}/dsl"
    } else {
        javadocUrl = '../javadoc'
        dsldocUrl = '../dsl'
    }
}
tasks.withType(AssembleDslDocTask) {
    classDocbookDir = dslSrcDir
}

task configureCss {
    doLast {
        def images = fileTree(dir: "src/docs/css/images", include: "*.*").files.collectEntries {
            [it.name, it.bytes.encodeBase64().toString()]
        }

        ext.tokens = images
        css.inputs.property 'tokens', tokens
        css.filter ReplaceTokens, tokens: tokens
    }
}

task css(type: Sync, dependsOn: configureCss) {
    into "$buildDir/css"
    from "src/docs/css"
    include "*.css"
    include "*.svg"
}

ext.cssFiles = fileTree(css.destinationDir) {
    builtBy css
}

task samples(type: ExtractSnippetsTask) {
    source samplesSrcDir
    exclude 'userguideOutput/**'
    exclude '**/readme.xml'
    exclude '**/build/**'
    exclude '**/.gradle/**'

    // Resources that should not be filtered
    exclude 'userguide/tutorial/antLoadfileResources/**'
    exclude 'native-binaries/cunit/libs/**'
    exclude 'native-binaries/google-test/libs/**'

    destDir = samplesDir
    snippetsDir = new File(buildDir, 'snippets')
    doLast {
        copy {
            from samplesSrcDir
            into samplesDir
            include 'userguide/tutorial/antLoadfileResources/**'
            include 'native-binaries/cunit/libs/**'
            include 'native-binaries/google-test/libs/**'
        }
    }
}

task userguideStyleSheets(type: Copy) {
    File stylesheetsDir = new File(srcDocsDir, 'stylesheets')
    into new File(buildDir, 'stylesheets')
    from(stylesheetsDir) {
        include '*.xsl'
    }
    from(cssFiles)
}

task samplesDocbook(type: AssembleSamplesDocTask) {
    source samplesSrcDir
    include '**/readme.xml'
    destFile = new File(docbookSrc, 'samplesList.xml')
}

task samplesDocs(type: Docbook2Xhtml) {
    source samplesDocbook
    destFile = new File(samples.destDir, 'readme.html')
    stylesheetName = 'standaloneHtml.xsl'
}

task dslMetaData(type: ExtractDslMetaDataTask) {
    source { javadocAll.source }
    destFile = new File(docbookSrc, 'dsl-meta-data.bin')
}

task dslDocbook(type: AssembleDslDocTask, dependsOn: [dslMetaData]) {
    inputs.files fileTree(dir: dslSrcDir, includes: ['*.xml'])
    sourceFile = new File(dslSrcDir, 'dsl.xml')
    classMetaDataFile = dslMetaData.destFile
    pluginsMetaDataFile = new File(dslSrcDir, 'plugins.xml')
    destFile = new File(docbookSrc, 'dsl.xml')
    linksFile = new File(docbookSrc, 'api-links.bin')
}

task dslStandaloneDocbook(type: UserGuideTransformTask, dependsOn: [dslDocbook]) {
    sourceFile = dslDocbook.destFile
    destFile = new File(docbookSrc, 'dsl-standalone.xml')
    dsldocUrl = '.'
}

task defaultImports(type: GenerateDefaultImportsTask, dependsOn: dslMetaData) {
    metaDataFile = dslMetaData.destFile
    importsDestFile = new File(generatedResourcesDir, "default-imports.txt")
    mappingDestFile = new File(generatedResourcesDir, "api-mapping.txt")
    // These are part of the API, but not the DSL
    excludePackage 'org.gradle.tooling.**'
    excludePackage 'org.gradle.testfixtures.**'

    // Tweak the imports due to some inconsistencies introduced before we automated the default-imports generation
    excludePackage 'org.gradle.plugins.ide.eclipse.model'
    excludePackage 'org.gradle.plugins.ide.idea.model'
    excludePackage 'org.gradle.api.tasks.testing.logging'
    extraPackage 'org.gradle.util'

    // TODO - rename some incubating types to remove collisions and then remove these exclusions
    excludePackage 'org.gradle.plugins.binaries.model'

    // Exclude classes that were moved in a different package but the deprecated ones are not removed yet
    excludePackage 'org.gradle.platform.base.test'
}

task dslHtml(type: Docbook2Xhtml) {
    source dslStandaloneDocbook
    destDir = new File(docsDir, 'dsl')
    stylesheetName = 'dslHtml.xsl'
    resources = cssFiles + fileTree(dslSrcDir) {
        include '*.js'
    }
    ext.entryPoint = "$destDir/index.html"
}

task checkSectionIds(type: UserGuideSectionVerifier) {
    docbookFiles = fileTree(userguideSrcDir) { include "**/*.xml" }
}

[configureCss, samples, samplesDocbook, defaultImports]*.mustRunAfter(checkSectionIds)

// This is used in the distribution and for the online version
task userguideDocbook(type: UserGuideTransformTask, dependsOn: [checkSectionIds, samples, samplesDocbook, defaultImports]) {
    destFile = new File(docbookSrc, 'userguide.xml')
}

// This is used for the PDF, where we need absolute links to the javadoc etc.
task pdfUserguideDocbook(type: UserGuideTransformTask, dependsOn: [samples, samplesDocbook, defaultImports]) {
    destFile = new File(docbookSrc, 'remoteUserguide.xml')
}

configure([userguideDocbook, pdfUserguideDocbook]) {
    // The master userguide.xml pulls these files in via xi:include, making them input
    inputs.files fileTree(dir: userguideSrcDir, includes: ['*.xml'])

    sourceFile new File(userguideSrcDir, 'userguide.xml')
    websiteUrl 'http://www.gradle.org'
}

task userguideHtml(type: Docbook2Xhtml) {
    source userguideDocbook
    destDir = userguideDir
    stylesheetName = 'userGuideHtml.xsl'
    resources = fileTree(userguideSrcDir) {
        include 'img/*.png'
    } + cssFiles
    ext.entryPoint = "$destDir/userguide.html"
}

task userguideSingleHtml(type: Docbook2Xhtml) {
    source userguideDocbook
    destFile = new File(userguideDir, 'userguide_single.html')
    stylesheetName = 'userGuideSingleHtml.xsl'
    resources = fileTree(userguideSrcDir) {
        include 'img/*.png'
    } + cssFiles
    ext.entryPoint = destFile
}

task pdfUserguideXhtml(type: Docbook2Xhtml) {
    source pdfUserguideDocbook
    destFile = new File(buildDir, 'tmp/userguidePdf/userguidePdf.html')
    stylesheetName = 'userGuidePdf.xsl'
    resources = fileTree(userguideSrcDir) {
        include 'img/*.png'
    } + cssFiles
    ext.entryPoint = destFile
}

task userguidePdf(type: Xhtml2Pdf, dependsOn: pdfUserguideXhtml) {
    inputs.files fileTree(userguideSrcDir) {
        include 'img/*.png'
    } + cssFiles
    sourceFile = pdfUserguideXhtml.destFile
    destFile = new File(userguideDir, 'userguide.pdf')
    classpath = configurations.userGuideTask
}

def javaApiUrl = "file:///usr/share/doc/default-jdk/api/"
def groovyApiUrl = "file:///usr/share/doc/groovy/api/"
def mavenApiUrl = "http://maven.apache.org/ref/${versions.maven}/maven-model/apidocs"

task javadocAll(type: Javadoc) {
    ext.stylesheetFile = file("src/docs/css/javadoc.css")
    inputs.file stylesheetFile

    group = 'documentation'
    options.encoding = 'utf-8'
    options.docEncoding = 'utf-8'
    options.charSet = 'utf-8'
    if (javaVersion.isJava8Compatible()) {
        options.addStringOption 'Xdoclint:none', '-quiet'
    }
    options.addStringOption "stylesheetfile", stylesheetFile.absolutePath
    source publicGroovyProjects.collect {project -> project.sourceSets.main.allJava }
    destinationDir = new File(docsDir, 'javadoc')
    classpath = files(publicGroovyProjects.collect {project -> [project.sourceSets.main.compileClasspath, project.sourceSets.main.output] })
    include 'org/gradle/*'
    include 'org/gradle/api/**'
    include 'org/gradle/authentication/**'
    include 'org/gradle/buildinit/**'
    include 'org/gradle/external/javadoc/**'
    include 'org/gradle/ide/**'
    include 'org/gradle/ivy/**'
    include 'org/gradle/jvm/**'
    include 'org/gradle/language/**'
    include 'org/gradle/maven/**'
    include 'org/gradle/nativeplatform/**'
    include 'org/gradle/platform/**'
    include 'org/gradle/play/**'
    include 'org/gradle/plugin/devel/**'
    include 'org/gradle/plugin/repository/*'
    include 'org/gradle/plugin/use/*'
    include 'org/gradle/plugins/**'
    include 'org/gradle/process/**'
    include 'org/gradle/testfixtures/**'
    include 'org/gradle/testing/jacoco/**'
    include 'org/gradle/tooling/**'
    include 'org/gradle/model/**'
    include 'org/gradle/testkit/**'
    include 'org/gradle/testing/**'
    exclude '**/internal/**'
    options.links(javaApiUrl, groovyApiUrl)
    doFirst {
        title = "Gradle API $version"
    }
    ext.entryPoint = "$destinationDir/index.html"
}

task checkstyleApi {
}

task userguideFragmentSrc(type: UserGuideTransformTask, dependsOn: [userguideStyleSheets]) {
    tags << 'standalone'
    sourceFile = new File(userguideSrcDir, 'installation.xml')
    destFile = new File(docbookSrc, 'installation.xml')
}

task distDocs(type: Docbook2Xhtml) {
    source userguideFragmentSrc
    destFile = new File(distDocsDir, 'getting-started.html')
    stylesheetName = 'standaloneHtml.xsl'
}

task userguide {
    dependsOn userguideHtml, userguideSingleHtml, userguidePdf
    description = 'Generates the userguide'
    group = 'documentation'
}

import org.gradle.plugins.pegdown.PegDown

task editReleaseNotes() {
    group = "release notes"
    doLast {
        Class.forName("java.awt.Desktop").newInstance().edit(file("src/docs/release/notes.md"))
    }
}

task releaseNotesMarkdown(type: PegDown) {
    group = "release notes"
    source "src/docs/release/notes.md"
    destination "$buildDir/release-notes-raw/release-notes.html"
}

task releaseNotes(type: Copy) {
    group = "release notes"
    ext.fileName = "release-notes.html"
    into "$docsDir"
    from releaseNotesMarkdown
    jsoup.plugins "src/transforms/release-notes.gradle"
    filter(ReplaceTokens, tokens: [version: project.version.toString(), versionBase: rootProject.versionBase])
    ext.entryPoint = file("$docsDir/$fileName")
}

tasks.addRule("view«Doc Task Name» - Opens entry point") { String taskName ->
    if (taskName.startsWith("view")) {
        def realTaskName = (taskName - "view")
        realTaskName = realTaskName[0].toLowerCase() + realTaskName[1..-1]
        def task = tasks.findByName(realTaskName)
        if (task && task.hasProperty("entryPoint")) {
            tasks.create(taskName) {
                dependsOn task
                doLast {
                    Class.forName("java.awt.Desktop").newInstance().browse(file(task.entryPoint).toURI())
                }
            }
        }
    }
}

sourceSets.main.output.dir generatedResourcesDir, builtBy: defaultImports

test {
    dependsOn releaseNotes
    inputs.files releaseNotesMarkdown.source withPropertyName "releaseNotesSource"
    inputs.dir releaseNotes.destinationDir withPropertyName "releaseNotesRendered"
    systemProperty "org.gradle.docs.releasenotes.source", releaseNotesMarkdown.source.singleFile
    systemProperty "org.gradle.docs.releasenotes.rendered", new File(releaseNotes.destinationDir, releaseNotes.fileName)
}

java9Test {
    dependsOn releaseNotes
    systemProperty "org.gradle.docs.releasenotes.source", releaseNotesMarkdown.source.singleFile
    systemProperty "org.gradle.docs.releasenotes.rendered", new File(releaseNotes.destinationDir, releaseNotes.fileName)
}

task docs {
    dependsOn javadocAll, userguide, distDocs, samplesDocs, dslHtml, releaseNotes
    description = 'Generates all documentation'
    group = 'documentation'
}

task docsZip(type: Zip) {
    from project.outputs.docs
}

class Xhtml2Pdf extends DefaultTask {
    @InputFile
    File sourceFile

    @OutputFile
    File destFile

    @InputFiles
    FileCollection classpath

    @TaskAction
    def transform() {
        def uris = classpath.files.collect {it.toURI().toURL()}
        def classloader = new URLClassLoader(uris as URL[], getClass().classLoader)
        def renderer = classloader.loadClass('org.xhtmlrenderer.pdf.ITextRenderer').newInstance()
        renderer.setDocument(sourceFile)
        renderer.layout()
        destFile.withOutputStream {
            renderer.createPDF(it)
        }
    }
}