description = 'Builds the Prelert Engine native binaries and Java classes'

import org.gradle.internal.os.OperatingSystem
import org.gradle.plugins.ide.eclipse.model.SourceFolder
import org.elasticsearch.gradle.precommit.LicenseHeadersTask
import org.elasticsearch.gradle.VersionProperties

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardCopyOption

project.ext.awsAccessKey = AWS_ACCESS_KEY
project.ext.awsSecretKey = AWS_SECRET_KEY

boolean isWindows = OperatingSystem.current().isWindows()
boolean isLinux = OperatingSystem.current().isLinux()
boolean isMacOsX = OperatingSystem.current().isMacOsX()

project.ext.bash = isWindows ? "C:\\Program Files\\Git\\bin\\bash" : "/bin/bash"

// norelease: replace with something else when we become part of x-plugins
project.ext.nasDirectory = isWindows ? "\\\\prelert-nas\\builds\\6.5.0\\" :
    (isMacOsX ? "/Volumes/builds/6.5.0/" : "/export/builds/6.5.0/")
// norelease: replace with something else when we become part of x-plugins
project.ext.nasExtension = '_' + (System.getenv()['GIT_COMMIT'] ?: 'xxxxxxxxxxxxxx').substring(0, 14) +
    (isWindows ? "_windows-x86_64.zip" : (isMacOsX ? "_darwin-x86_64.zip" :
    (isLinux ? "_linux-x86_64.zip" : "_sunos-x86_64.zip")))

// C++ build can be explicitly enabled or disabled, or if neither is chosen
// it will be enabled if the necessary 3rd party dependencies are present
String cppEnabledStr = properties.get('xpack.cpp.build', 'auto')
if (['true', 'false', 'auto'].contains(cppEnabledStr) == false) {
  throw new GradleException("xpack.cpp.build must be true or false, got ${cppEnabledStr}")
}
project.ext.cppEnabled = cppEnabledStr == 'true'
if (cppEnabledStr == 'auto') {
    // Disable the C++ build if the 3rd party tools/libraries aren't available
    String[] cmdArray = [ project.ext.bash, '-c', 'source cpp/set_env.sh && 3rd_party/3rd_party.sh --check' ]
    Process checkProcess = Runtime.getRuntime().exec(cmdArray, null, rootDir)
    StringBuffer checkOutput = new StringBuffer()
    checkProcess.consumeProcessOutputStream(checkOutput)
    if (checkProcess.waitFor() == 0) {
        project.ext.cppEnabled = true
    } else {
        println 'C++ dependencies not available - disabling C++ build'
        println checkOutput
        project.ext.cppEnabled = false
    }
}

configurations.all {
    // check for updates every build
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

buildscript {
    repositories {
        if (System.getProperty("repos.mavenlocal") != null) {
            // with -Drepos.mavenlocal=true we can force checking the local .m2 repo which is useful for building against
            // elasticsearch snapshots
            mavenLocal()
        }
        mavenCentral()
        maven {
            name 'sonatype-snapshots'
            url "https://oss.sonatype.org/content/repositories/snapshots/"
        }
        jcenter()
    }
    dependencies {
        classpath group: 'org.elasticsearch.gradle', name: 'build-tools', version: "${elasticsearchVersion}", changing: true
    }
}

subprojects {
  // we must not publish to sonatype until we have set up x-plugins to only publish the parts we want to publish!
  project.afterEvaluate {
    if (project.plugins.hasPlugin('com.bmuschko.nexus') && project.nexus.repositoryUrl.startsWith('file://') == false) {
      uploadArchives.enabled = false
    }
  }
}

task bundlePack(type: Zip) {
  onlyIf { project('kibana').bundlePlugin.enabled && project('cpp').strip.enabled }
  dependsOn 'elasticsearch:bundlePlugin'
  dependsOn 'kibana:bundlePlugin'
  from { zipTree(project('elasticsearch').bundlePlugin.outputs.files.singleFile) }
  from { zipTree(project('kibana').bundlePlugin.outputs.files.singleFile) }
  destinationDir file('build/distributions')
  baseName = 'prelert'
  version = VersionProperties.elasticsearch
}

task assemble(dependsOn: bundlePack) {
  group = 'Build'
  description = 'Assembles the outputs of this project.'
}

task build(dependsOn: assemble) {
  group = 'Build'
  description = 'Assembles and tests this project.'
}

task clean(type: Delete) {
  group = 'Build'
  description = 'Deletes the build directory'
  delete 'build'
}

// norelease: this won't be needed when the pluginAll task below is removed
class SimpleCopy extends DefaultTask {
  String sourceFile;
  String destFile;

  @TaskAction
  def copy() {
    Files.copy(Paths.get(sourceFile), Paths.get(destFile), StandardCopyOption.REPLACE_EXISTING)
  }
}

// norelease: by the time we move to x-plugins we cannot use the Prelert NAS at all
task uploadPack(type: SimpleCopy) {
  // This doesn't use a Copy task because that builds hashes for a huge number of files on the NAS
  String zipFile = "prelert-${elasticsearchVersion}.zip"
  sourceFile = "${projectDir}/build/distributions/" + zipFile
  destFile = project.ext.nasDirectory + zipFile.replace('.zip', project.ext.nasExtension)
}

uploadPack.dependsOn build

task deploy(dependsOn: uploadPack) {

}

subprojects {
    apply plugin: 'eclipse'
    apply plugin: 'idea'

    buildscript {
        repositories {
            if (System.getProperty("repos.mavenlocal") != null) {
                // with -Drepos.mavenlocal=true we can force checking the local .m2 repo which is useful for building against
                // elasticsearch snapshots
                mavenLocal()
            }
            mavenCentral()
            maven {
                name 'sonatype-snapshots'
                url "https://oss.sonatype.org/content/repositories/snapshots/"
            }
            jcenter()
        }
    }

    group = 'org.elasticsearch.prelert'

    repositories {
        if (System.getProperty("repos.mavenlocal") != null) {
            // with -Drepos.mavenlocal=true we can force checking the local .m2 repo which is useful for building against
            // elasticsearch snapshots
            mavenLocal()
        }
        mavenCentral()
        maven {
            name 'sonatype-snapshots'
            url "https://oss.sonatype.org/content/repositories/snapshots/"
        }
        jcenter()
    }

    tasks.withType(LicenseHeadersTask.class) {
      approvedLicenses = ['Elasticsearch Confidential']
      additionalLicense 'ESCON', 'Elasticsearch Confidential', 'ELASTICSEARCH CONFIDENTIAL'
    }
}

allprojects {
  // injecting groovy property variables into all projects
  project.ext {
    // for ide hacks...
    isEclipse = System.getProperty("eclipse.launcher") != null || gradle.startParameter.taskNames.contains('eclipse') || gradle.startParameter.taskNames.contains('cleanEclipse')
    isIdea = System.getProperty("idea.active") != null || gradle.startParameter.taskNames.contains('idea') || gradle.startParameter.taskNames.contains('cleanIdea')
  }
}

// intellij configuration
allprojects {
  apply plugin: 'idea'

  if (isIdea) {
    project.buildDir = file('build-idea')
  }
  idea {
    module {
      inheritOutputDirs = false
      outputDir = file('build-idea/classes/main')
      testOutputDir = file('build-idea/classes/test')

      // also ignore other possible build dirs
      excludeDirs += file('build')
      excludeDirs += file('build-eclipse')

      iml {
        // fix so that Gradle idea plugin properly generates support for resource folders
        // see also https://issues.gradle.org/browse/GRADLE-2975
        withXml {
          it.asNode().component.content.sourceFolder.findAll { it.@url == 'file://$MODULE_DIR$/src/main/resources' }.each {
            it.attributes().remove('isTestSource')
            it.attributes().put('type', 'java-resource')
          }
          it.asNode().component.content.sourceFolder.findAll { it.@url == 'file://$MODULE_DIR$/src/test/resources' }.each {
            it.attributes().remove('isTestSource')
            it.attributes().put('type', 'java-test-resource')
          }
        }
      }
    }
  }
}

// Make sure gradle idea was run before running anything in intellij (including import).
File ideaMarker = new File(projectDir, '.local-idea-is-configured')
tasks.idea.doLast {
  ideaMarker.setText('', 'UTF-8')
}
if (System.getProperty('idea.active') != null && ideaMarker.exists() == false) {
  throw new GradleException('You must run gradle idea from the root of elasticsearch before importing into IntelliJ')
}

// eclipse configuration
allprojects {
  apply plugin: 'eclipse'
  // Name all the non-root projects after their path so that paths get grouped together when imported into eclipse.
  if (path != ':') {
    eclipse.project.name = path
    if (isWindows) {
      eclipse.project.name = eclipse.project.name.replace(':', '_')
    }
  }

  plugins.withType(JavaBasePlugin) {
    File eclipseBuild = project.file('build-eclipse')
    eclipse.classpath.defaultOutputDir = eclipseBuild
    if (isEclipse) {
      // set this so generated dirs will be relative to eclipse build
      project.buildDir = eclipseBuild
    }
    eclipse.classpath.file.whenMerged { classpath ->
      // give each source folder a unique corresponding output folder
      int i = 0;
      classpath.entries.findAll { it instanceof SourceFolder }.each { folder ->
        i++;
        // this is *NOT* a path or a file.
        folder.output = "build-eclipse/" + i
      }
    }
  }
  task copyEclipseSettings(type: Copy) {
    // TODO: "package this up" for external builds
    from new File(project.rootDir, 'buildSrc/src/main/resources/eclipse.settings')
    into '.settings'
  }
  // otherwise .settings is not nuked entirely
  task wipeEclipseSettings(type: Delete) {
    delete '.settings'
  }
  tasks.cleanEclipse.dependsOn(wipeEclipseSettings)
  // otherwise the eclipse merging is *super confusing*
  tasks.eclipse.dependsOn(cleanEclipse, copyEclipseSettings)
}