/*
 * Copyright © 2018-2019 Apple Inc. and the ServiceTalk project authors
 *
 * Licensed 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 io.servicetalk.gradle.plugin.internal.Versions

if (!repositories) {
  allprojects {
    buildscript {
      repositories {
        gradlePluginPortal()
      }
    }
    repositories {
      mavenCentral()
      gradlePluginPortal()
      if ("$nettyVersion".endsWith("+")) {
        maven {
          name "Netty Snapshots"
          url "https://central.sonatype.com/repository/maven-snapshots/"

          content {
            includeGroup "io.netty"
          }
        }
      }
    }
  }
  println("This machine doesn't have any pre-configured repositories, will use: ${repositories*.name.join(", ")}")
} else {
  print("This machine already has some pre-configured repositories, will use: ${repositories*.name.join(", ")}")
}

buildscript {
  if (!repositories) {
    repositories {
      gradlePluginPortal()
    }
  }
  dependencies {
    if (JavaVersion.current().isJava11Compatible()) {
      classpath("com.autonomousapps:dependency-analysis-gradle-plugin:$dependencyAnalysisPluginVersion")
    }
  }
}

apply plugin: "io.servicetalk.servicetalk-gradle-plugin-internal-root"

// Unfortunately, we can not make this validation part of our servicetalk-gradle-plugin-internal because it requires
// JDK11 while we build and package our plugin with JDK8.
if (JavaVersion.current().isJava11Compatible()) {
  apply plugin: "com.autonomousapps.dependency-analysis"

  dependencyAnalysis {
    issues {
      all {
        onAny {
          severity("fail")
        }
        onUnusedDependencies {
          // We use it for log4j2.xml configuration
          exclude(":servicetalk-test-resources")
        }
        onUsedTransitiveDependencies {
          // We import it as api dependency via :servicetalk-annotations and don't want to repeat it explicitly
          exclude("com.google.code.findbugs:jsr305")
        }
        onIncorrectConfiguration {
          // We don't want to leak it as api dependency to our users
          exclude("com.google.code.findbugs:jsr305")
        }
        onCompileOnly {
          // False positive, these annotations use RetentionPolicy.RUNTIME
          exclude(":servicetalk-annotations")
        }
      }
    }
  }

  quality.dependsOn buildHealth
}

task validateLocalDocSite(type: Exec) {
  group 'Documentation'
  description 'Generate and validate servicetalk.io site documentation'
  workingDir 'docs/generation'
  commandLine './gradlew', 'clean', 'validateLocalSite'
}
quality.dependsOn validateLocalDocSite

subprojects {
  // mockito 5 only supports jdk11+
  if (JavaVersion.current() < JavaVersion.VERSION_11) {
    project.setProperty("mockitoCoreVersion", mockitoCorePreJdk11Version)
  } else {
    apply plugin: "com.autonomousapps.dependency-analysis"
  }
  // Used by ci-release.yaml to determine which modules need to be built/released with JDK11.
  task printJavaTargetCompatibility {
    doLast {
      if (project.parent == project.rootProject) {
        def javaLanguage = (project.tasks.withType(JavaCompile)?.findByName("compileJava")?.options?.release?.get()) ?:
            Integer.parseInt(Versions.TARGET_VERSION.getMajorVersion())
        println("version: " + javaLanguage + " name: " + project.name)
      }
    }
  }

  // Configure dependency locking: https://docs.gradle.org/current/userguide/dependency_locking.html
  dependencyLocking {
    lockMode = LockMode.STRICT
  }

  configurations {
    annotationProcessor {
      resolutionStrategy.activateDependencyLocking()
    }
    compileClasspath {
      resolutionStrategy.activateDependencyLocking()
    }
    runtimeClasspath {
      resolutionStrategy.activateDependencyLocking()
    }
    jmhCompileClasspath {
      resolutionStrategy.activateDependencyLocking()
    }
    jmhRuntimeClasspath {
      resolutionStrategy.activateDependencyLocking()
    }
  }

  tasks.register("resolveAndLockAll") {
    notCompatibleWithConfigurationCache("Filters configurations at execution time")
    doFirst {
      assert gradle.startParameter.writeDependencyLocks :
          "$path must be run from the command line with the `--write-locks` flag"
    }
    doLast {
      configurations.findAll {
        // Add any custom filtering on the configurations to be resolved
        it.canBeResolved
      }.each { it.resolve() }
    }
  }
}
