/*
 * 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.
 */
import org.gradle.api.internal.artifacts.publish.ArchivePublishArtifact;

apply plugin: 'distribution'

// disable artifact generation for this project
jar.enabled = false
extraArchive {
  sources = false
  javadoc = false
  tests = false
}

disableMavenPublishing()

// Gradle doesn't automatically remove the jar artifact even though we disabled it
// this causes publishing to fail.  So we nuke all the disabled artifacts from all configurations.
configurations.all {
  artifacts.removeAll artifacts.findAll { it instanceof ArchivePublishArtifact && !it.archiveTask.enabled }
}

gradle.taskGraph.whenReady( { graph ->
  tasks.withType(Tar).each { tar ->
    tar.compression = Compression.GZIP
    tar.extension = 'tar.gz'
  }
})

configurations {
  bundled {
    description 'A dependency that is shipped with geode, but is not required to compile'
  }
  gfshDependencies
}

dependencies {
  provided project(':geode-core')

  archives project(':geode-common')  
  archives project(':geode-json')  
  archives project(':geode-core')
  archives project(':geode-lucene')
  archives project(':geode-web')
  archives project(':geode-web-api')
  archives project(':geode-pulse')
  archives project(':geode-wan')
  archives project(':geode-cq')

  testCompile project(':geode-junit')
  testCompile files(project(':geode-core').sourceSets.test.output)
  testCompile ('org.springframework:spring-web:' + project.'springframework.version') {
    exclude module: 'aopalliance'
    exclude module: 'spring-aop'
  }

  testCompile 'org.apache.httpcomponents:httpclient:' + project.'httpclient.version'
  testCompile 'org.apache.httpcomponents:httpcore:' + project.'httpcore.version'

  testRuntime files("${System.getProperty('java.home')}/../lib/tools.jar")
  testRuntime files("$buildDir/install/${distributions.main.baseName}/lib/geode-dependencies.jar")


  gfshDependencies ('org.springframework:spring-web:' + project.'springframework.version'){
    exclude module: 'spring-core'
    exclude module: 'commons-logging'
  }
}

sourceSets {
  // need to remove this since we use the dependencies jar out of the install dir
  //test.runtimeClasspath -= configurations.provided
}

test {
  // test from the actual classpath not the gradle classpath
  dependsOn installDist
  // @TODO: this doesn't seem to be working need to get basename first.
  classpath += files "$buildDir/install/${distributions.main.baseName}/lib/geode-dependencies.jar"
}

tasks.withType(Test){
  environment 'GEMFIRE', "$buildDir/install/${distributions.main.baseName}/lib"
}

task defaultDistributionConfig(type: JavaExec, dependsOn: classes) {
  outputs.file file("$buildDir/gemfire.properties")
  main 'com.gemstone.gemfire.distributed.internal.DistributionConfigImpl'
  classpath project(':geode-core').sourceSets.main.runtimeClasspath
  workingDir buildDir
  
  doFirst {
    buildDir.mkdirs()
  }
}

task defaultCacheConfig(type: JavaExec, dependsOn: classes) {
  outputs.file file("$buildDir/cache.xml")
  main 'com.gemstone.gemfire.internal.cache.xmlcache.CacheXmlGenerator'
  classpath project(':geode-core').sourceSets.main.runtimeClasspath
  workingDir buildDir

  doFirst {
    buildDir.mkdirs()
  }
}

// This closure sets the gemfire classpath.  If we add another jar to the classpath it must
// be included in the filter logic below.
def cp = {
  // first add all the dependent project jars
  def jars = configurations.archives.dependencies.collect { it.dependencyProject }
    .findAll { !it.name.contains('web') }
    .collect { it.jar.archiveName }
    .join(' ')

  // then add all the dependencies of the dependent jars
  jars += ' ' + configurations.archives.dependencies.collect { 
    it.dependencyProject.configurations.runtime.collect { it.getName() }.findAll {
      // depedencies from geode-core
      it.contains('antlr') ||
      it.contains('commons-io') ||
      it.contains('commons-lang') ||
      it.contains('commons-logging') ||
      it.contains('fastutil') ||
      it.contains('jackson-annotations') ||
      it.contains('jackson-core') ||
      it.contains('jackson-databind') ||
      it.contains('jansi') ||
      it.contains('javax.resource-api') ||
      it.contains('javax.servlet-api') ||
      it.contains('javax.transaction-api') ||
      it.contains('jetty-http') ||
      it.contains('jetty-io') ||
      it.contains('jetty-security') ||
      it.contains('jetty-server') ||
      it.contains('jetty-servlet') ||
      it.contains('jetty-webapp') ||
      it.contains('jetty-util') ||
      it.contains('jetty-xml') ||
      it.contains('jline') ||
      it.contains('jna') ||
      it.contains('jopt-simple') ||
      it.contains('log4j-api') ||
      it.contains('log4j-core') ||
      it.contains('log4j-jcl') ||
      it.contains('log4j-jul') ||
      it.contains('log4j-slf4j-impl') ||
      it.contains('shiro') ||
      it.contains('slf4j-api') ||
      it.contains('spring-core') ||
      it.contains('spring-shell') ||
      it.contains('snappy') ||
      it.contains('hbase') ||
      it.contains('jgroups') ||
      it.contains('netty') ||
      
      // dependencies from geode-lucene
      it.contains('lucene-analyzers-common') ||
      it.contains('lucene-core') ||
      it.contains('lucene-queries') ||
      it.contains('lucene-queryparser')
    }
  }.flatten().unique().join(' ')

  return jars
}

// Note: this dependency doesn't work if you change a library version from
// a dependent project.  Please fix me.
task depsJar (type: Jar, dependsOn: ':geode-core:classes') {
  description 'Assembles the jar archive that defines the gemfire classpath.'
  archiveName 'geode-dependencies.jar'
  doFirst {
    manifest { 
      attributes("Class-Path": cp())
    }
  }
}

// Note: this dependency doesn't work if you change a library version from
// a dependent project.  Please fix me.
task gfshDepsJar (type: Jar, dependsOn: ':geode-core:classes') {
  description 'Assembles the jar archive that defines the gfsh classpath.'
  archiveName 'gfsh-dependencies.jar'
  doFirst {
    manifest {
      attributes("Class-Path": cp() + 
        ' ' + project(':geode-core').webJar.archiveName +
        ' ' + configurations.gfshDependencies.collect{ it.getName() }.flatten().join(' ')
      )
    }
  }
}


def docsDir = file("$buildDir/javadocs")
task docs(type: Javadoc) {
    options.addStringOption('Xdoclint:none', '-quiet')
    options.encoding='UTF-8'
    source parent.subprojects*.javadoc*.source
    classpath = files(parent.subprojects*.javadoc*.classpath)
    title = "Apache Geode ${project.version}"
    include 'com/gemstone/gemfire/**/'
    exclude 'com/gemstone/gemfire/internal/**/'
    exclude 'com/gemstone/gemfire/**/internal/**/'
    exclude 'com/gemstone/gemfire/**/xml/**/'
    exclude 'com/gemstone/gemfire/distributed/**/util/**/'
    exclude 'com/gemstone/gemfire/test/**/'
    destinationDir = docsDir

    doLast {
      parent.subprojects.each { project ->
        copy {
          from project.sourceSets.main.resources.srcDirs
          into docsDir
          include 'javadoc-images/*'
        }
      }
   }
}

task writeBuildInfo {
  def buildInfo = file "$buildDir/.buildinfo"
  outputs.file buildInfo
  doLast {
    buildInfo.getParentFile().mkdirs();
    new FileOutputStream(buildInfo).withStream { fos ->
      project(':geode-core').readScmInfo().store(fos, '')
    }
  }
}

gradle.taskGraph.whenReady( { graph ->
  tasks.withType(AbstractArchiveTask).findAll {
    it.name.toLowerCase().contains("dist")
  }.each { archive ->
    archive.doLast {
      ant.checksum file:"${archive.archivePath}", algorithm:"md5", format: 'MD5SUM'
      ant.checksum file:"${archive.archivePath}", algorithm:"sha-256", format: 'MD5SUM', fileext: '.sha256'
    }
  }
})

distributions {
  src {
    baseName = 'apache-geode-src'
    contents {
      from writeBuildInfo
      from (rootDir) {
        exclude 'KEYS'
        exclude '**/gradlew'
        exclude '**/gradlew.bat'
        exclude '**/gradle/wrapper/gradle-wrapper.jar'
        exclude '**/.gradle'
        exclude '**/build/**'
        exclude 'geode-spark-connector/**/target/**'
        exclude 'geode-spark-connector/project/project'
        exclude '**/.project'
        exclude '**/.classpath'
        exclude '**/.settings/**'
        exclude '**/build-eclipse/**'
        exclude '**/.idea/**'
        exclude '**/*.iml'
        exclude '**/*.ipr'
        exclude '**/*.iws'
        exclude '**/.travis.yml'
        exclude '**/tags'

        //These directories are generated on the jenkins server by gradle
        exclude 'caches'
        exclude 'daemon'
        exclude 'native'
        exclude 'wrapper'
      }

      into ('geode-examples') {
        from project.file( 'src/src/dist/gradlew' )
      }
    }
  }

  main {
    baseName = 'apache-geode' //TODO rootProject.name
    contents {
      duplicatesStrategy 'exclude'
      exclude '*.asc'
      
      exclude '*.asc'
      exclude '*-sources.jar'
      exclude '*-javadoc.jar'

      from rootProject.file( 'README.md' )

      into ('config') {
        from defaultCacheConfig
        from defaultDistributionConfig
        from (project(':geode-core').sourceSets.main.resources.files.find {
          it.name == 'log4j2.xml' 
        })
      }
      
      into ('lib') {
        from project(":geode-common").configurations.runtime
        from project(":geode-common").configurations.archives.allArtifacts.files

        from project(":geode-json").configurations.runtime
        from project(":geode-json").configurations.archives.allArtifacts.files

        from project(":geode-wan").configurations.runtime
        from project(":geode-wan").configurations.archives.allArtifacts.files

        from project(":geode-cq").configurations.runtime
        from project(":geode-cq").configurations.archives.allArtifacts.files

        from project(":geode-core").configurations.runtime
        from project(":geode-core").configurations.archives.allArtifacts.files

        from project(":geode-lucene").configurations.runtime
        from project(":geode-lucene").configurations.archives.allArtifacts.files

        from configurations.bundled
        from configurations.gfshDependencies

        //These tasks are included as closures (wrapped in {}) because gradle may evaluate
        //this CopySpec before it evaluates the geode-core build file.
        from { project(":geode-core").webJar }
        from { project(":geode-core").raJar }
        from { project(":geode-core").jcaJar }

        // include this jar        
        from project(":geode-web-api").jar
        
        // dependency jars
        from depsJar
        from gfshDepsJar
      }

      into ('tools/Extensions') {
        from (project(":geode-web").configurations.archives.allArtifacts.files) {
          exclude '*.jar'
        }
        from (project(":geode-web-api").configurations.archives.allArtifacts.files) {
          exclude '*.jar'
        }
      }

      into ('javadoc') {
        from docs
      }

      into ('tools/Pulse') {
        from (project(":geode-pulse").configurations.archives.allArtifacts.files) {
          exclude '*.jar'
        }
      }

      into ('tools/Modules') {
        from (project(':extensions/geode-modules-assembly').configurations.moduleDistOutputs.files)
      }
    }
  }
}

// Create a configuration closure to configure test targets with the install directory
def dependOnInstalledProduct = {
  dependsOn installDist
  def install = file("$buildDir/install/${distributions.main.baseName}")
  environment ('GEMFIRE', install)
}

// Add the configuration closure to the test targets so they depend on the install directory
test dependOnInstalledProduct
distributedTest dependOnInstalledProduct
integrationTest dependOnInstalledProduct
flakyTest dependOnInstalledProduct

// Make build final task to generate all test and product resources
build.dependsOn installDist

installDist.dependsOn ':extensions/geode-modules-assembly:dist'

/**Print the names of all jar files in a fileTree */
def printJars(tree) {
  tree.matching {include("**/*.jar")}.visit{ file -> 
    if(!file.isDirectory()) {
      println file.name
    }
  };
}

task dumpInstalledJars(dependsOn: installDist) << {
  description "Dump a list of all of the jars shipped with the binary distribution, for validation purposes"

  FileTree installDir = fileTree(dir: installDist.destinationDir)

  println("Jars in the binary install")
  println("==========================")
  printJars(installDir)

  installDir.include("**/*.war").visit{ file -> 
    if(!file.isDirectory()) {
        FileTree warContents = zipTree(file.file)
        println ""
        println file.name
        println("==========================")
        printJars(warContents);
    } 
  };
}