/*
 * Copyright OpenSearch Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

plugins {
    id 'de.undercouch.download' version '4.1.2' apply false
}

import com.mgd.core.gradle.S3Upload

subprojects {
    apply plugin: 'de.undercouch.download'
    apply plugin: 'distribution'

    dependencies {
        /* required to resolve below issue with aws sdk
          JAXB is unavailable. Will fallback to SDK implementation which may be less performant
         */
        implementation 'javax.xml.bind:jaxb-api:2.3.1'
    }

    ext {
        archiveToTar = this.&archiveToTar
    }

    def supportedArchitectures = architectures.get(it.name) as String[]
    def platform = it.name

    //For each subproject and its supported architecture - Add distribution and upload tasks
    supportedArchitectures.each {
        def architecture = it
        def distName = "${platform}${architecture}" //eg linuxarm64
        def distNameWithJDK = "${distName}WithJDK"
        def downloadJDKTask = "download${architecture}JDK"
        def installTaskName = "install${distName.capitalize()}Dist"

        //This adds two distributions for each supported architecture e.g. linuxarm64DistTar, linuxarm64WithJDKDistTar
        distributions {
            "${distName}" {
                distributionBaseName = "${project.rootProject.name}-${project.rootProject.version}-${platform}-${architecture}"
                contents {
                    with archiveToTar()
                    into('bin') {
                        from("data-prepper-${architecture}.sh").rename("data-prepper-${architecture}.sh", "data-prepper")
                        fileMode 0755
                    }
                }
            }
            "${distNameWithJDK}" {
                distributionBaseName = "${project.rootProject.name}-jdk-${project.rootProject.version}-${platform}-${architecture}"
                contents {
                    with archiveToTar()
                    into('openjdk') {
                        from tarTree("${buildDir}/${platform}${architecture}/openjdk/openjdk.tar.gz")
                    }
                    into('bin') {
                        from("data-prepper-jdk-${architecture}.sh").rename("data-prepper-jdk-${architecture}.sh", "data-prepper")
                        fileMode 0755
                    }
                }
            }
        }

        //by default distribution plugin adds project version to archive name, removing it
        distTar {
            project.version = ""
        }

        tasks.getByName(installTaskName) {
            dependsOn ':release:releasePrerequisites'
        }

        assemble.dependsOn(installTaskName)

        //Adds one task per supported architecture for downloading appropriate JDK e.g. downloadarm64JDK
        tasks.create("${downloadJDKTask}", Download, {
            src jdkSources.get(platform + '_' + architecture)
            dest "${buildDir}/${platform}${architecture}/openjdk/openjdk.tar.gz"
            overwrite false
        })
    }

    tasks.withType(Zip) {
        enabled false
    }

    tasks.withType(Tar) {
        dependsOn ':release:releasePrerequisites'
        compression = Compression.GZIP
        archiveExtension = 'tar.gz'
    }

    tasks.create("${platform}Tar") {
        supportedArchitectures.each {
            dependsOn "${platform}${it}DistTar"
            dependsOn "${platform}${it}WithJDKDistTar"
        }
    }

    afterEvaluate {
        supportedArchitectures.each {
            def platformWithArchitecture = "${platform}${it}"
            def tarTask = tasks.getByName("${platformWithArchitecture}DistTar")
            def tarWithJDKTask = tasks.getByName("${platformWithArchitecture}WithJDKDistTar")
            def destinationKeyPath = "${archiveRootKey}/archive"

            tasks.getByName("${platformWithArchitecture}WithJDKDistTar").dependsOn("download${it}JDK")

            tasks.create(name: "upload${platformWithArchitecture}TarToS3", type: S3Upload) {
                dependsOn tarTask.name
                file = tarTask.archiveFile.get().asFile.absolutePath
                bucket = awsS3Bucket
                key = "${destinationKeyPath}/${tarTask.archiveName}"
            }

            tasks.create(name: "upload${platformWithArchitecture}TarWithJDKToS3", type: S3Upload) {
                dependsOn tarWithJDKTask.name
                file = tarWithJDKTask.archiveFile.get().asFile.absolutePath
                bucket = awsS3Bucket
                key = "${destinationKeyPath}/${tarWithJDKTask.archiveName}"
            }
        }

        tasks.create('uploadToS3') {
            tasks.withType(S3Upload).each {
                dependsOn it.name
            }
        }
    }
}

CopySpec archiveToTar() {
    return copySpec {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        into('lib') {
            from project(':data-prepper-main').jar.archivePath
            from project(':data-prepper-main').configurations.runtimeClasspath
            fileMode 0755
        }
        into('examples') {
            from("${rootDir}/examples")
            dirMode 0750
            fileMode 0755
        }
        into('config') {
            from("${rootDir}/shared-config/log4j2-rolling.properties")
            from("${rootDir}/examples/config/example-data-prepper-config.yaml")
                    .rename("example-data-prepper-config.yaml", "data-prepper-config.yaml")
            from("${rootDir}/examples/certificates/default_certificate.pem")
            from("${rootDir}/examples/certificates/default_private_key.pem")
        }
        into('pipelines') {
            from("${rootDir}/examples/config/pipelines-readme.txt").rename("pipelines-readme.txt", "README")
        }
        into('') {
            from("${rootDir}/LICENSE")
            from("${rootDir}/NOTICE")
            from("${rootDir}/THIRD-PARTY")
            fileMode 0755
        }
    }
}

task uploadArchives {
    subprojects.each { dependsOn ':release:archives:' + it.name + ':uploadToS3' }
}

task buildTar {
    subprojects.each { dependsOn ':release:archives:' + it.name + ':' + it.name + 'Tar' }
}

task buildArchives {
    dependsOn buildTar
}