pipeline {
    agent { label 'windows && amd64' }

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

    stages {
        stage('clean previous runs and update gitlab commit status'){
            steps{
                deleteDir()
                updateGitlabCommitStatus(name: 'Build windows', 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 = "64" }                            
                            println BUILD_OPTIONS
                            println ARCHITECTURE
                        }
                    }
                }
                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
                        }
                    }
                }
                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
                        }
                    }
                }
            }
        }

        stage('Checkout windows'){
            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
                    ])
                    windows_sources_workspace = WORKSPACE

                    dir('src\\MEGASync\\mega'){
                        sh "echo Cloning SDK branch \"${SDK_BRANCH}\""
                        checkout([
                            $class: 'GitSCM',
                            branches: [[name: "${SDK_BRANCH}"]],
                            userRemoteConfigs: [[ url: "${env.GIT_URL_SDK}", credentialsId: "12492eb8-0278-4402-98f0-4412abfb65c1" ]],
                            extensions: [
                                [$class: "UserIdentity",name: "jenkins", email: "jenkins@jenkins"]
                            ]
                        ])
                    }
                }
            }
        }

        stage('Compile windows'){
            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 {
                VCPKGPATH  = "${windows_sources_workspace}\\..\\vcpkg"
                MEGAQTPATH = "C:\\Qt\\Qt5.15.17\\5.15.17\\x64"
                _MSPDBSRV_ENDPOINT_ = "${BUILD_TAG}"
                TMP       = "${windows_sources_workspace}\\tmp"
                TEMP      = "${windows_sources_workspace}\\tmp"
                TMPDIR    = "${windows_sources_workspace}\\tmp"
            }
            steps{
                sh "echo SDK_BRANCH: \"${params.SDK_BRANCH}\""
                sh "echo ${env.BUILD_OPTIONS}"
                dir(windows_sources_workspace){
                    sh "mkdir build_dir"
                    sh "mkdir tmp"
                    sh "cmake ${env.BUILD_OPTIONS} -G 'Visual Studio 17 2022' -A x64 -DCMAKE_PREFIX_PATH='${MEGAQTPATH}' -DVCPKG_ROOT='${VCPKGPATH}' -S '${windows_sources_workspace}' -B '${windows_sources_workspace}'\\\\build_dir\\\\"
                    sh "cmake --build '${windows_sources_workspace}'\\\\build_dir\\\\ --config Debug --target MEGAsync -j 1"
                    sh "cmake --build '${windows_sources_workspace}'\\\\build_dir\\\\ --config Debug --target MEGAupdater -j 1"
                    sh "cmake --build '${windows_sources_workspace}'\\\\build_dir\\\\ --config Debug --target MEGAShellExt -j 1"            
                }
                script {
                    uploadInstallersExecuted = false
                }

            }
        }

        stage('Build windows installers'){
            when {
                beforeAgent true
                expression { env.gitlabTriggerPhrase != null && (env.gitlabTriggerPhrase == 'trigger package' || env.gitlabTriggerPhrase.startsWith('trigger package windows'))  }
            }
            stages{
                stage('Build windows installers'){
                    options {
                        timeout(time: 120, unit: 'MINUTES')
                    }
                    environment{
                        MEGA_VCPKGPATH  = "${windows_sources_workspace}\\..\\vcpkg"
                        MEGA_QTPATH = "C:\\Qt\\Qt5.15.17\\5.15.17\\x64"
                        LAF_TOKEN = credentials('MEGASYNC_LAF_TOKEN')
                        MEGA_CRASH_BACKEND_URL = credentials('MEGA_CRASH_URL')
                    }
                    steps {
                        dir(windows_sources_workspace){
                            bat """
                                mkdir tmp
                                set _MSPDBSRV_ENDPOINT_= ${BUILD_TAG}
                                set TMP=${Workspace}\\tmp
                                set TEMP=${Workspace}\\tmp
                                set TMPDIR=${Workspace}\\tmp   
                                full_build_process.cmd ${env.ARCHITECTURE} 2 true
                            """
                        }
                    }
                }
                stage ('Upload Installers') {
                    environment{
                        JF_PATH  = "${windows_sources_workspace}\\.."
                    }
                    steps {
                        dir(windows_sources_workspace){
                            script {
                                def windows_artifactory_upload = { String ART_UPLOAD_PATH, String buildDir, String arch ->
                                
                                    withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                                        powershell """
                                            ${JF_PATH}\\jf rt del --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} ${ART_UPLOAD_PATH}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} MEGAsyncSetup${arch}.exe ${ART_UPLOAD_PATH}
                                            cd ${buildDir}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} MEGAsync.pdb ${ART_UPLOAD_PATH}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} mega-desktop-app-gfxworker.pdb ${ART_UPLOAD_PATH}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} SDKlib.pdb ${ART_UPLOAD_PATH}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} MEGAShellExt.pdb ${ART_UPLOAD_PATH}
                                            ${JF_PATH}\\jf rt upload --url ${REPO_URL} --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} MEGAupdater.pdb ${ART_UPLOAD_PATH}
                                        """
                                    }
                                }
                                if (env.ARCHITECTURE == "64") {
                                    windows_artifactory_upload("MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/windows/built64/", "built64", "64")
                                } else if (env.ARCHITECTURE == "32/64") {
                                    windows_artifactory_upload("MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/windows/built64/", "built64", "64")
                                    windows_artifactory_upload("MEGAsync-sprints/$MEGASYNC_TEAM/${env.gitlabMergeRequestIid}/windows/built32/", "built32", "32")
                                }
                                uploadInstallersExecuted = true
                            }
                        }
                    }
                }
            }
        }
    }
    post{
        always {
            deleteDir()
        }
        success {
            script{
                if (uploadInstallersExecuted){
                    addGitLabMRComment(comment: ":white_check_mark: ${currentBuild.projectName} <b>Windows</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}/windows]" )
                } else{
                    addGitLabMRComment(comment: ":white_check_mark: ${currentBuild.projectName} <b>Windows</b> SUCCEEDED :muscle:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
                }
                updateGitlabCommitStatus(name: 'Build windows', state: 'success')
            }
        }
        failure {
            addGitLabMRComment(comment: ":red_circle: ${currentBuild.projectName} <b>Windows</b> FAILURE  :worried:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
            updateGitlabCommitStatus(name: 'Build windows', state: 'failed')
        }
        aborted{
            addGitLabMRComment(comment: ":interrobang: ${currentBuild.projectName} <b>Windows</b> ABORTED  :confused:<br/>Build results: [Jenkins [${currentBuild.displayName}]](${currentBuild.absoluteUrl})<br/>Commit: ${env.GIT_COMMIT}" )
            updateGitlabCommitStatus(name: 'Build windows', state: 'canceled')
        }
    }
}

