/*
 * 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 com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

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

    repositories {
        maven { url kotlinCompilerRepo }
        maven { url "https://kotlin.bintray.com/kotlinx" }
        maven { url "https://cache-redirector.jetbrains.com/maven-central" }
        jcenter()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-native-utils:$kotlinVersion"
        classpath "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
        classpath "org.jetbrains.kotlin:kotlin-native-build-tools:$konanVersion"
        classpath 'com.github.jengelman.gradle.plugins:shadow:5.1.0'
    }
}
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

defaultTasks 'clean', 'dist'

convention.plugins.platformInfo = PlatformInfo

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

    kotlinCompilerModule="org.jetbrains.kotlin:kotlin-compiler:${kotlinVersion}"
    kotlinStdLibModule="org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
    kotlinCommonStdlibModule="org.jetbrains.kotlin:kotlin-stdlib-common:${kotlinStdlibVersion}:sources"
    kotlinTestCommonModule="org.jetbrains.kotlin:kotlin-test-common:${kotlinStdlibVersion}:sources"
    kotlinTestAnnotationsCommonModule="org.jetbrains.kotlin:kotlin-test-annotations-common:${kotlinStdlibVersion}:sources"
    kotlinReflectModule="org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}"
    kotlinScriptRuntimeModule="org.jetbrains.kotlin:kotlin-script-runtime:${kotlinVersion}"
    kotlinNativeUtilsModule="org.jetbrains.kotlin:kotlin-native-utils:${kotlinVersion}"
    kotlinUtilKliMetadatabModule="org.jetbrains.kotlin:kotlin-util-klib-metadata:${kotlinVersion}"

    konanVersionFull = KonanVersionGeneratedKt.getCurrentKonanVersion()
    gradlePluginVersion = konanVersionFull
}

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

    repositories {
        maven {
            url 'https://cache-redirector.jetbrains.com/maven-central'
        }
        maven {
            url kotlinStdlibRepo
        }
        maven {
            url kotlinCompilerRepo
        }
    }

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

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

void setupClang(Project project) {

    project.convention.plugins.platformManager = project.rootProject.ext.platformManager
    project.convention.plugins.execClang = new org.jetbrains.kotlin.ExecClang(project)

    project.plugins.withType(NativeComponentPlugin) {
        project.model {
            if (isWindows()) {
                platforms {
                    host {
                        architecture 'x86_64'
                    }
                }

                components {
                    withType(NativeComponentSpec) {
                        targetPlatform 'host'
                    }
                }

                toolChains {
                    gcc(Gcc) {
                        path "$llvmDir/bin"
                    }
                }
            } else {

                toolChains {
                    clang(Clang) {
                        hostPlatform.clang.clangPaths.each {
                            path it
                        }

                        eachPlatform { // TODO: will not work when cross-compiling
                            [cCompiler, cppCompiler, linker].each {
                                it.withArguments { it.addAll(project.hostPlatform.clang.clangArgs) }
                            }

                        }
                    }
                }
            }
        }
    }
}

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
    kotlinCommonSources
    distPack
}

dependencies {
    ftpAntTask 'org.apache.ant:ant-commons-net:1.9.9'
    [kotlinCommonStdlibModule, kotlinTestCommonModule, kotlinTestAnnotationsCommonModule].each {
        kotlinCommonSources(it) { transitive = false }
    }
    distPack project(':Interop:Runtime')
    distPack project(':Interop:Indexer')
    distPack project(':Interop:StubGenerator')
    distPack project(':backend.native')
    distPack project(':utilities')
    distPack project(':klib')
    distPack project(path: ':endorsedLibraries:kotlinx.cli', configuration: "jvmRuntimeElements")
    distPack "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
    distPack "org.jetbrains.kotlin:konan.metadata:$konanVersion"
    distPack  "org.jetbrains.kotlin:konan.serializer:$konanVersion"
}

task sharedJar {
    dependsOn gradle.includedBuild('kotlin-native-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.kotlinCommonSources.files
    zipSources true
}

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

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

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

task distEndorsedSources {
    dependsOn(':endorsedLibraries:endorsedLibsSources')
}

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

task detectJarCollision(type: CollisionDetector) {
    ignoredFiles.addAll(["META-INF/MANIFEST.MF", "META-INF/services/**"])
    configurations = [project.configurations.distPack]
    resolvingRules["META-INF/kotlin-util-klib.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/kotlin-util-io.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/descriptors.jvm.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/descriptors.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/descriptors.runtime.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/deserialization.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/metadata.jvm.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/metadata.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/type-system.kotlin_module"] = "kotlin-compiler"
    resolvingRules["META-INF/util.runtime.kotlin_module"] = "kotlin-compiler"
    resolvingRules["kotlin/annotation/annotation.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/collections/collections.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/coroutines/coroutines.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/internal/internal.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/kotlin.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/ranges/ranges.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["kotlin/reflect/reflect.kotlin_builtins"] = "kotlin-compiler"
    resolvingRules["META-INF/maven/com.google.protobuf/protobuf-java/pom.properties"] = "kotlin-compiler"
    resolvingRules["META-INF/maven/com.google.protobuf/protobuf-java/pom.xml"] = "kotlin-compiler"
    librariesWithIgnoredClassCollisions.addAll(["kotlin-util-klib", "kotlin-util-io"])
    if (project.hasProperty('kotlinProjectPath')) {
        resolvingRulesWithRegexes[new Regex("META-INF/.+\\.kotlin_module")] = "kotlin-compiler"
        resolvingRules["META-INF/extensions/compiler.xml"] = "kotlin-compiler"
        resolvingRules["kotlinManifest.properties"] = "kotlin-compiler"
        librariesWithIgnoredClassCollisions.addAll(["util", "container", "resolution", "serialization", "psi", "frontend",
                                                    "frontend.common", "frontend.java", "cli-common", "ir.tree",
                                                    "ir.psi2ir", "ir.backend.common", "backend.jvm", "backend.js",
                                                    "backend.wasm", "ir.serialization.common", "ir.serialization.js",
                                                    "backend-common", "backend", "plugin-api", "light-classes", "cli",
                                                    "cli-js", "incremental-compilation-impl", "js.ast", "js.serializer",
                                                    "js.parser", "js.frontend", "js.translator", "js.dce", "metadata",
                                                    "metadata.jvm", "descriptors", "descriptors.jvm", "descriptors.runtime",
                                                    "deserialization", "util.runtime", "type-system", "cones", "resolve",
                                                    "tree", "psi2fir", "fir2ir", "java", "kotlin-build-common"])
    }
}

task shadowJar(type: ShadowJar) {
    dependsOn ':detectJarCollision'
    mergeServiceFiles()
    destinationDirectory.set(file("$distDir/konan/lib"))
    archiveBaseName.set("kotlin-native")
    configurations = [project.configurations.distPack]
    archiveClassifier.set(null)
    transform(CollisionTransformer.class) {
        resolvedConflicts = detectJarCollision.resolvedConflicts
    }
}

task distCompiler(type: Copy) {
    dependsOn ':shadowJar'

    destinationDir distDir

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

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

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

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

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

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

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

    from(file('cmd')) {
        fileMode(0755)
        into('bin')
        if (!PlatformInfo.isWindows()) {
            exclude('**/*.bat')
        }
    }
    from(project.file('konan')) {
        into('konan')
    }
    if (experimentalEnabled) {
        file('konan/experimentalTargetsEnabled').text = ""
    } else {
        delete('konan/experimentalTargetsEnabled')
    }
}

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

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

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

def stdlib = 'klib/common/stdlib'
def endorsedLibs = 'klib/common/endorsedLibraries'
def endorsedLibsBase = 'klib/common'

task commonDistRuntime(type: Copy) {
    destinationDir distDir

    // Target independant common part.
    from(project(':runtime').file("build/${hostName}Stdlib")) {
        include('**')
        into(stdlib)
    }
}

task crossDistRuntime(type: Copy) {
    dependsOn.addAll(targetList.collect { "${it}CrossDistRuntime" })
    dependsOn('commonDistRuntime')
}

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

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

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

        destinationDir distDir

        from(project(':runtime').file("build/$target")) {
            include("runtime.bc")
            into("$stdlib/targets/$target/native")
        }
        from(project(':runtime').file("build/$target")) {
            include("*.bc")
            exclude("runtime.bc")
            into("konan/targets/$target/native")
        }
        from(project(':runtime').file("build/${target}Stdlib")) {
            include('**')
            into(stdlib)
        }
        if (target == 'wasm32') {
            into("$stdlib/targets/wasm32/included") {
                from(project(':runtime').file('src/main/js'))
                from(project(':runtime').file('src/launcher/js'))
                from(project(':Interop:JsRuntime').file('src/main/js'))
            }
        }
    }

    task("${target}PlatformLibs") {
        dependsOn ":platformLibs:${target}Install"
    }

    task("${target}CrossDist") {
        dependsOn "${target}CrossDistRuntime", 'distCompiler', 'commonDistRuntime', "${target}CrossDistEndorsedLibraries"
    }

    task("${target}CrossDistEndorsedLibraries", type: Copy) {
        dependsOn ":endorsedLibraries:${target}EndorsedLibraries"

        destinationDir distDir
        from(project(':endorsedLibraries').file("build")) {
            include('**')
            into("$endorsedLibsBase")
        }
    }
}

task distPlatformLibs {
    dependsOn ':platformLibs:hostInstall'
}

task dist {
    dependsOn 'distCompiler', 'distRuntime', 'distEndorsedLibraries'
}

task crossDist {
    dependsOn 'crossDistRuntime', 'distCompiler', 'crossDistEndorsedLibraries'
}

task bundle(type: (isWindows()) ? Zip : Tar) {
    if (isMac()) {
      dependsOn('bundleRestricted')
    }
    def simpleOsName = HostManager.simpleOsName()
    baseName = "kotlin-native-$simpleOsName-$konanVersionFull"
    from("$project.rootDir/dist") {
        include '**'
        exclude 'dependencies'
        exclude 'klib/testLibrary'
        into baseName
    }
    if (isWindows()) {
        zip64 true
    } else {
        extension = 'tar.gz'
        compression = Compression.GZIP
    }
}

task bundleRestricted(type: Tar) {
    def simpleOsName = HostManager.simpleOsName()
    baseName = "kotlin-native-restricted-$simpleOsName-$konanVersionFull"
    from("$project.rootDir/dist") {
        include '**'
        exclude 'dependencies'
        exclude 'klib/testLibrary'
        exclude 'klib/platform/macos_x64'
        exclude 'klib/platform/ios_x64'
        exclude 'klib/platform/ios_arm64'
        exclude 'klib/platform/ios_arm32'
        into baseName
    }

    extension = 'tar.gz'
    compression = Compression.GZIP
}

configure([bundle, bundleRestricted]) {
    dependsOn('crossDistPlatformLibs')
    dependsOn('crossDist')
    dependsOn('distSources')
    from(project.rootDir) {
        include 'DISTRO_README.md'
        rename {
            return "README.md"
        }
        into baseName
    }
    from(project.rootDir) {
        include 'RELEASE_NOTES.md'
        into baseName
    }
    from(project.rootDir) {
        include 'licenses/**'
        into baseName
    }

    destinationDir = file('.')
}

task 'tc-dist'(type: (isWindows()) ? Zip : Tar) {
    dependsOn('distPlatformLibs')
    dependsOn('dist')
    dependsOn('distSources')
    def simpleOsName = HostManager.simpleOsName()
    baseName = "kotlin-native-dist-$simpleOsName-$konanVersionFull"
    from("$project.rootDir/dist") {
        include '**'
        exclude 'dependencies'
        into baseName
    }

    destinationDir = file('.')

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

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

task performance {
    dependsOn 'dist'
    dependsOn ':performance:clean'
    dependsOn ':performance:konanRun'
}

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.rootDir) {
        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/'
}

task copy_samples(dependsOn: 'copySamples')
task copySamples(type: CopySamples) {
    destinationDir file('build/samples-under-test')
}

task uploadBundle {
    dependsOn ':bundle'
    if (isMac()) {
        dependsOn ':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.simpleOsName()}"
        ]
        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 teamcityKonanVersion {
    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 {
    dependsOn subprojects.collect { it.tasks.matching { it.name == "clean" } }
    doLast {
        delete distDir
        delete bundle.outputs.files
    }
}

task pusher(type:  KotlinBuildPusher){
    kotlinVersion = project.kotlinVersion
    konanVersion = KonanVersionGeneratedKt.getCurrentKonanVersion()
    buildServer = "teamcity.jetbrains.com"
    token = project.findProperty("teamcityBearToken") ?: System.getenv("TEAMCITY_BEAR_TOKEN")
}