import org.apache.tools.ant.taskdefs.condition.Os

import java.time.LocalDateTime

task jpackageSanityChecks {
    description 'Interactive sanity checks on the version of the code that will be packaged'

    doLast {
        // Enforce JDK 15 for packaging. This will ensure:
        // - Java 15 is used to compile the jars
        // - jpackager from JDK 15 is used to package the binaries
        // - JRE 15 is bundled in the released binaries
        // TODO Use jpackage flag "--runtime-image jdk-11" to include another version of JRE in generated binaries
        //  (But buggy in jpackager v15? Flag didn't work in last v15 test)
        assert JavaVersion.current() == JavaVersion.VERSION_15: "JDK 15 is required when packaging"

        executeCmd("git --no-pager log -5 --oneline")
        ant.input(message: "Above you see the current HEAD and its recent history.\n" +
                "Is this the right commit for packaging? (y=continue, n=abort)",
                addproperty: "sanity-check-1",
                validargs: "y,n")
        if (ant.properties['sanity-check-1'] == 'n') {
            ant.fail('Aborting')
        }

        executeCmd("git status --short --branch")
        ant.input(message: "Above you see any local changes that are not in the remote branch.\n" +
                "If you have any local changes, please abort, get them merged, get the latest branch and try again.\n" +
                "Continue with packaging? (y=continue, n=abort)",
                addproperty: "sanity-check-2",
                validargs: "y,n")
        if (ant.properties['sanity-check-2'] == 'n') {
            ant.fail('Aborting')
        }
    }
}

task createNewTempFolder {
    description 'Create new temp folder where the packaging files will be placed'
    dependsOn 'jpackageSanityChecks'

    doLast {
        // The build directory will be deleted next time the clean task runs
        // Therefore, we can use it to store any temp files (separate JDK for jpackage, etc) and resulting build artefacts
        // We create a temp folder in the build directory which holds all jpackage-related artefacts (not just the final installers)
        String tempRootDirName = 'temp-' + LocalDateTime.now().format('yyyy.MM.dd-HHmmssSSS')
        File tempRootDir = new File(project.buildDir, tempRootDirName)
        tempRootDir.mkdirs()
        ext.tempRootDir = tempRootDir
        println "Created temp root folder " + tempRootDir

        File binariesFolderPath = new File(tempRootDir, "binaries")
        binariesFolderPath.mkdirs()
        ext.binariesFolderPath = binariesFolderPath
    }
}

task packageInstallers {
    description 'Call jpackage to prepare platform-specific binaries for this platform'
    dependsOn 'createNewTempFolder'
    dependsOn rootProject.clean
    dependsOn ':desktop:build' // Full build needed for "desktop/build/app/lib", used for raspi package

    doLast {
        String jPackageFilePath = "jpackage" // Binary is in the PATH because we're running JDK v15
        File binariesFolderPath = file(createNewTempFolder.property('binariesFolderPath'))

        File tempRootDir = createNewTempFolder.property("tempRootDir") as File
        // The jpackageTempDir stores temp files used by jpackage for building the installers
        // It can be inspected in order to troubleshoot the packaging process
        File jpackageTempDir = new File(tempRootDir, "jpackage-temp")
        jpackageTempDir.mkdirs()

        // ALL contents of this folder will be included in the resulting installers
        // However, the fat jar is the only one we need
        // Therefore, this location should point to a folder that ONLY contains the fat jar
        // If later we will need to include other non-jar resources, we can do that by adding --resource-dir to the jpackage opts
        String fatJarFolderPath = "${project(':desktop').buildDir}/libs/fatJar"
        String mainJarName = shadowJar.getArchiveFileName().get()

        delete(fatJarFolderPath)
        mkdir(fatJarFolderPath)
        copy {
            from "${project(':desktop').buildDir}/libs/${mainJarName}"
            into fatJarFolderPath
        }

        // We convert the fat jar into a deterministic one by stripping out comments with date, etc.
        // jar file created from https://github.com/ManfredKarrer/tools
        executeCmd("java -jar \"${project(':desktop').projectDir}/package/tools-1.0.jar\" ${fatJarFolderPath}/${mainJarName}")

        // TODO For non-modular applications: use jlink to create a custom runtime containing only the modules required

        // See jpackager argument documentation:
        // https://docs.oracle.com/en/java/javase/15/docs/specs/man/jpackage.html

        // Remove the -SNAPSHOT suffix from the version string (originally defined in build.gradle)
        // Having it in would have resulted in an invalid version property for several platforms (mac, linux/rpm)
        String appVersion = version.replaceAll("-SNAPSHOT", "")
        println "Packaging Bisq version ${appVersion}"

        // zip jar lib for Raspberry Pi only on macOS as it is only needed once for the release
        if (Os.isFamily(Os.FAMILY_MAC)) {
            println "Zipping jar lib for raspberry pi"
            ant.zip(basedir: "${project(':desktop').buildDir}/app/lib",
                    destfile: "${binariesFolderPath}/jar-lib-for-raspberry-pi-${appVersion}.zip")
        }

        String appDescription = 'A decentralized bitcoin exchange network.'
        String appCopyright = 'Copyright © 2013-2022 - The Bisq developers'
        String appNameAndVendor = 'Bisq'

        String commonOpts = new String(
                // Generic options
                " --dest \"${binariesFolderPath}\"" +
                        " --name ${appNameAndVendor}" +
                        " --description \"${appDescription}\"" +
                        " --app-version ${appVersion}" +
                        " --copyright \"${appCopyright}\"" +
                        " --vendor ${appNameAndVendor}" +
                        " --temp \"${jpackageTempDir}\"" +

                        // Options for creating the application image
                        " --input ${fatJarFolderPath}" +

                        // Options for creating the application launcher
                        " --main-jar ${mainJarName}" +
                        " --main-class bisq.desktop.app.BisqAppMain" +
                        " --java-options -Xss1280k" +
                        " --java-options -XX:MaxRAM=8g" +
                        " --java-options -XX:+UseG1GC" +
                        " --java-options -XX:MaxHeapFreeRatio=10" +
                        " --java-options -XX:MinHeapFreeRatio=5" +
                        " --java-options -XX:+UseStringDeduplication" +
                        " --java-options -Djava.net.preferIPv4Stack=true"
                // Warning: this will cause guice reflection exceptions and lead to issues with the guice internal cache
                // resulting in the UI not loading
//              " --java-options -Djdk.module.illegalAccess=deny" +
        )

        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            // TODO Found no benefit in using --resource-dir "..package/windows", it has the same outcome as opts below
            String windowsOpts = new String(
                    " --icon \"${project(':desktop').projectDir}/package/windows/Bisq.ico\"" +
                            " --resource-dir \"${project(':desktop').projectDir}/package/windows\"" +
                            " --win-dir-chooser" +
                            " --win-per-user-install" +
                            " --win-menu" +
                            " --win-shortcut"
            )

            executeCmd(jPackageFilePath + commonOpts + windowsOpts + " --type exe")
        } else if (Os.isFamily(Os.FAMILY_MAC)) {
            // See https://docs.oracle.com/en/java/javase/14/jpackage/override-jpackage-resources.html
            // for details of "--resource-dir"

            String macOpts = new String(
                    " --resource-dir \"${project(':desktop').projectDir}/package/macosx\""
            )

            executeCmd(jPackageFilePath + commonOpts + macOpts + " --type dmg")
        } else {
            String linuxOpts = new String(
                    " --icon ${project(':desktop').projectDir}/package/linux/icon.png" +

                            // This defines the first part of the resulting packages (the application name)
                            // deb requires lowercase letters, therefore the application name is written in lowercase
                            " --linux-package-name bisq" +

                            // This represents the linux package version (revision)
                            // By convention, this is part of the deb/rpm package names, in addition to the software version
                            " --linux-app-release 1" +

                            " --linux-menu-group Network" +
                            " --linux-shortcut"
            )

            // Package deb
            executeCmd(jPackageFilePath + commonOpts + linuxOpts +
                    " --linux-deb-maintainer noreply@bisq.network" +
                    " --type deb")

            // Clean jpackage temp folder, needs to be empty for the next packaging step (rpm)
            jpackageTempDir.deleteDir()
            jpackageTempDir.mkdirs()

            // Package rpm
            executeCmd(jPackageFilePath + commonOpts + linuxOpts +
                    " --linux-rpm-license-type AGPLv3" + // https://fedoraproject.org/wiki/Licensing:Main?rd=Licensing#Good_Licenses
                    " --type rpm")
        }

        // After binaries have been generated, copy the (deterministic, signed) fat jar to the binaries folder
        copy {
            from "${fatJarFolderPath}/${mainJarName}"
            into binariesFolderPath
            // desktop-1.6.4-SNAPSHOT-all.jar => desktop-1.6.4-SNAPSHOT-all-mac.jar (or -win.jar, or -linux.jar)
            rename { String fileName -> fileName.replace('-all.jar', "-all-" + os + ".jar") }
        }

        // Checksum each file present in the binaries folder
        ant.checksum(algorithm: 'SHA-256') {
            ant.fileset(dir: "${binariesFolderPath}")
        }

        println "The binaries and checksums are ready:"
        FileCollection collection = layout.files { binariesFolderPath.listFiles() }
        collection.collect { it.path }.sort().each { println it }

        // After binaries are ready, copy them to shared folder
        // Env variable can be set by calling "export BISQ_SHARED_FOLDER='Some value'"
        // This is to copy the final binary/ies to a shared folder for further processing if a VM is used.
        String envVariableSharedFolder = "$System.env.BISQ_SHARED_FOLDER"
        println "Environment variable BISQ_SHARED_FOLDER is: ${envVariableSharedFolder}"
        ant.input(message: "Copy the created binary to a shared folder? (y=yes, n=no)",
                addproperty: "copy-to-shared-folder",
                validargs: "y,n")
        if (ant.properties['copy-to-shared-folder'] == 'y') {
            copy {
                from binariesFolderPath
                into envVariableSharedFolder
            }

            // Try to open a native file explorer window at the shared folder location
            if (Os.isFamily(Os.FAMILY_WINDOWS)) {
                executeCmd("start '${envVariableSharedFolder}'")
            } else if (Os.isFamily(Os.FAMILY_MAC)) {
                executeCmd("open '${envVariableSharedFolder}'")
            } else {
                executeCmd("nautilus '${envVariableSharedFolder}'")
            }
        }
    }
}

def executeCmd(String cmd) {
    String shell
    String shellArg
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        shell = 'cmd'
        shellArg = '/c'
    } else {
        shell = 'bash'
        shellArg = '-c'
    }

    println "Executing command:\n${cmd}\n"
    // See "Executing External Processes" section of
    // http://docs.groovy-lang.org/next/html/documentation/
    def commands = [shell, shellArg, cmd]
    def process = commands.execute(null, project.rootDir)
    def result
    if (process.waitFor() == 0) {
        result = process.text
        println "Command output (stdout):\n${result}"
    } else {
        result = process.err.text
        println "Command output (stderr):\n${result}"
    }
    return result
}