pipeline {
    agent { label 'linux-testing-package-builder' }

    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: 'BUILD_NEMO', defaultValue: false, description: 'BUILD NEMO?')
        booleanParam(name: 'BUILD_THUNAR', defaultValue: false, description: 'BUILD THUNAR?')
        booleanParam(name: 'BUILD_NAUTILUS', defaultValue: false, description: 'BUILD NAUTILUS')
        booleanParam(name: 'BUILD_DOLPHIN', defaultValue: false, description: 'BUILD DOLPHIN')
        string(name: 'MEGASYNC_BRANCH', defaultValue: 'release/v5.2.0', description: 'Which version of MEGAsync should we build?')
        string(name: 'SDK_BRANCH', defaultValue: ' ', description: 'Optionally, define a custom SDK branch')
    }

    environment {
        linux_sources_workspace = ''
        MEGASYNC_BRANCH = "${params.MEGASYNC_BRANCH}"
        SDK_BRANCH = "${params.SDK_BRANCH}"
    }

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

        stage('Checkout linux'){
            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 {
                    linux_sources_workspace = WORKSPACE
                    def branchToCheckout = ''

                    if (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"]
                            ]
                        ])
                    }
                    linux_sources_workspace = WORKSPACE
                }
            }
        }
        stage("Run Linux full build extensions"){
            matrix {
                axes {
                    axis {
                        name 'ARCHITECTURE';
                        values 'amd64','armhf'
                    }
                    axis {
                        name 'DISTRO';
                        values  'xUbuntu_26.04', 'xUbuntu_25.10', 'xUbuntu_24.04', 'xUbuntu_22.04',
                                'Debian_11','Debian_12','Debian_13','Debian_testing',
                                'DEB_Arch_Extra',
                                'Raspbian_12',
                                'Fedora_43','Fedora_44',
                                'AlmaLinux_9','CentOS_Stream_9',
                                'openSUSE_Leap_16.0', 'openSUSE_Tumbleweed'
                    }
                }
                excludes {
                    exclude {
                        axis {
                            name 'ARCHITECTURE';
                            values 'armhf'
                        }
                        axis {
                            name 'DISTRO';
                            values  'xUbuntu_26.04', 'xUbuntu_25.10','xUbuntu_24.04', 'xUbuntu_22.04',
                                    'Debian_11','Debian_12','Debian_13','Debian_testing',
                                    'DEB_Arch_Extra',
                                    'Fedora_43','Fedora_44',
                                    'AlmaLinux_9','CentOS_Stream_9',
                                    'openSUSE_Leap_16.0', 'openSUSE_Tumbleweed'
                        }
                    }
                    exclude {
                        axis {
                            name 'ARCHITECTURE';
                            values 'amd64'
                        }
                        axis {
                            name 'DISTRO';
                            values  'Raspbian_12'
                        }
                    }
                }
                stages {
                    stage('Build Dolphin') {
                        when {
                            beforeAgent true
                            expression { params.BUILD_DOLPHIN == true }
                        }
                        agent { label 'linux-testing-package-builder' }
                        steps {
                            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                echo "Do Build for ${DISTRO} - ${ARCHITECTURE}"
                                dir(linux_sources_workspace){
                                    lock(resource: "${DISTRO}-${ARCHITECTURE}-MEGAsync-build", quantity: 1, ){
                                        sh "/opt/buildTools/build/buildManager.sh -a $ARCHITECTURE -j 2 build $DISTRO . dolphin-megasync"
                                        sh "/opt/buildTools/repo/repoManager.sh add /srv/builder/results/$DISTRO/$ARCHITECTURE/dolphin-megasync/ $DISTRO"
                                        sh "SIGN_KEY_PATH=/srv/sign_test/ /opt/buildTools/repo/repoManager.sh build -n $DISTRO"
                                    }
                                }
                                script{
                                    if (params.IS_RELEASE_CANDIDATE == true){
                                        def MEGASYNC_VERSION = getVersionFromHeader("src/MEGASync/control/Version.h")
                                        withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                                            dir("/srv/repo/private/$DISTRO"){
                                                sh """
                                                    jf rt upload \
                                                        --url ${REPO_URL} \
                                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                                        --regexp '(dolphin-megasync.*deb\$|dolphin-megasync.*rpm\$|dolphin-megasync.*\\.pkg\\.tar\\.zst\$|dolphin-megasync.*\\.pkg\\.tar\\.xz\$)' \
                                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/
                                                """
                                            }
                                        }
                                        echo "Packages successfully uploaded. URL: [${env.REPO_URL}/MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/]"
                                    }
                                }
                            }
                        }
                    }

                    stage('Build Nemo') {
                        when {
                            beforeAgent true
                            expression { params.BUILD_NEMO == true }
                        }
                        agent { label 'linux-testing-package-builder' }
                        steps {
                            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                echo "Do Build for ${DISTRO} - ${ARCHITECTURE}"
                                dir(linux_sources_workspace){
                                    lock(resource: "${DISTRO}-${ARCHITECTURE}-MEGAsync-build", quantity: 1, ){
                                        sh "/opt/buildTools/build/buildManager.sh -a $ARCHITECTURE -j 2 build $DISTRO . nemo-megasync"
                                        sh "/opt/buildTools/repo/repoManager.sh add /srv/builder/results/$DISTRO/$ARCHITECTURE/nemo-megasync/ $DISTRO"
                                        sh "SIGN_KEY_PATH=/srv/sign_test/ /opt/buildTools/repo/repoManager.sh build -n $DISTRO"
                                    }
                                }
                                script{
                                    if (params.IS_RELEASE_CANDIDATE == true){
                                        def MEGASYNC_VERSION = getVersionFromHeader("src/MEGASync/control/Version.h")
                                        withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                                            dir("/srv/repo/private/$DISTRO"){
                                                sh """
                                                    jf rt upload \
                                                        --url ${REPO_URL} \
                                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                                        --regexp '(nemo-megasync.*deb\$|nemo-megasync.*rpm\$|nemo-megasync.*\\.pkg\\.tar\\.zst\$|nemo-megasync.*\\.pkg\\.tar\\.xz\$)' \
                                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/
                                                """
                                            }
                                        }
                                        echo "Packages successfully uploaded. URL: [${env.REPO_URL}/MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/]"
                                    }
                                }
                            }
                        }
                    }

                    stage('Build Thunar') {
                        when {
                            beforeAgent true
                            expression { params.BUILD_THUNAR == true }
                        }
                        agent { label 'linux-testing-package-builder' }
                        steps {
                            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                echo "Do Build for ${DISTRO} - ${ARCHITECTURE}"
                                dir(linux_sources_workspace){
                                    lock(resource: "${DISTRO}-${ARCHITECTURE}-MEGAsync-build", quantity: 1, ){
                                        sh "/opt/buildTools/build/buildManager.sh -a $ARCHITECTURE -j 2 build $DISTRO . thunar-megasync"
                                        sh "/opt/buildTools/repo/repoManager.sh add /srv/builder/results/$DISTRO/$ARCHITECTURE/thunar-megasync/ $DISTRO"
                                        sh "SIGN_KEY_PATH=/srv/sign_test/ /opt/buildTools/repo/repoManager.sh build -n $DISTRO"
                                    }
                                }
                                script{
                                    if (params.IS_RELEASE_CANDIDATE == true){
                                        def MEGASYNC_VERSION = getVersionFromHeader("src/MEGASync/control/Version.h")
                                        withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                                            dir("/srv/repo/private/$DISTRO"){
                                                sh """
                                                    jf rt upload \
                                                        --url ${REPO_URL} \
                                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                                        --regexp '(thunar-megasync.*deb\$|thunar-megasync.*rpm\$|thunar-megasync.*\\.pkg\\.tar\\.zst\$|thunar-megasync.*\\.pkg\\.tar\\.xz\$)' \
                                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/
                                                """
                                            }
                                        }
                                        echo "Packages successfully uploaded. URL: [${env.REPO_URL}/MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/]"
                                    }
                                }
                            }
                        }
                    }

                    stage('Build nautilus') {
                        when {
                            beforeAgent true
                            expression { params.BUILD_NAUTILUS == true }
                        }
                        agent { label 'linux-testing-package-builder' }
                        steps {
                            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                echo "Do Build for ${DISTRO} - ${ARCHITECTURE}"
                                dir(linux_sources_workspace){
                                    lock(resource: "${DISTRO}-${ARCHITECTURE}-MEGAsync-build", quantity: 1, ){
                                        sh "/opt/buildTools/build/buildManager.sh -a $ARCHITECTURE -j 2 build $DISTRO . nautilus-megasync"
                                        sh "/opt/buildTools/repo/repoManager.sh add /srv/builder/results/$DISTRO/$ARCHITECTURE/nautilus-megasync/ $DISTRO"
                                        sh "SIGN_KEY_PATH=/srv/sign_test/ /opt/buildTools/repo/repoManager.sh build -n $DISTRO"
                                    }
                                }
                                script{
                                    if (params.IS_RELEASE_CANDIDATE == true){
                                        def MEGASYNC_VERSION = getVersionFromHeader("src/MEGASync/control/Version.h")
                                        withCredentials([string(credentialsId: 'MEGASYNC_ARTIFACTORY_TOKEN', variable: 'MEGASYNC_ARTIFACTORY_TOKEN')]) {
                                            dir("/srv/repo/private/$DISTRO"){
                                                sh """
                                                    jf rt upload \
                                                        --url ${REPO_URL} \
                                                        --access-token ${MEGASYNC_ARTIFACTORY_TOKEN} \
                                                        --regexp '(nautilus-megasync.*deb\$|nautilus-megasync.*rpm\$|nautilus-megasync.*\\.pkg\\.tar\\.zst\$|nautilus-megasync.*\\.pkg\\.tar\\.xz\$)' \
                                                        MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/
                                                """
                                            }
                                        }
                                        echo "Packages successfully uploaded. URL: [${env.REPO_URL}/MEGAsync-releases/$MEGASYNC_VERSION/$RELEASE_CANDIDATE_NAME/linux/extensions/$DISTRO/]"
                                    }
                                }
                            }
                        }
                    }

                }
            }
        }
    }                 
    post {
        always {
            deleteDir()
        }
    }
}
            
def getVersionFromHeader(String versionFilePath) {
    return sh(script: "awk -F'\"' '/VER_PRODUCTVERSION_STR/ {split(\$2, a, \".\"); print a[1]\".\"a[2]\".\"a[3]}' ${versionFilePath}", returnStdout: true).trim()
}

