/*
 * Copyright 2010-2017 JetBrains s.r.o.
 *
 * 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 kotlin.text.Regex
import org.jetbrains.kotlin.konan.target.*
import org.jetbrains.kotlin.konan.util.*
import org.jetbrains.kotlin.CopySamples
import org.jetbrains.kotlin.CopyCommonSources
import org.jetbrains.kotlin.PlatformInfo
import org.jetbrains.kotlin.KotlinBuildPusher
import org.jetbrains.kotlin.CollisionDetector
import org.jetbrains.kotlin.CollisionTransformer
import org.jetbrains.kotlin.CompilationDatabaseKt
import org.jetbrains.kotlin.CompareDistributionSignatures
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.apache.tools.ant.filters.ReplaceTokens
import org.jetbrains.kotlin.UtilsKt
import java.util.concurrent.ConcurrentHashMap

buildscript {
    apply from: "gradle/kotlinGradlePlugin.gradle"

    repositories {
        if (UtilsKt.getCacheRedirectorEnabled(project)) {
            maven { url "https://cache-redirector.jetbrains.com/maven-central" }
            maven { url "https://cache-redirector.jetbrains.com/jcenter" }
        }
        else {
            mavenCentral()
            jcenter()
        }
        gradlePluginPortal()
    }

    dependencies {
        //classpath project(":kotlin-native-utils")
        classpath 'gradle.plugin.com.github.johnrengelman:shadow:7.1.1'
    }
}
import org.jetbrains.kotlin.konan.*

// Allows generating wrappers for the root build and all the samples during execution of the default 'wrapper' task.
// Run './gradlew wrapper --gradle-version <version>' to update all the wrappers.
//apply plugin: org.jetbrains.kotlin.GradleWrappers
//
//wrappers.projects = ['samples', 'samples/calculator', 'samples/androidNativeActivity', 'samples/cocoapods/kotlin-library']
//wrapper.distributionType = Wrapper.DistributionType.ALL

// FIXME: Remove until IDEA-231214 is fixed.
//defaultTasks 'clean', 'dist'

convention.plugins.platformInfo = PlatformInfo

if (isMac()) {
    checkXcodeVersion(project)
}

ext {
    distDir = UtilsKt.getKotlinNativeDist(project)
    dependenciesDir = DependencyProcessor.defaultDependenciesRoot
    experimentalEnabled = project.hasProperty("org.jetbrains.kotlin.native.experimentalTargets")
    platformManager = new PlatformManager(DistributionKt.buildDistribution(projectDir.absolutePath),
            ext.experimentalEnabled)

    cacheableTargetNames = platformManager.hostPlatform.cacheableTargets
    cacheableTargets = cacheableTargetNames.collect { platformManager.targetByName(it) }

    // Some targets miss zlib in their sysroots.
    // We skip these targets when generate a corresponding platform library.
    // See also: the :distDef task, targetDefFiles in the :platformLibs project.
    targetsWithoutZlib = [
            KonanTarget.LINUX_MIPS32.INSTANCE,
            KonanTarget.LINUX_MIPSEL32.INSTANCE
    ]

    kotlinCompilerModule= [path: ":kotlin-compiler", configuration: "runtimeElements"]
    kotlinStdLibModule= project(":kotlin-stdlib")
    kotlinReflectModule= project(":kotlin-reflect")
    kotlinScriptRuntimeModule= project(":kotlin-script-runtime")
    kotlinUtilKliMetadatabModule= project(":kotlin-util-klib-metadata")

    konanVersionFull = ext.kotlinNativeVersion
    gradlePluginVersion = konanVersionFull

    // A separate map for each build for automatic cleaning the daemon after the build have finished.
    toolClassLoadersMap = new ConcurrentHashMap<Object, URLClassLoader>()
}

allprojects {
    buildscript {
        repositories {
            if (UtilsKt.getCacheRedirectorEnabled(project))
                maven { url 'https://cache-redirector.jetbrains.com/jcenter' }
            else
                jcenter()
        }
    }
    if (path != ":kotlin-native:dependencies") {
        evaluationDependsOn(":kotlin-native:dependencies")
    }

    repositories {
        if (UtilsKt.getCacheRedirectorEnabled(project))
            maven { url 'https://cache-redirector.jetbrains.com/maven-central' }
        else
            mavenCentral()
        maven {
            url project.bootstrapKotlinRepo
        }
    }

    setupHostAndTarget()
    loadCommandLineProperties()
    loadLocalProperties()
    setupClang(project)
}

void setupHostAndTarget() {
    ext.hostName = platformManager.hostName
    ext.targetList = platformManager.enabled.collect { it.visibleName } as List
    ext.konanTargetList = platformManager.enabled as List
}

void setupClang(Project project) {
    project.extensions.platformManager = project.project(":kotlin-native").ext.platformManager
    project.extensions.execClang = org.jetbrains.kotlin.ExecClang.create(project)
}

void loadLocalProperties() {
    if (new File("$project.rootDir/local.properties").exists()) {
        Properties props = new Properties()
        props.load(new FileInputStream("$project.rootDir/local.properties"))
        props.each { prop -> project.ext.set(prop.key, prop.value) }
    }
}

void loadCommandLineProperties() {
    if (project.hasProperty("konanc_flags")) {
        throw new Error("Specify either -Ptest_flags or -Pbuild_flags.")
    }
    ext.globalBuildArgs = project.hasProperty("build_flags") ? ext.build_flags.split() : []
    ext.globalTestArgs = project.hasProperty("test_flags") ? ext.test_flags.split() : []
    ext.testTarget = project.hasProperty("test_target") ? ext.test_target : null
}

configurations {
    ftpAntTask
    distPack
    commonSources
}

dependencies {
    ftpAntTask 'org.apache.ant:ant-commons-net:1.9.9'
    distPack project(':kotlin-native:Interop:Runtime')
    distPack project(':kotlin-native:Interop:Indexer')
    distPack project(':kotlin-native:Interop:StubGenerator')
    distPack project(':kotlin-native:Interop:Skia')
    distPack project(':kotlin-native:backend.native')
    distPack project(':kotlin-native:utilities:cli-runner')
    distPack project(':kotlin-native:utilities:basic-utils')
    distPack project(':kotlin-native:klib')
    distPack project(path: ':kotlin-native:endorsedLibraries:kotlinx.cli', configuration: "jvmRuntimeElements")
    //distPack "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
    commonSources project(path: ':kotlin-stdlib-common', configuration: 'sources')
    commonSources project(path: ':kotlin-test:kotlin-test-common', configuration: 'sources')
    commonSources project(path: ':kotlin-test:kotlin-test-annotations-common', configuration: 'sources')
}

//task sharedJar {
//    dependsOn gradle.includedBuild('shared').task(':jar')
//}

//task gradlePluginJar {
//    dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':shadowJar')
//}

//task gradlePluginCheck {
//    dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':check')
//}

task dist_compiler(dependsOn: "distCompiler")
task dist_runtime(dependsOn: "distRuntime")
task cross_dist(dependsOn: "crossDist")
task list_dist(dependsOn: "listDist")
task build {
    dependsOn ':dist', ':distPlatformLibs'
}

task distCommonSources(type: CopyCommonSources) {
    outputDir "$distDir/sources"
    sourcePaths configurations.commonSources
    zipSources true
}

task distNativeSources(type: Zip) {
    destinationDirectory = file("$distDir/sources")
    archiveFileName = "kotlin-stdlib-native-sources.zip"

    includeEmptyDirs = false
    include('**/*.kt')

    from(project(':kotlin-native:runtime').file('src/main/kotlin'))
    from(project(":kotlin-stdlib-common").file('../native-wasm/src/'))
    from(project(':kotlin-native:Interop:Runtime').file('src/main/kotlin'))
    from(project(':kotlin-native:Interop:Runtime').file('src/native/kotlin'))
    from(project(':kotlin-native:Interop:JsRuntime').file('src/main/kotlin')) {
        into('kotlinx/wasm/jsinterop')
    }
}

task distEndorsedSources {
    dependsOn(':kotlin-native:endorsedLibraries:endorsedLibsSources')
}

task distSources {
    dependsOn(distCommonSources)
    dependsOn(distNativeSources)
    dependsOn(distEndorsedSources)
}

task shadowJar(type: ShadowJar) {
    mergeServiceFiles()
    destinationDirectory.set(file("$distDir/konan/lib"))
    archiveBaseName.set("kotlin-native")
    // Exclude trove4j because of license agreement.
    exclude "*trove4j*"
    exclude("META-INF/versions/9/module-info.class")
    configurations = [project.configurations.distPack]
    archiveClassifier.set(null)
    outputs.upToDateWhen {
        archiveFile.getOrNull()?.asFile.exists() ?: false
    }
}

task distCompiler(type: Copy) {
    dependsOn ":kotlin-native:dependencies:update"
    dependsOn ':kotlin-native:shadowJar'
    dependsOn ":kotlin-native-compiler-embeddable:kotlin-native-compiler-embeddable"

    destinationDir distDir

    from(project(':kotlin-native:backend.native').file("build/nativelibs/$hostName")) {
        into('konan/nativelib')
    }

    from(project(':kotlin-native:backend.native').file('build/external_jars/trove4j.jar')) {
        into('konan/lib')
    }

    from(project(":kotlin-native-compiler-embeddable").file("build/libs")) {
        into("konan/lib")
    }

    from(project(':kotlin-native:Interop').file('Indexer/build/nativelibs')) {
        into('konan/nativelib')
    }

    from(project(':kotlin-native:Interop').file('Runtime/build/nativelibs')) {
        into('konan/nativelib')
    }

    from(project(':kotlin-native:llvmCoverageMappingC').file('build/libs/coverageMapping/shared')) {
        into('konan/nativelib')
    }

    from(project(':kotlin-native:llvmDebugInfoC').file('build/libs/debugInfo/shared')) {
        into('konan/nativelib')
    }

    from(project(':kotlin-native:llvmDebugInfoC').file('src/scripts/konan_lldb.py')) {
        into('tools')
    }

    from(project(':kotlin-native:utilities').file('env_blacklist')) {
        into('tools')
    }

    from(file('cmd')) {
        fileMode(0755)
        into('bin')
        if (!PlatformInfo.isWindows()) {
            exclude('**/*.bat')
        }
    }

    from(project.file('konan')) {
        into('konan')
        exclude('**/*.properties')
    }

    from(project.file('konan')) {
        into('konan')
        include('**/*.properties')
        filter(ReplaceTokens, tokens: [compilerVersion: konanVersionFull.toString()])
        // Set LLVM variant that will be used by default in the distribution.
        // `user` - smaller, includes only necessary components.
        // `dev` - bigger, includes (almost) every possible component. Use this one,
        //          if your feature requires component that is not a part of user distribution (yet).
        // Note: by default konan.properties use `dev` variant because it is needed for building our LLVM dynamic library.
        String llvmVariant = 'user'
        filter(ReplaceTokens,
                beginToken: '$',
                endToken: '',
                tokens: [("llvm.${hostName}.dev".toString()): "\$llvm.${hostName}.${llvmVariant}".toString()]
        )
    }
    if (experimentalEnabled) {
        file('konan/experimentalTargetsEnabled').text = ""
    } else {
        delete('konan/experimentalTargetsEnabled')
    }
}

task distDef(type: Copy) {
    destinationDir project.file("$distDir/konan/platformDef/")

    platformManager.targetValues.each { target ->
        from(project(":kotlin-native:platformLibs").file("src/platform/${target.family.name().toLowerCase()}")) {
            into target.visibleName
            include '**/*.def'
            if (target in targetsWithoutZlib) {
                exclude '**/zlib.def'
            }
        }
    }
}

task listDist(type: Exec) {
    commandLine 'find', distDir
}

task distRuntime(type: Copy) {
    dependsOn "${hostName}CrossDistRuntime"
}

task distEndorsedLibraries {
    dependsOn "${hostName}CrossDistEndorsedLibraries"
}

task distStdlibCache {
    if (hostName in cacheableTargetNames) {
        dependsOn("${hostName}StdlibCache")
    }
}

task distEndorsedCache {
    if (hostName in cacheableTargetNames) {
        dependsOn("${hostName}EndorsedCache")
    }
}

def stdlib = 'klib/common/stdlib'
def stdlibDefaultComponent = "$stdlib/default"
def endorsedLibs = 'klib/common/endorsedLibraries'
def endorsedLibsBase = 'klib/common'

task crossDistRuntime {
    dependsOn.addAll(targetList.collect { "${it}CrossDistRuntime" })
}

task crossDistEndorsedLibraries {
    dependsOn.addAll(targetList.collect { "${it}CrossDistEndorsedLibraries" })
}

task crossDistPlatformLibs {
    dependsOn.addAll(targetList.collect { "${it}PlatformLibs" })
}

task crossDistStdlib {
    dependsOn.addAll(targetList.collect { "${it}CrossDistStdlib" })
}

task crossDistStdlibCache {
    dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}StdlibCache" })
}

task crossDistEndorsedCache {
    dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}EndorsedCache" })
}

def endorsedLibsCopyTask = task("crossDistEndorsedLibrariesCopy", type: Copy) {
    destinationDir project.file("$distDir/$endorsedLibsBase")

    from(project(':kotlin-native:endorsedLibraries').file("build")) {
        include('**')
        exclude('cache')
    }
}

targetList.each { target ->
    task("${target}CrossDistStdlib", type: Copy) {
        dependsOn ":kotlin-native:runtime:${target}Stdlib"

        destinationDir project.file("$distDir/$stdlib")

        from(project(':kotlin-native:runtime').file("build/${target}Stdlib")) {
            include('**')
            eachFile {
                if (name == 'manifest') {
                    def existingManifest = file("$destinationDir/$path")
                    if (existingManifest.exists()) {
                        UtilsKt.mergeManifestsByTargets(project, file, existingManifest)
                        exclude()
                    }
                }
            }
        }

        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }

    task("${target}CrossDistBitcodeCopy", type: Copy) {
        dependsOn ":kotlin-native:runtime:${target}Runtime"

        destinationDir project.file("$distDir/konan/targets/")

        from(project(':kotlin-native:runtime').file("build/bitcode/main/$target")) {
            include("*.bc")
            exclude("runtime.bc")
            into("$target/native")
        }
    }

    task("${target}CrossDistRuntime", type: Copy) {
        dependsOn ":kotlin-native:runtime:${target}Runtime"
        dependsOn ":kotlin-native:${target}CrossDistStdlib"
        dependsOn "${target}CrossDistBitcodeCopy"

        destinationDir project.file("$distDir/$stdlibDefaultComponent")

        if (target == 'wasm32') {
            into("targets/wasm32/included") {
                from(project(':kotlin-native:runtime').file('src/main/js'))
                from(project(':kotlin-native:runtime').file('src/launcher/js'))
                from(project(':kotlin-native:Interop:JsRuntime').file('src/main/js'))
            }
        }
    }

    task("${target}PlatformLibs") {
        dependsOn ":kotlin-native:platformLibs:${target}Install"
        if (target in cacheableTargetNames) {
            dependsOn(":kotlin-native:platformLibs:${target}Cache")
        }
    }

    if (target in cacheableTargetNames) {
        task ("${target}StdlibCache", type: Copy) {
            dependsOn "${target}CrossDistStdlib"
            dependsOn ":kotlin-native:runtime:${target}StdlibCache"

            destinationDir project.file("$distDir/klib/cache/")

            from("${project(":kotlin-native:runtime").buildDir}/cache/$target") {
                include('**')
            }
        }

        task ("${target}EndorsedCache", type: Copy) {
            dependsOn "${target}CrossDistStdlib"
            dependsOn ":kotlin-native:endorsedLibraries:${target}Cache"

            destinationDir project.file("$distDir/klib/cache")

            from("${project(':kotlin-native:endorsedLibraries').buildDir}/cache/$target") {
                include('**')
            }
        }
    }

    task("${target}CrossDist") {
        dependsOn "${target}CrossDistRuntime", "distCompiler"
        dependsOn "${target}CrossDistEndorsedLibraries"
        if (target in cacheableTargetNames) {
            dependsOn "${target}StdlibCache", "${target}EndorsedCache"
        }
    }

    task("${target}CrossDistEndorsedLibraries") {
        def endorsedLibsBuildTask = ":kotlin-native:endorsedLibraries:${target}EndorsedLibraries"
        dependsOn endorsedLibsBuildTask
        dependsOn endorsedLibsCopyTask
        // There is only one copy task for endorsed libs, because they are already copied into a single dir,
        // while having target-tasks will make Gradle issue warnings on incorrect inputs and outputs usage.
        // So this copy task should run after the all build tasks.
        endorsedLibsCopyTask.mustRunAfter(endorsedLibsBuildTask)
    }
}

task distPlatformLibs {
    dependsOn ':kotlin-native:platformLibs:hostInstall'
    dependsOn ':kotlin-native:platformLibs:hostCache'
}

task dist {
    dependsOn "distCompiler",
            "distRuntime",
            "distEndorsedLibraries",
            "distDef",
            "distStdlibCache",
            "distEndorsedCache"
}

task crossDist {
    dependsOn "distCompiler",
            "crossDistRuntime",
            "crossDistEndorsedLibraries",
            "distDef",
            "crossDistStdlib",
            "crossDistStdlibCache",
            "crossDistEndorsedCache"
}

task bundle {
    dependsOn 'bundleRegular', 'bundlePrebuilt'
}

task bundleRegular(type: (isWindows()) ? Zip : Tar) {
    def simpleOsName = HostManager.platformName()
    archiveBaseName.set("kotlin-native-$simpleOsName-$konanVersionFull")
    from(UtilsKt.getKotlinNativeDist(project)) {
        include '**'
        exclude 'dependencies'
        exclude 'klib/testLibrary'
        // Don't include platform libraries into the bundle (generate them at the user side instead).
        exclude 'klib/platform'
        // Exclude platform libraries caches too. Keep caches for stdlib and endorsed libs.
        exclude 'klib/cache/*/org.jetbrains.kotlin.native.platform.*/**'
        into archiveBaseName
    }
}

task bundlePrebuilt(type: (isWindows()) ? Zip : Tar) {
    dependsOn("crossDistPlatformLibs")
    def simpleOsName = HostManager.platformName()
    archiveBaseName.set("kotlin-native-prebuilt-$simpleOsName-$konanVersionFull")
    from(UtilsKt.getKotlinNativeDist(project)) {
        include '**'
        exclude 'dependencies'
        exclude 'klib/testLibrary'
        into archiveBaseName
    }
}

void configurePackingLicensesToBundle(AbstractArchiveTask task, boolean containsPlatformLibraries) {
    task.from(project.projectDir) {
        include 'licenses/**'
        if (!containsPlatformLibraries || !isMac()) {
            exclude '**/xcode_license.pdf'
        }
        into task.archiveBaseName
    }

    task.from(project.rootProject.file("license")) {
        into "${task.archiveBaseName.get()}/licenses"
    }
}

configurePackingLicensesToBundle(bundleRegular, /* containsPlatformLibraries = */ false)
configurePackingLicensesToBundle(bundlePrebuilt, /* containsPlatformLibraries = */ true)

configure([bundleRegular, bundlePrebuilt]) {
    dependsOn("crossDist")
    dependsOn("crossDistStdlibCache")
    dependsOn("crossDistEndorsedCache")
    dependsOn("distSources")
    dependsOn("distDef")
    from(project.projectDir) {
        include 'RELEASE_NOTES.md'
        into baseName
    }

    destinationDirectory.set(file('.'))

    if (isWindows()) {
        zip64 true
    } else {
        archiveExtension.set('tar.gz')
        compression = Compression.GZIP
    }
}

task 'tc-dist'(type: (isWindows()) ? Zip : Tar) {
    dependsOn('dist')
    dependsOn('distSources')
    def simpleOsName = HostManager.platformName()
    archiveBaseName.set("kotlin-native-dist-$simpleOsName-$konanVersionFull")
    from(UtilsKt.getKotlinNativeDist(project)) {
        include '**'
        exclude 'dependencies'
        into archiveBaseName
    }

    destinationDirectory.set(file('.'))

    if (isWindows()) {
        zip64 true
    } else {
        archiveExtension.set('tar.gz')
        compression = Compression.GZIP
    }
}

task samples {
    dependsOn 'samplesZip', 'samplesTar'
}

task samplesZip(type: Zip)
task samplesTar(type: Tar) {
    extension = 'tar.gz'
    compression = Compression.GZIP
}

configure([samplesZip, samplesTar]) {
    baseName "kotlin-native-samples-$konanVersionFull"
    destinationDir = projectDir
    into(baseName)

    from(file('samples')) {
        // Process properties files separately.
        exclude '**/gradle.properties'
    }

    from(project.projectDir) {
        include 'licenses/**'
    }

    from(file('samples')) {
        include '**/gradle.properties'
        filter {
            it.startsWith('org.jetbrains.kotlin.native.home=') || it.startsWith('# Use custom Kotlin/Native home:') ? null : it
        }
    }

    // Exclude build artifacts.
    exclude '**/build'
    exclude '**/.gradle'
    exclude '**/.idea'
    exclude '**/*.kt.bc-build/'
}

project.tasks.register("copy_samples") {
    dependsOn 'copySamples'
}
project.tasks.register("copySamples", CopySamples) {
    destinationDir file('build/samples-under-test')
}

task uploadBundle {
    dependsOn ':kotlin-native:bundle'
    if (isMac()) {
        dependsOn ':kotlin-native:bundleRestricted'
    }
    doLast {
        def kind = (konanVersionFull.meta == MetaVersion.DEV) ? "dev" : "releases"
        def ftpSettings = [
                server: project.findProperty("cdnUrl") ?: System.getenv("CDN_URL"),
                userid: project.findProperty("cdnUser") ?: System.getenv("CDN_USER"),
                password: project.findProperty("cdnPass") ?: System.getenv("CDN_PASS"),
                remoteDir: "/builds/$kind/$konanVersion/${HostManager.platformName()}"
        ]
        ant {
            taskdef(name: 'ftp',
                    classname: 'org.apache.tools.ant.taskdefs.optional.net.FTP',
                    classpath: configurations.ftpAntTask.asPath)
            ftp([action: "mkdir"] + ftpSettings)
            ftp(ftpSettings) {
                fileset(file: bundle.archivePath)
            }
            if (isMac()) {
                ftp(ftpSettings) {
                    fileset(file: bundleRestricted.archivePath)
                }
            }
        }
    }
}

task teamcityCompilerVersion {
    doLast {
        println("##teamcity[setParameter name='kotlin.native.version.base' value='$konanVersion']")
        println("##teamcity[setParameter name='kotlin.native.version.full' value='$konanVersionFull']")
        println("##teamcity[setParameter name='kotlin.native.version.meta' value='${konanVersionFull.meta.toString().toLowerCase()}']")
        println("##teamcity[buildNumber '${konanVersionFull.toString(true, true)}']")
    }
}

task clean(type: Delete) {
    dependsOn subprojects.collect { it.tasks.matching { it.name == "clean" } }
    doFirst {
        delete distDir
        delete buildDir
        delete bundle.outputs.files
        delete "${projectDir}/compile_commands.json"
    }
}

task pusher(type: KotlinBuildPusher){
    kotlinVersion = project.kotlinVersion
    konanVersion = project.ext.kotlinNativeVersion
    buildServer = "buildserver.labs.intellij.net"
    compilerConfigurationId = System.getenv("TEAMCITY_COMPILER_ID") ?: "Kotlin_KotlinDev_Compiler"
    overrideConfigurationId = System.getenv("TEAMCITY_OVERRIDE_NATIVE_ID") ?: "Kotlin_KotlinDev_DeployMavenArtifacts_OverrideNative"
    token = project.findProperty("teamcityBearToken") ?: System.getenv("TEAMCITY_BEAR_TOKEN")
}

targetList.each { target ->
    CompilationDatabaseKt.mergeCompilationDatabases(project, "${target}CompilationDatabase".toString(), [
            ":kotlin-native::common:${target}CompilationDatabase".toString(),
            ":kotlin-native:runtime:${target}CompilationDatabase".toString()
    ]).configure {
        outputFile = file("$buildDir/${target}/compile_commands.json")
    }
}

task compdb(type: Copy) {
    dependsOn "${hostName}CompilationDatabase"
    from "$buildDir/${hostName}/compile_commands.json"
    into "$projectDir"
}

targetList.each { targetName ->
    task "${targetName}CheckPlatformAbiCompatibility"(type: CompareDistributionSignatures) {
        dependsOn "${targetName}PlatformLibs"

        libraries = new CompareDistributionSignatures.Libraries.Platform(targetName)
        if (project.hasProperty("anotherDistro")) {
            oldDistribution = project.findProperty("anotherDistro")
        }
        onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
    }
}

task "checkStdlibAbiCompatibility"(type: CompareDistributionSignatures) {
    dependsOn "distRuntime"

    libraries = CompareDistributionSignatures.Libraries.Standard.INSTANCE
    if (project.hasProperty("anotherDistro")) {
        oldDistribution = project.findProperty("anotherDistro")
    }
    onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
}