project.ext {
  title = "Qi4j SDK"
  description = "Qi4j™ is a framework for domain centric application development, including evolved concepts from AOP, DI and DDD."
  testFailures = [ ]
  mainClassName = 'org.qi4j.container.Main'
  groovycMain_mx = "512m"
  groovycMain_permSize = "128m"
  groovycMain_maxPermSize = "256m"
}


apply plugin: 'java'
apply plugin: 'idea'
apply plugin: 'signing'
apply plugin: 'maven'
apply from: 'maven-compat.gradle'
apply plugin: 'project-report'
apply plugin: 'sonar'
apply from: 'libraries.gradle'

targetCompatibility = "1.6"
sourceCompatibility = "1.6"

// Collect the modules that fulfills the Release Criteria.
project.ext {
  releaseSpec = new org.qi4j.gradle.plugin.ModuleReleaseSpecification()
}

def releaseApprovedProjects = allprojects.findAll( { project ->  rootProject.ext.releaseSpec.satisfiedBy( project ) } )

buildscript {
  repositories {
    mavenCentral()
  }
}


// External tools BEGIN ---------------------------------------------------

// Sonar configuration - Used at nemo.sonarsource.org
// Using system properties for easy configuration from outside the build
sonar {
    server {
        url = System.getProperty("sonar.host.url") ?: "http://localhost:9000/"
    }
    database {
        url = System.getProperty("sonar.jdbc.url") ?: "jdbc:h2:tcp://localhost:9092/sonar"
        driverClassName = System.getProperty("sonar.jdbc.driver") ?: "org.h2.Driver"
        username = System.getProperty("sonar.jdbc.username") ?: "sonar"
        password = System.getProperty("sonar.jdbc.password") ?: "sonar"
    }
}

// IDEA plugin configuration
idea.project.ipr {
  withXml { provider ->
    provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'
  }
}

// External tools END -----------------------------------------------------

// Define repositories URLs here so we can reuse them in the build script
// Needed as Gradle forbid access to declared repositories URLs by design
// Releasable submodules should not declare repositories in their own build files
def repos_urls = [
  mavenCentral: "http://repo1.maven.org/maven2/",
  ops4j: "http://repository.ops4j.org/maven2/",
  aduna: "http://repo.aduna-software.org/maven2/releases/",
  restlet: 'http://maven.restlet.org',
  javanet: "http://download.java.net/maven/2",
]

allprojects {

  apply plugin: 'eclipse'
  apply plugin: 'idea'
  apply plugin: 'signing'
  apply plugin: 'java'
//  apply plugin: 'checkstyle'
  apply plugin: 'project-report'
  apply plugin: 'maven'


  defaultTasks 'classes', 'test'

  group = name.substring( 0, name.lastIndexOf( '.' ) )
  version = System.properties.version ?: "0"
  [ compileJava, compileTestJava, javadoc ]*.options*.encoding = 'UTF-8'

  repositories {
    mavenCentral()
    mavenRepo name: 'ops4j-repo', url: repos_urls.ops4j
    mavenRepo name: 'aduna-repo', url: repos_urls.aduna
    mavenRepo name: 'restlet-repo', url: repos_urls.restlet
    mavenRepo name: 'maven2-repository.dev.java.net', url: repos_urls.javanet
  }

  // Artifact upload global configuration BEGIN -----------------------------

  def uploadSnapshots = version.contains("SNAPSHOT")
  def uploadReleases = ! uploadSnapshots
  // By default RELEASES are signed, SNAPSHOTS are not
  // Signing can be turned on or off by setting the uploadSigned property
  def uploadSigned = rootProject.hasProperty('uploadSigned') \
                        ? rootProject.uploadSigned : uploadReleases \
                        ? true : false
  // By default RELEASES must satisfy ReleaseSpecification, SNAPSHOT don't
  // ReleaseSpecification usage can be turned on or off by setting the uploadReleaseSpec property
  def uploadReleaseSpec = rootProject.hasProperty('uploadReleaseSpec') \
                             ? rootProject.uploadReleaseSpec : uploadReleases \
                             ? true : false
  // By default RELEASES are uploaded using SSH, SNAPSHOTS using WEBDAV
  // Used Wagon can be overriden by setting the uploadWagon property
  // def wagonSSH = "org.apache.maven.wagon:wagon-ssh:1.0-beta-2"
  def wagonWEBDAV = "org.apache.maven.wagon:wagon-webdav:1.0-beta-2"
  def uploadWagon = rootProject.hasProperty('uploadWagon') \
                        ? rootProject.uploadWagon : wagonWEBDAV
  // By default RELEASES are uploaded to OPS4J, SNAPSHOTS to Cloudbees
  // Target repository can be overriden by setting the uploadRepository property
  def releasesRepository = "dav:https://repository-qi4j.forge.cloudbees.com/release/"
  def snapshotsRepository = "dav:https://repository-qi4j.forge.cloudbees.com/snapshot/"
  def uploadRepository = rootProject.hasProperty('uploadRepository') \
                            ? rootProject.uploadRepository \
                            : uploadReleases ? releasesRepository : snapshotsRepository
  // No username/password is provided by default
  // If needed set them using the uploadUsername and uploadPassword properties
  def uploadUsername = rootProject.hasProperty('uploadUsername') ? rootProject.uploadUsername : null
  def uploadPassword = rootProject.hasProperty('uploadPassword') ? rootProject.uploadPassword : null

  // Artifact upload global configuration END -------------------------------


  configurations {
    archives
    deployerJars
    provided
    compile.extendsFrom provided
    runtime.extendsFrom compile
  }

  dependencies {
    testCompile( libraries.ant )
    testCompile( libraries.ant_junit )
    testCompile( libraries.junit )
    testRuntime( libraries.asm, libraries.asm_commons, libraries.asm_util )
    deployerJars( uploadWagon )
  }

  test.onlyIf { !project.hasProperty( 'skipTests' ) }
  test {
      testLogging {
          info {
              exceptionFormat "full"
          }
      }
  }

  sourceSets {
    docs {
      resources {
        srcDir 'src/docs'
      }
    }
  }

  project.ext {
    javaDir = new File( "$projectDir/src/main/java" )
    scalaDir = new File( "$projectDir/src/main/scala" )
    documentationDir = new File( "$projectDir/src/docs" )
    testJavaDir = new File( "$projectDir/src/tests/java" )
    testScalaDir = new File( "$projectDir/src/tests/scala" )
  }

  // Actual code projects BEGIN -------------------------------------------
  if( ext.javaDir.isDirectory() || ext.scalaDir.isDirectory() ||
      ext.testJavaDir.isDirectory() || ext.testScalaDir.isDirectory() )
  {
    apply plugin: 'osgi'
    apply plugin: VersionClass
    apply plugin: AsciidocBuildInfo

//    if( name == "org.qi4j.core.runtime" )
//    {
//      checkstyleMain {
//        configFile = new File( "$rootProject.projectDir.absolutePath/etc/qi4j-runtime-checkstyle.xml" )
//        ignoreFailures = true
//      }
//    }
//    else
//    {
//      checkstyleMain {
//        configFile = new File( rootProject.projectDir.absolutePath.toString() + '/etc/qi4j-api-checkstyle.xml' )
//        ignoreFailures = true
//        reporting.baseDir = "$rootProject.reporting.baseDir/checkstyle"
//      }
//    }
//    checkstyleTest {
//      configFile = new File( "$rootProject.projectDir.absolutePath/etc/qi4j-tests-checkstyle.xml" )
//      ignoreFailures = true
//    }
//
//    checkstyleVersion {
//      configFile = new File( "$rootProject.projectDir.absolutePath/etc/qi4j-tests-checkstyle.xml" )
//      ignoreFailures = true
//    }

    jar {
      manifest {
        license = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
        docURL = 'http://www.qi4j.org'
        description = project.description ?: 'Qi4j is a platform for Composite Oriented Programming'
        vendor = 'Qi4j Community, http://www.qi4j.org'
        instruction '-debug', 'true'
      }
    }

    signing {
      required { uploadSigned }
      sign configurations.archives
    }

    task sourceJar( type: Jar ) {
      classifier = "sources"
      from sourceSets.main.allSource
    }

    task testSourceJar( type: Jar ) {
      classifier = "testsources"
      from sourceSets.test.allSource
    }

    task javadocJar( type: Jar ) {
      classifier = "javadoc"
      from javadoc.destinationDir
      dependsOn javadoc
    }

    artifacts {
      archives sourceJar, testSourceJar, javadocJar
    }

    def testProperties = [
            'proxySet': System.properties[ 'proxySet' ],
            'proxyHost': System.properties[ 'proxyHost' ],
            'proxyPort': System.properties[ 'proxyPort' ] ]

    test {
      maxHeapSize = "1024m"
      systemProperties = testProperties
      ignoreFailures = true
      testReport = true
      afterSuite { descriptor, result ->
        if( result.resultType == TestResult.ResultType.FAILURE )
        {
          rootProject.ext.testFailures << project
        }
      }
    }

//    // Create checkstyle report
//    task checkstyleReport( type: Xslt, dependsOn: check ) {
//      source project.checkstyle.reportsDir
//      include '*.xml'
//      destDir = file( "build/reports/checkstyle/" )
//      extension = 'html'
//      stylesheetFile = file( "$rootProject.projectDir/etc/checkstyle-noframes.xsl" )
//    }
//

    // Dependency Report generate only the runtime configuration
    // The report is packaged in the SDK distributions
    dependencyReport {
        configurations = [ project.configurations.runtime ]
    }

    // Sonar configuration, mainly for code coverage BEGIN ----------------
    // See http://www.gradle.org/docs/current/userguide/dependency_management.html#sub:configurations
    // and http://www.gradle.org/docs/current/dsl/org.gradle.api.artifacts.ConfigurationContainer.html
    configurations {
        jacoco // Configuration Group used by Sonar to provide Code Coverage using JaCoCo
        sonar {
          project {
              dynamicAnalysis  = "reuseReports"
              withProjectProperties { props ->
                  props["sonar.core.codeCoveragePlugin"] = "jacoco"
                  props["sonar.jacoco.reportPath"]       = "${buildDir}/jacoco.exec"
              }
          }
        }
    }
    dependencies {
        jacoco group: "org.jacoco", name: "org.jacoco.agent", version: "0.5.10.201208310627", classifier: "runtime"
    }
    test {
        jvmArgs "-javaagent:${configurations.jacoco.asPath}=destfile=${buildDir}/jacoco.exec,includes=org.qi4j.*"
    }
    // Sonar configuration, mainly for code coverage END ------------------

    task minBuild {
      dependsOn classes
      dependsOn test
    }

  }
  // Actual code projects END ---------------------------------------------

  // Upload Archives - Artifact Deployment
  uploadArchives.doFirst {
    if( version == "0" )
    {
      throw new GradleException( "'version' must be given as a system property to perform a release." )
    }
  }

  uploadArchives.onlyIf { ( !uploadReleaseSpec || ( releaseApprovedProjects.contains( project ) || project == rootProject ) ) && !project.hasProperty( 'skipUpload' ) }
  uploadArchives {
    dependsOn check
    repositories.mavenDeployer {
      if( uploadSigned )
        beforeDeployment { MavenDeployment deployment -> signing.signPom( deployment ) }
      configuration = configurations.deployerJars
      repository(url: uploadRepository) {
        if( uploadUsername )
          authentication(userName: uploadUsername, password: uploadPassword)
      }
      snapshotRepository(url: uploadRepository) {
        if( uploadUsername )
          authentication(userName: uploadUsername, password: uploadPassword)
      }
    }
  }

  idea.module.iml {
    whenMerged { module ->
      module.dependencies*.exported = true
    }
  }
} // allproject END -------------------------------------------------------

gradle.taskGraph.whenReady {taskGraph ->
  taskGraph.allTasks.last().doLast {
    if( rootProject.ext.testFailures )
    {
      println "\nTest failures in:"
      rootProject.ext.testFailures.unique().each { project -> println "  " + project.name }
      println ""
      throw new RuntimeException( "There was TEST FAILURES!! See list above." )
    }
  }
}

task globalTestReport( type: TestReport ) {
  destinationDir = file("$buildDir/reports/tests")
  reportOn subprojects*.test
}

test {
  dependsOn subprojects*.test, globalTestReport
  testReport = false
}

// Build the whole SDK public Javadoc
task javadocs( type: Javadoc ) {

  options.docFilesSubDirs = true
  options.encoding = "UTF-8"
  options.overview = "${rootProject.projectDir}/buildSrc/src/javadoc/overview.html"
  title = "${rootProject.title} ${version}"
  def apiSources = releaseApprovedProjects.findAll( { project ->
    ( project.name.startsWith( 'org.qi4j.core' ) && !project.name.startsWith( 'org.qi4j.core.runtime' ) ) ||
    project.name.startsWith( 'org.qi4j.library' ) ||
    project.name.startsWith( 'org.qi4j.extension' ) ||
    project.name.startsWith( 'org.qi4j.tool' )
  } )
  source apiSources.collect { project ->
    project.sourceSets.main.allJava
  }
  destinationDir = new File( "" + buildDir + '/docs/javadoc' )
  // Might need a classpath
  classpath = files( apiSources.collect { project ->
    project.sourceSets.main.compileClasspath
  } )
  options.links( "http://java.sun.com/j2se/1.6.0/docs/api" )
  options.group( [ "Core API": [ "org.qi4j.api", "org.qi4j.api.*", "org.qi4j.io", "org.qi4j.functional" ],
                         "Core Bootstrap": [ "org.qi4j.bootstrap" ],
                         "Core SPI": [ "org.qi4j.spi", "org.qi4j.spi.*" ],
                         "Libraries": [ "org.qi4j.library.*", "org.qi4j.logging", "org.qi4j.logging.*", "org.qi4j.lang.*" ],
                         "Extensions": [ "org.qi4j.valueserialization.*", "org.qi4j.entitystore.*", "org.qi4j.index.*", "org.qi4j.metrics.*", "org.qi4j.cache.*", "org.qi4j.migration", "org.qi4j.migration.*" ],
                         "Tools": [ "org.qi4j.tools.*", "org.qi4j.envisage", "org.qi4j.envisage.*", "org.qi4j.library.swing.entityviewer" ],
                         "Test Support": [ "org.qi4j.test", "org.qi4j.test.*" ]
                 ] )

}

task archiveJavadocs(type: Copy ) {
  dependsOn javadocs

  if( rootProject.version == '0' || rootProject.version.contains( "SNAPSHOT" ) )
  {
    into( "$rootProject.projectDir/../qi4j.github.com/develop/javadocs/" )
  }
  else
  {
    into( "$rootProject.projectDir/../qi4j.github.com/$version/javadocs/" )
  }
  from( 'build/docs/javadoc/' )
}


// Build All
task buildAll( dependsOn: [
    archiveJavadocs,
    test,
    jar,
    subprojects*.dependencyReport,
    subprojects*.assemble,
    ':org.qi4j.manual:website'
] ) { }

// Prepare runtime dependencies download facility (metalink)
buildAll.doLast {
    def runtimeDepsMetalink = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<metalink xmlns=\"urn:ietf:params:xml:ns:metalink\">\n"
    runtimeDepsMetalink = runtimeDepsMetalink + " <identity>qi4j-sdk-runtime-deps</identity>\n"
    runtimeDepsMetalink = runtimeDepsMetalink + " <version>${version}</version>\n"
    def handledGavPaths = []
    releaseApprovedProjects.each { p ->
      p.configurations.runtime.allDependencies.each { dep ->
        def gavpath = dep.group.replace(".","/") + "/" + dep.name + "/" + dep.version + "/" + dep.name + "-" + dep.version + ".jar"
        if( !dep.group.startsWith("org.qi4j") && !handledGavPaths.contains( gavpath ) ) {
          runtimeDepsMetalink = runtimeDepsMetalink + "  <file name=\"${dep.group}-${dep.name}-${dep.version}.jar\">\n"
          repos_urls.each { repo_url ->
            runtimeDepsMetalink = runtimeDepsMetalink + "    <url>" + repo_url.value + dep.group.replace(".","/") + "/" + dep.name + "/" + dep.version + "/" + dep.name + "-" + dep.version + ".jar" + "</url>\n"
          }
          runtimeDepsMetalink = runtimeDepsMetalink + "  </file>\n\n"
          handledGavPaths << gavpath
        }
      }
    }
    runtimeDepsMetalink = runtimeDepsMetalink + "</metalink>\n"
    new File( buildDir.toString(), "reports" ).mkdirs()
    new File( buildDir.toString(), "reports/qi4j-sdk-runtime-deps.metalink" ).text = runtimeDepsMetalink
}

def srcDistImage = copySpec {
  from '.'
  exclude '**/build/'     // build output
  exclude '**/bin/'       // helper scripts
  exclude 'derby.log'     // Derby test garbage
  exclude '**/*.iml'      // IDEA files
  exclude 'org.qi4j.ipr'  // IDEA files
  exclude 'org.qi4j.iws'  // IDEA files
  exclude '**/out/*'       // build output
  exclude '**/.git/'      // git directories
  exclude '**/.git*'      // git files
  exclude '**/.gradle/'   // gradle management files
  into "qi4j-sdk-$version/src/"

}

def reportsDistImage = copySpec {
  from "$buildDir/reports"
  into( "docs/reports" )
}

def docsImage = copySpec {
  from "build/docs"
  from "manual/build/docs/website"
  into( "docs" )
}

def runtimeDependenciesListImage = copySpec {
  releaseApprovedProjects.collect { p ->
    into( "libs/" ) {
      from "$p.buildDir/reports/project/dependencies.txt"
      rename 'dependencies.txt', p.name + '-' + p.version + '-runtime-deps.txt'
    }
  }
  into( "libs/" ) {
    from "build/reports/qi4j-sdk-runtime-deps.metalink"
    rename 'qi4j-sdk-runtime-deps.metalink', 'qi4j-sdk-' + version + '-runtime-deps.metalink'
  }
}

def libsImage = copySpec {
  releaseApprovedProjects.collect { proj ->
    into( "libs/" ) {
      from proj.configurations.archives.artifacts.files
      exclude '**-testsources.jar'
      exclude '**-javadoc.jar'
      exclude '**/*.asc'
    }
  }
}

def samplesImage = copySpec {
  from( "$projectDir/samples" )
  from( "$projectDir/samples/*/build/docs/javadoc" )
  into( "samples" )
  exclude '**/*.iml'
  exclude '**/build/'     // build output
}

def tutorialsImage = copySpec {
  from( "$projectDir/tutorials" )
  exclude '**/build/'
  into( "tutorials" )
  from( "$projectDir/tutorials/*/build/docs/javadoc" )
  exclude '**/*.iml'
}

def binDistImage = copySpec {
  into "qi4j-sdk-$version"
  with docsImage
  with reportsDistImage
  with runtimeDependenciesListImage
  with libsImage
  with samplesImage
  with tutorialsImage
}

task zipSources( type: Zip, dependsOn: [ buildAll ] ) {
  baseName = 'qi4j-sdk'
  with srcDistImage
  classifier = 'src'
}

task tarSources( type: Tar, dependsOn: [ buildAll ] ) {
  baseName = 'qi4j-sdk'
  with srcDistImage
  compression = Compression.GZIP
  classifier = 'src'
}

task zipBinaries( type: Zip, dependsOn: [ buildAll ] ) {
  baseName = 'qi4j-sdk'
  classifier = 'bin'
  with binDistImage
}

task tarBinaries( type: Tar, dependsOn: [ buildAll ] ) {
  baseName = 'qi4j-sdk'
  classifier = 'bin'
  compression = Compression.GZIP
  with binDistImage
}

artifacts {
  archives zipSources, tarSources, zipBinaries, tarBinaries
}

task dist( type: Copy, dependsOn: install ) {
  with binDistImage
  into "$buildDir/dist"
}

task release {
  description = 'Builds, tests and uploads the release artifacts'
  group = 'release'
  doFirst {
    if( System.properties[ 'version' ] == null || System.properties[ 'version' ].contains( 'SNAPSHOT' ) )
    {
      throw new GradleException( "'version' must be given as a system property to perform a release." )
    }
  }
  dependsOn archiveJavadocs, ':org.qi4j.manual:copyWebsite', allprojects*.uploadArchives, dist
}

//
// This is a task that generates the gradlew scripts, allowing users to run gradle without having gradle installed
// on their system.
// This task should be run by "build master" and the resulting ouput committed to source control.  Its outputs include:
//  1) /gradlew which is the *NIX shell script for executing builds
//  2) /gradlew.bat which is the windows bat script for for executing builds
//  3) /wrapper which is a directory named by the "jarPath" config which contains other needed files.
task wrapper( type: Wrapper ) {
  gradleVersion = '1.5'
}