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

    options { 
        buildDiscarder(logRotator(numToKeepStr: '30', daysToKeepStr: '15'))
        gitLabConnection('GitLabConnectionJenkins')
    }
    

    environment {
        VCPKGPATH = "${env.HOME}/jenkins/3rdparty"
    }

    stages {
        stage('clean previous runs and update gitlab commit status'){
            steps{
                deleteDir()
                updateGitlabCommitStatus(name: 'Build macOS', state: 'running')
            }
        }
        stage('Get parameters'){
            parallel{
                stage('Get build options'){
                    steps {
                        script{
                            env.BUILD_OPTIONS = ' '
                            env.BUILD_OPTIONS = sh(script: 'echo "gitlabTriggerPhrase" | grep BUILD_OPTIONS | awk -F "BUILD_OPTIONS="  \'{print \$2}\' | cut -d"\\"" -f2 || :', returnStdout: true).trim()
                            env.ARCHITECTURE = sh(script: 'echo "$gitlabTriggerPhrase" | grep ARCHITECTURE | awk -F "ARCHITECTURE="  \'{print \$2}\' | cut -d\\" -f2', returnStdout: true).trim()
                            if (env.ARCHITECTURE == "")
                                { env.ARCHITECTURE = "arm64" }
                            println env.BUILD_OPTIONS
                            println env.ARCHITECTURE
                        }
                    }
                    post{
                        always {
                            script{                        
                                if (currentBuild.currentResult == 'FAILURE'){
                                    addGitLabMRComment(comment: ":red_circle: ${env.JOB_NAME} FAILURE when getting the additional build parameters :worried:<br/>Build results: [Jenkins [${env.JOB_NAME} ${env.BUILD_DISPLAY_NAME}]](${env.RUN_DISPLAY_URL})<br/>Commit: ${env.GIT_COMMIT}" )
                                }
                            }
                        }
                    }
                }
                stage('Get SDK branch'){
                    steps {
                        script{
                            env.SDK_BRANCH = sh(script: 'echo "$gitlabMergeRequestDescription" | grep SDK_SUBMODULE_TEST | awk -F "SDK_SUBMODULE_TEST="  \'{print \$2}\' | cut -d" " -f1', returnStdout: true).trim()
                            println SDK_BRANCH
                        }
                    }
                    post{
                        always {
                            script{                        
                                if (currentBuild.currentResult == 'FAILURE'){
                                    addGitLabMRComment(comment: ":red_circle: ${env.JOB_NAME} FAILURE when getting the SDK branch :worried:<br/>Build results: [Jenkins [${env.JOB_NAME} ${env.BUILD_DISPLAY_NAME}]](${env.RUN_DISPLAY_URL})<br/>Commit: ${env.GIT_COMMIT}" )
                                }
                            }
                        }
                    }
                }
                stage('get MEGAsync team'){
                    when {
                        expression { 
                            env.gitlabMergeRequestDescription.contains('MEGASYNC_TEAM')
                        }
                    }
                    steps {
                        script{
                            println "${env.gitlabMergeRequestDescription}"
                            env.MEGASYNC_TEAM = sh(script: 'echo "$gitlabMergeRequestDescription" | grep MEGASYNC_TEAM | awk -F "MEGASYNC_TEAM="  \'{print \$2}\' | cut -d" " -f1', returnStdout: true).trim()
                            println MEGASYNC_TEAM
                        }
                    }
                    post{
                        always {
                            script{                        
                                if (currentBuild.currentResult == 'FAILURE'){
                                    addGitLabMRComment(comment: ":red_circle: ${env.JOB_NAME} FAILURE when getting the MEGASYNC team :worried:<br/>Build results: [Jenkins [${env.JOB_NAME} ${env.BUILD_DISPLAY_NAME}]](${env.RUN_DISPLAY_URL})<br/>Commit: ${env.GIT_COMMIT}" )
                                }
                            }
                        }
                    }
                }
            }
        }

        stage('Checkout macOS'){
            steps {
                script {
                    def scmExtensions = [
                        [$class: "UserIdentity", name: "jenkins", email: "jenkins@jenkins"]
                    ]
                    if (env.gitlabTriggerPhrase == null || (env.gitlabTriggerPhrase != null && env.gitlabTriggerPhrase.startsWith('trigger compilation'))) {
                        scmExtensions << [$class: 'PreBuildMerge', options: [fastForwardMode: 'FF', mergeRemote: "origin", mergeStrategy: 'DEFAULT', mergeTarget: "${env.gitlabTargetBranch}"]]
                    }
                    checkout([
                        $class: 'GitSCM', 
                        branches: [[name: "origin/${env.gitlabSourceBranch}"]],
                        userRemoteConfigs: [[ url: "${env.GIT_URL_DESKTOP}", credentialsId: "12492eb8-0278-4402-98f0-4412abfb65c1" ]],
                        extensions: scmExtensions
                    ])
                    macos_sources_workspace = WORKSPACE
                    dir('src/MEGASync/mega'){
                        sh "echo Cloning SDK branch ${SDK_BRANCH}"
                        checkout([
                            $class: 'GitSCM',
                            branches: [[name: "origin/${SDK_BRANCH}"]],
                            userRemoteConfigs: [[ url: "${env.GIT_URL_SDK}", credentialsId: "12492eb8-0278-4402-98f0-4412abfb65c1" ]],
                            extensions: [
                                [$class: "UserIdentity",name: "jenkins", email: "jenkins@jenkins"]
                            ]
                        ])
                    }
                }
            }
        }

        stage('Compile macOS'){
            when {
                beforeAgent true
                anyOf {
                    expression { env.gitlabTriggerPhrase != null && env.gitlabTriggerPhrase.startsWith('trigger compilation')  }
                    allOf{
                        expression { env.gitlabTriggerPhrase == null }
                        triggeredBy "GitlabWebhookCause" 
                    }
                }
            }
            options{
                timeout(time: 120, unit: 'MINUTES')
            }
            environment{
                PATH = "/usr/local/bin:${env.PATH}"
                BUILD_DIR = "contrib/cmake/build_dir"
                MEGAQTPATH= "${env.HOME}/Qt-build/5.15.11/5.15.11/arm64"
            }
            steps{
                dir(macos_sources_workspace){
                    sh "mkdir contrib/cmake/build_dir"
                    sh "cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_VERBOSE_MAKEFILE=1 -DMega3rdPartyDir=${VCPKGPATH} ${BUILD_OPTIONS} -DUSE_THIRDPARTY_FROM_VCPKG=1 -DCMAKE_PREFIX_PATH=${MEGAQTPATH} -S ${macos_sources_workspace}/contrib/cmake -B ${macos_sources_workspace}/${BUILD_DIR}"
                    sh "cmake --build ${macos_sources_workspace}/${BUILD_DIR} --target MEGAsync -j1"
                    sh "cmake --build ${macos_sources_workspace}/${BUILD_DIR} --target MEGAupdater -j1"
                    sh "xcodebuild clean build CODE_SIGN_IDENTITY=\"-\" CODE_SIGNING_REQUIRED=NO -jobs 1 -configuration Debug -target MEGAShellExtFinder -project src/MEGAShellExtFinder/MEGAFinderSync.xcodeproj/"
                }
            }
            post{
                always {
                    script{
                        if (currentBuild.currentResult == 'SUCCESS'){
                            addGitLabMRComment(comment: ":white_check_mark: ${currentBuild.projectName} :green_apple: <b>macOS</b> SUCCEEDED :muscle:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'success')
                        }                                
                        if (currentBuild.currentResult == 'FAILURE'){
                            addGitLabMRComment(comment: ":red_circle: ${currentBuild.projectName} :green_apple: <b>macOS</b> FAILURE  :worried:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'failed')
                        }
                        if (currentBuild.currentResult == 'ABORTED'){
                            addGitLabMRComment(comment: ":interrobang: ${currentBuild.projectName} :green_apple: <b>macOS</b> ABORTED  :confused:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'canceled')
                        }                                
                        if (currentBuild.currentResult == 'UNSTABLE'){
                            addGitLabMRComment(comment: ":interrobang: ${currentBuild.projectName} :green_apple: <b>macOS</b> UNSTABLE  :confused:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'failed')
                        }
                    }
                }
            }
        }

        stage('Build macOS packages'){
            when {
                beforeAgent true
                expression { env.gitlabTriggerPhrase != null && (env.gitlabTriggerPhrase == 'trigger package' || env.gitlabTriggerPhrase.startsWith('trigger package macos'))  }
            }

            stages{
                stage('Build macos packages'){
                    options {
                        timeout(time: 120, unit: 'MINUTES')
                    }
                    environment{
                        VCPKGPATH = "/users/macstudio3/jenkins/3rdparty"
                        QT_BASE_PATH = "${env.HOME}/Qt-build/5.15.11/5.15.11"
                    }
                    steps {
                        dir(macos_sources_workspace){
                            sh "sed -i'' -e 's/sysctl -n hw.ncpu/echo 2/g'  installer_mac.sh"
                            script {
                                def commonArgs = "--build --create-dmg"

                                if (env.ARCHITECTURE == "arm64") {
                                    env.MEGAQTPATH = "${QT_BASE_PATH}/arm64"
                                    sh "./installer_mac.sh ${commonArgs}"
                                }
                                
                                else if (env.ARCHITECTURE == "x86_64") {
                                    env.MEGAQTPATH = "${QT_BASE_PATH}/x86_64"
                                    sh "./installer_mac.sh ${commonArgs} --arch x86_64"
                                }
                                else {
                                    error "Unknown architecture"
                                }
                            }

                        }
                        
                    }
                }
                stage ('Upload Packages') {
                    steps {
                        dir(macos_sources_workspace){
                            script{
                                if (env.ARCHITECTURE == "arm64"){
                                    sh "jf rt del MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/macos/arm64"
                                    sh "cd Release_arm64 && zip -r MEGAsync.app.dSYM.zip MEGAsync.app.dSYM && jf rt upload --regexp '(MEGAsync.*dmg|MEGAsync.*zip)' MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/macos/arm64/"                       
                                }
                                if (env.ARCHITECTURE == "x86_64"){
                                    sh "jf rt del MEGAsync-sprints/$MEGASYNC_TEAM/macos/x86_64"
                                    sh "cd Release_x86_64 && zip -r MEGAsync.app.dSYM.zip MEGAsync.app.dSYM && jf rt upload --regexp '(MEGAsync.*dmg|MEGAsync.*zip)' MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/macos/x86_64/"
                                } 
                            }
                        }
                    }
                }
            }
            post {
                always {
                    script{
                        if (currentBuild.currentResult == 'SUCCESS'){
                            addGitLabMRComment(comment: ":white_check_mark: ${currentBuild.projectName} :green_apple: <b>macOS</b>  SUCCEEDED :muscle:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}<br/>Packages URL: [${env.REPO_URL}/MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/macos]" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'success')
                        }
                        if (currentBuild.currentResult == 'FAILURE'){
                            addGitLabMRComment(comment: ":red_circle: ${currentBuild.projectName} :green_apple: <b>macOS</b> FAILURE  :worried:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                            updateGitlabCommitStatus(name: 'Build macOS', state: 'failed')
                            error "Job failed"
                        }
                    }
                }
            }
        }
    }
}
