/*
 * 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.apache.geode.gradle.plugins.DependencyConstraints

if (project.name.endsWith("geode-all-bom")) {
  // This anti-pattern is a workaround -- java-platform must be applied before java or java-library
  // to avoid conflicts over redefining certain configurations.
  // Evaluation as to whether java-platform should be applied at all is left to GEODE-6611.
  apply plugin: 'java-platform'
}
apply plugin: 'java-library'

sourceCompatibility = 1.8
targetCompatibility = 1.8
compileJava.options.encoding = 'UTF-8'

dependencies {
  // log4j-core has an annotation processor that is passed on the compile-classpath via geode-core and others.
  // Fix Gradle warning here until we clean up our own classpath
  annotationProcessor 'org.apache.logging.log4j:log4j-core:' + DependencyConstraints.get('log4j.version')
}

String javaVersion = System.properties['java.version']
if (javaVersion.startsWith("1.8.0") && javaVersion.split("-")[0].split("_")[1].toInteger() < 121) {
  throw new GradleException("Java version 1.8.0_121 or later required, but was " + javaVersion)
}

// apply compiler options
gradle.taskGraph.whenReady({ graph ->
  tasks.withType(JavaCompile).each { javac ->
    javac.configure {
      sourceCompatibility '1.8'
      targetCompatibility '1.8'
      options.encoding = 'UTF-8'
    }
    javac.options.incremental = true
    javac.options.fork = true
    javac.options.forkOptions.with({
      memoryMaximumSize = "768m"
    })
    if (project.hasProperty('compileJVM') && !compileJVM.trim().isEmpty()) {
      javac.options.forkOptions.executable = compileJVM + "/bin/javac"
    }
  }
})

// apply default manifest
gradle.taskGraph.whenReady({ graph ->
  tasks.withType(Jar).each { jar ->
    jar.doFirst {
      manifest {
        attributes(
            "Manifest-Version": "1.0",
            "Created-By": System.getProperty("user.name"),
            "Title": rootProject.name,
            "Version": version,
            "Organization": productOrg
        )
      }
    }
    jar.metaInf {
      from("$rootDir/LICENSE")
      if (jar.source.filter({ it.name.contains('NOTICE') }).empty) {
        from("$rootDir/NOTICE")
      }
    }
  }
})

configurations {
  testOutput {
    extendsFrom testCompile
    description 'a dependency that exposes test artifacts'
  }
}

// This ensures that javadoc and source jars also have any prefix paths stripped and will
// be created as libs/foo-sources.jar instead of libs/extensions/foo-sources.jar for example.
tasks.all { task ->
  if (task instanceof Jar) {
    baseName = project.name
  }
}

task jarTest(type: Jar, dependsOn: testClasses) {
  description 'Assembles a jar archive of test classes.'
  from sourceSets.test.output
  classifier 'test'
}

artifacts {
  testOutput jarTest
}

javadoc {
  destinationDir = file("$buildDir/javadoc")
  options.addStringOption('Xdoclint:none', '-quiet')
  options.encoding = 'UTF-8'
  exclude "**/internal/**"

  classpath += configurations.compileOnly
}