/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch 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.tools.ant.taskdefs.condition.Os
import org.elasticsearch.gradle.LoggedExec
import org.elasticsearch.gradle.Version

import java.nio.charset.StandardCharsets

import static org.elasticsearch.gradle.BuildPlugin.getJavaHome
/**
 * This is a dummy project which does a local checkout of the previous
 * wire compat version's branch, and builds a snapshot. This allows backcompat
 * tests to test against the next unreleased version, closest to this version,
 * without relying on snapshots.
 */
subprojects {

  Version bwcVersion = bwcVersions.getSnapshotForProject(project.name)
  if (bwcVersion == null) {
    // this project wont do anything
    return
  }

  String bwcBranch
  if (project.name == 'next-minor-snapshot') {
    // this is always a .x series
    bwcBranch = "${bwcVersion.major}.x"
  } else {
    bwcBranch = "${bwcVersion.major}.${bwcVersion.minor}"
  }

  apply plugin: 'distribution'
  // Not published so no need to assemble
  tasks.remove(assemble)
  build.dependsOn.remove('assemble')

  File checkoutDir = file("${buildDir}/bwc/checkout-${bwcBranch}")

  final String remote = System.getProperty("tests.bwc.remote", "elastic")

  final boolean gitFetchLatest
  final String gitFetchLatestProperty = System.getProperty("tests.bwc.git_fetch_latest", "true")
  if ("true".equals(gitFetchLatestProperty)) {
    gitFetchLatest = true
  } else if ("false".equals(gitFetchLatestProperty)) {
    gitFetchLatest = false
  } else {
    throw new GradleException("tests.bwc.git_fetch_latest must be [true] or [false] but was [" + gitFetchLatestProperty + "]")
  }

  task createClone(type: LoggedExec) {
    onlyIf { checkoutDir.exists() == false }
    commandLine = ['git', 'clone', rootDir, checkoutDir]
  }

  task findRemote(type: LoggedExec) {
    dependsOn createClone
    workingDir = checkoutDir
    commandLine = ['git', 'remote', '-v']
    ByteArrayOutputStream output = new ByteArrayOutputStream()
    standardOutput = output
    doLast {
      project.ext.remoteExists = false
      output.toString('UTF-8').eachLine {
        if (it.contains("${remote}\t")) {
          project.ext.remoteExists = true
        }
      }
    }
  }

  task addRemote(type: LoggedExec) {
    dependsOn findRemote
    onlyIf { project.ext.remoteExists == false }
    workingDir = checkoutDir
    commandLine = ['git', 'remote', 'add', "${remote}", "https://github.com/${remote}/elasticsearch.git"]
  }

  task fetchLatest(type: LoggedExec) {
    onlyIf { project.gradle.startParameter.isOffline() == false && gitFetchLatest }
    dependsOn addRemote
    workingDir = checkoutDir
    commandLine = ['git', 'fetch', '--all']
  }

  String buildMetadataKey = "bwc_refspec_${project.path.substring(1)}"
  task checkoutBwcBranch(type: LoggedExec) {
    String refspec = System.getProperty("tests.bwc.refspec.${bwcBranch}", buildMetadata.get(buildMetadataKey, "${remote}/${bwcBranch}"))
    dependsOn fetchLatest
    workingDir = checkoutDir
    commandLine = ['git', 'checkout', refspec]
    doFirst {
      println "Checking out elasticsearch ${refspec} for branch ${bwcBranch}"
    }
  }

  File buildMetadataFile = project.file("build/${project.name}/build_metadata")
  task writeBuildMetadata(type: LoggedExec) {
    dependsOn checkoutBwcBranch
    workingDir = checkoutDir
    commandLine = ['git', 'rev-parse', 'HEAD']
    ignoreExitValue = true
    ByteArrayOutputStream output = new ByteArrayOutputStream()
    standardOutput = output
    doLast {
      if (execResult.exitValue != 0) {
        output.toString('UTF-8').eachLine { line -> logger.error(line) }
        execResult.assertNormalExitValue()
      }
      project.mkdir(buildMetadataFile.parent)
      String commit = output.toString('UTF-8')
      buildMetadataFile.setText("${buildMetadataKey}=${commit}", 'UTF-8')
      println "Checked out elasticsearch commit ${commit}"
    }
  }

  List<File> artifactFiles = []
  List<String> projectDirs = []
  for (String project : ['zip', 'deb', 'rpm']) {
    String baseDir = "distribution"
    if (bwcVersion.onOrAfter('6.3.0')) {
      baseDir += project == 'zip' ? '/archives' : '/packages'
      // add oss variant first
      projectDirs.add("${baseDir}/oss-${project}")
      artifactFiles.add(file("${checkoutDir}/${baseDir}/oss-${project}/build/distributions/elasticsearch-oss-${bwcVersion}.${project}"))
    }
    projectDirs.add("${baseDir}/${project}")
    artifactFiles.add(file("${checkoutDir}/${baseDir}/${project}/build/distributions/elasticsearch-${bwcVersion}.${project}"))
  }

  task buildBwcVersion(type: Exec) {
    dependsOn checkoutBwcBranch, writeBuildMetadata
    // send RUNTIME_JAVA_HOME so the build doesn't fails on newer version the branch doesn't know about
    environment('RUNTIME_JAVA_HOME', getJavaHome(it, rootProject.ext.minimumRuntimeVersion.getMajorVersion() as int))
    workingDir = checkoutDir
    // we are building branches that are officially built with JDK 8, push JAVA8_HOME to JAVA_HOME for these builds
    if (["5.6", "6.0", "6.1"].contains(bwcBranch)) {
      environment('JAVA_HOME', getJavaHome(it, 8))
    } else if ("6.2".equals(bwcBranch)) {
      environment('JAVA_HOME', getJavaHome(it, 9))
    } else if (["6.3", "6.4", "6.x"].contains(bwcBranch)) {
      environment('JAVA_HOME', getJavaHome(it, 10))
    } else {
      environment('JAVA_HOME', project.compilerJavaHome)
    }
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
      executable 'cmd'
      args '/C', 'call', new File(checkoutDir, 'gradlew').toString()
    } else {
      executable new File(checkoutDir, 'gradlew').toString()
    }
    for (String dir : projectDirs) {
      args ":${dir.replace('/', ':')}:assemble"
    }
    args "-Dbuild.snapshot=true"
    final LogLevel logLevel = gradle.startParameter.logLevel
    if ([LogLevel.QUIET, LogLevel.WARN, LogLevel.INFO, LogLevel.DEBUG].contains(logLevel)) {
      args "--${logLevel.name().toLowerCase(Locale.ENGLISH)}"
    }
    final String showStacktraceName = gradle.startParameter.showStacktrace.name()
    assert ["INTERNAL_EXCEPTIONS", "ALWAYS", "ALWAYS_FULL"].contains(showStacktraceName)
    if (showStacktraceName.equals("ALWAYS")) {
      args "--stacktrace"
    } else if (showStacktraceName.equals("ALWAYS_FULL")) {
      args "--full-stacktrace"
    }
    standardOutput = new IndentingOutputStream(System.out)
    errorOutput = new IndentingOutputStream(System.err)
    doLast {
      List missing = artifactFiles.grep { file ->
        false == file.exists()
      }
      if (false == missing.empty) {
        throw new InvalidUserDataException(
                "Building bwc version didn't generate expected files ${missing}")
      }
    }
  }

  artifacts {
    for (File artifactFile : artifactFiles) {
      String artifactName = artifactFile.name.contains('oss') ? 'elasticsearch-oss' : 'elasticsearch'
      String suffix = artifactFile.toString()[-3..-1]
      'default' file: artifactFile, name: artifactName, type: suffix, builtBy: buildBwcVersion
    }
  }
}

class IndentingOutputStream extends OutputStream {

  public static final byte[] INDENT = "  [bwc] ".getBytes(StandardCharsets.UTF_8)
  private final OutputStream delegate

  public IndentingOutputStream(OutputStream delegate) {
      this.delegate = delegate
  }

  @Override
  public void write(int b) {
    write([b] as int[], 0, 1)
  }

  public void write(int[] bytes, int offset, int length) {
    for (int i = 0; i < bytes.length; i++) {
      delegate.write(bytes[i])
      if (bytes[i] == '\n') {
        delegate.write(INDENT)
      }
    }
  }
}