import org.elasticsearch.gradle.LoggedExec
import org.elasticsearch.gradle.info.BuildParams
import org.elasticsearch.gradle.plugin.PluginBuildPlugin
import org.gradle.internal.jvm.Jvm

import java.nio.charset.StandardCharsets

apply plugin: 'elasticsearch.java-rest-test'
apply plugin: 'elasticsearch.yaml-rest-test'
apply plugin: 'elasticsearch.validate-rest-spec'

archivesBaseName = 'x-pack'

dependencies {
  testImplementation project(xpackModule('core'))
  testImplementation project(path: xpackModule('core'), configuration: 'testArtifacts')
  javaRestTestImplementation project(path: xpackModule('core'), configuration: 'testArtifacts')
  if (false == isEclipse) {
    // let the yamlRestTest see the classpath of test
    // Eclipse doesn't need this because it flattens test deps and gets very, very confused by it
    yamlRestTestImplementation project.sourceSets.test.runtimeClasspath
  }
}

subprojects {
  afterEvaluate {
    if (project.plugins.hasPlugin(PluginBuildPlugin)) {
      // see the root Gradle file for additional logic regarding this configuration
      project.configurations.create('featureAwarePlugin')
      project.dependencies.add('featureAwarePlugin', project.configurations.compileClasspath)
      project.dependencies.add('featureAwarePlugin', project(':x-pack:test:feature-aware'))
      project.dependencies.add('featureAwarePlugin', project.sourceSets.main.output.getClassesDirs())

      File successMarker = file("$buildDir/markers/featureAware")
      task featureAwareCheck(type: LoggedExec) {
        description = "Runs FeatureAwareCheck on main classes."
        dependsOn project.configurations.featureAwarePlugin
        outputs.file(successMarker)

        executable = "${Jvm.current().javaHome}/bin/java"

        // default to main class files if such a source set exists
        final List files = []
        if (project.sourceSets.findByName("main")) {
          files.add(project.sourceSets.main.output.classesDirs)
          dependsOn project.tasks.classes
        }
        // filter out non-existent classes directories from empty source sets
        final FileCollection classDirectories = project.files(files).filter { it.exists() }

        doFirst {
          args('-cp', project.configurations.featureAwarePlugin.asPath, 'org.elasticsearch.xpack.test.feature_aware.FeatureAwareCheck')
          classDirectories.each { args it.getAbsolutePath() }
        }
        doLast {
          successMarker.parentFile.mkdirs()
          successMarker.setText("", 'UTF-8')
        }
      }

      project.precommit.dependsOn featureAwareCheck
    }
  }
}

configurations {
  testArtifacts.extendsFrom testRuntime
  testArtifacts.extendsFrom testImplementation
}

restResources {
  restApi {
    includeCore '*'
    includeXpack '*'
  }
}

//The api and tests need to stay at src/test/... since some external tooling depends on that exact file path.
artifacts {
  restXpackSpecs(new File(projectDir, "src/test/resources/rest-api-spec/api"))
  restXpackTests(new File(projectDir, "src/test/resources/rest-api-spec/test"))
}

def testJar = tasks.register("testJar", Jar) {
  appendix 'test'
  from sourceSets.test.output

  /*
   * Stick the license and notice file in the jar. This isn't strictly
   * needed because we don't publish it but it makes our super-paranoid
   * tests happy.
   */
  metaInf {
    from(project.licenseFile.parent) {
      include project.licenseFile.name
      rename { 'LICENSE.txt' }
    }
    from(project.noticeFile.parent) {
      include project.noticeFile.name
    }
  }
}
artifacts {
  testArtifacts testJar
}

// location for keys and certificates
File keystoreDir = file("$buildDir/keystore")
File nodeKey = file("$keystoreDir/testnode.pem")
File nodeCert = file("$keystoreDir/testnode.crt")

// Add key and certs to test classpath: it expects them there
// User cert and key PEM files instead of a JKS Keystore for the cluster's trust material so that
// it can run in a FIPS 140 JVM
// TODO: Remove all existing uses of cross project file references when the new approach for referencing static files is available
// https://github.com/elastic/elasticsearch/pull/32201
tasks.register("copyKeyCerts", Copy) {
  from(project(':x-pack:plugin:core').file('src/test/resources/org/elasticsearch/xpack/security/transport/ssl/certs/simple/')) {
    include 'testnode.crt', 'testnode.pem'
  }
  into keystoreDir
}
// Add keystores to test classpath: it expects it there
sourceSets.yamlRestTest.resources.srcDir(keystoreDir)
processYamlRestTestResources.dependsOn("copyKeyCerts")
processJavaRestTestResources.dependsOn("copyKeyCerts")

yamlRestTest {
  /*
   * We have to disable setting the number of available processors as tests in the same JVM randomize processors and will step on each
   * other if we allow them to set the number of available processors as it's set-once in Netty.
   */
  systemProperty 'es.set.netty.runtime.available.processors', 'false'


  // TODO: fix this rest test to not depend on a hardcoded port!
  def blacklist = ['getting_started/10_monitor_cluster_health/*']
  if (BuildParams.isSnapshotBuild() == false) {
    // these tests attempt to install basic/internal licenses signed against the dev/public.key
    // Since there is no infrastructure in place (anytime soon) to generate licenses using the production
    // private key, these tests are blacklisted in non-snapshot test runs
    blacklist.addAll(['xpack/15_basic/*', 'license/20_put_license/*', 'license/30_enterprise_license/*'])
  }
  systemProperty 'tests.rest.blacklist', blacklist.join(',')
  dependsOn copyKeyCerts
}

testClusters.all {
  testDistribution = 'DEFAULT' // this is important since we use the reindex module in ML
  setting 'xpack.ml.enabled', 'true'
  setting 'xpack.security.enabled', 'true'
  setting 'xpack.watcher.enabled', 'false'
  // Integration tests are supposed to enable/disable exporters before/after each test
  setting 'xpack.monitoring.exporters._local.type', 'local'
  setting 'xpack.monitoring.exporters._local.enabled', 'false'
  setting 'xpack.security.authc.token.enabled', 'true'
  setting 'xpack.security.authc.api_key.enabled', 'true'
  setting 'xpack.security.transport.ssl.enabled', 'true'
  setting 'xpack.security.transport.ssl.key', nodeKey.name
  setting 'xpack.security.transport.ssl.certificate', nodeCert.name
  setting 'xpack.security.transport.ssl.verification_mode', 'certificate'
  setting 'xpack.security.audit.enabled', 'true'
  setting 'xpack.license.self_generated.type', 'trial'
  // disable ILM history, since it disturbs tests using _all
  setting 'indices.lifecycle.history_index_enabled', 'false'
  keystore 'bootstrap.password', 'x-pack-test-password'
  keystore 'xpack.security.transport.ssl.secure_key_passphrase', 'testnode'

  user username: "x_pack_rest_user", password: "x-pack-test-password"
  user username: "cat_test_user", password: "cat-test-password", role: "cat_test_role"
  extraConfigFile nodeKey.name, nodeKey
  extraConfigFile nodeCert.name, nodeCert
  extraConfigFile 'roles.yml', file('src/test/resources/roles.yml')
}