pipeline {
    agent { label 'osx && arm64' }

    options { 
        buildDiscarder(logRotator(numToKeepStr: '25', daysToKeepStr: '30'))
        gitLabConnection('GitLabConnectionJenkins')
    }
    parameters {
        booleanParam(name: 'IS_RELEASE_CANDIDATE', defaultValue: false, description: 'Is it a Release Candidate?')
        string(name: 'RELEASE_CANDIDATE_NAME', defaultValue: '', description: 'i.e: RC2, RC3 (only needed if IS_RELEASE_CANDIDATE is true)')
        booleanParam(name: 'ARM64', defaultValue: true, description: 'Build for ARM64?')
        booleanParam(name: 'X86_64', defaultValue: false, description: 'Build for X86_64?')        
        string(name: 'MEGASYNC_BRANCH', defaultValue: "${env.BRANCH_NAME}", description: 'Which version of MEGAsync should we build? Default is current branch.')
        string(name: 'SDK_BRANCH', defaultValue: ' ', description: 'Optionally, define a custom SDK branch.')
    }
    environment {
        MEGASYNC_BRANCH = "${params.MEGASYNC_BRANCH}"
        SDK_BRANCH = "${params.SDK_BRANCH}"
    }

    stages {
        stage('Clean previous runs'){
            steps{
                deleteDir()
            }
        }

        stage('Checkout macOS'){
            steps {
                checkout([
                    $class: 'GitSCM', 
                    branches: [[name: "${env.MEGASYNC_BRANCH}"]],
                    userRemoteConfigs: [[ url: "${env.GIT_URL_DESKTOP}", credentialsId: "12492eb8-0278-4402-98f0-4412abfb65c1" ]],
                    extensions: [
                        [$class: "UserIdentity",name: "jenkins", email: "jenkins@jenkins"]
                        ]
                ])
                script {
                    macos_sources_workspace = WORKSPACE
                    def branchToCheckout = ''

                    if (env.SDK_BRANCH && env.SDK_BRANCH != ' ') {
                        branchToCheckout = env.SDK_BRANCH
                    } else if (env.MEGASYNC_BRANCH in ['develop', 'master']) {
                        branchToCheckout = "develop"
                    } else {
                        def status = sh(script: "git submodule status src/MEGASync/mega", returnStdout: true).trim()
                        branchToCheckout = status.tokenize(' ')[0].substring(1)
                    }

                    dir('src/MEGASync/mega') {
                        sh "echo Cloning SDK branch ${branchToCheckout}"
                        checkout([
                            $class: 'GitSCM',
                            branches: [[name: branchToCheckout]],
                            userRemoteConfigs: [[url: "${env.GIT_URL_SDK}", credentialsId: "12492eb8-0278-4402-98f0-4412abfb65c1"]],
                            extensions: [
                                [$class: "UserIdentity", name: "jenkins", email: "jenkins@jenkins"]
                            ]
                        ])
                    }
                }
            }
        }
        stage ('Build macOS packages'){
            environment{
                VCPKGPATH  = "${env.HOME}/jenkins/vcpkg"
                QT_BASE_PATH = "${env.HOME}/Qt-build/5.15.17/5.15.17"
                MEGA_CRASH_BACKEND_URL = credentials('MEGA_CRASH_URL')
            }
            steps {
                gitlabCommitStatus (name: 'Build macOS packages'){
                    dir(macos_sources_workspace){
                        sh "sed -i'' -e 's/sysctl -n hw.ncpu/echo 2/g'  installer_mac.sh"
                        script {
                            def commonArgs = params.IS_RELEASE_CANDIDATE == true ? "--build-cmake --sign-adhoc --create-dmg" : "--build-cmake"

                            if (params.ARM64 == true) {
                                env.MEGAQTPATH = "${QT_BASE_PATH}/arm64"
                                sh "./installer_mac.sh ${commonArgs}"
                            }
                            
                            if (params.X86_64 == true) {
                                env.MEGAQTPATH = "${QT_BASE_PATH}/x86_64"
                                sh "./installer_mac.sh ${commonArgs} --arch x86_64"
                            }
                        }

                    }
                }
            }
        }
        stage ('Upload Installers') {
            when {
                beforeAgent true
                anyOf {
                    expression { params.IS_RELEASE_CANDIDATE == true}
                }
            }
            steps {
                dir(macos_sources_workspace){
                    script{
                        MEGASYNC_VERSION = sh (
                        script: '''awk -F'"' '/VER_PRODUCTVERSION_STR/ {split(\$2, a, "."); print a[1]"."a[2]"."a[3]}' src/MEGASync/control/Version.h''',
                        returnStdout: true 
                        ).trim()
                        sh "echo $MEGASYNC_VERSION > version.txt"
                        withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                            if (params.ARM64 == true){
                                sh """
                                    jf rt del \
                                        --url ${REPO_URL} \
                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/macOS/arm64
                                """
                                dir("Release_arm64") {
                                    sh """
                                        jf rt upload \
                                            --url ${REPO_URL} \
                                            --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                            --regexp '(MEGAsync.*dmg|MEGAsync.*zip)' \
                                            MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/macOS/arm64/
                                    """
                                }
                            }
                            if (params.X86_64 == true){
                                sh """
                                    jf rt del \
                                        --url ${REPO_URL} \
                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/macOS/x86_64
                                """
                                dir("Release_x86_64") {
                                    sh """
                                        jf rt upload \
                                            --url ${REPO_URL} \
                                            --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                            --regexp '(MEGAsync.*dmg|MEGAsync.*zip)' \
                                            MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/macOS/x86_64/
                                   """
                                }
                            }
                        }
                    }
                    archiveArtifacts artifacts: 'version.txt', onlyIfSuccessful: true
                }
            }
            post {
                success {
                    script {
                        echo "Installers successfully uploaded. URL: [${env.REPO_URL}/MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/macOS]"    
                    }
                }
            }
        }
    }
}
