.jenkins

currentBuild.displayName = "#${BUILD_NUMBER}"
if (env.GERRIT_CHANGE_SUBJECT) {
   currentBuild.displayName += " - ${GERRIT_CHANGE_SUBJECT} (${GERRIT_CHANGE_NUMBER})"
}
if (env.GERRIT_REFNAME) {
   currentBuild.displayName += " - ${GERRIT_REFNAME}"
}

def buildPrepare()
{
   sh """
      git clean -xdff
      uv venv --seed --python 3.12
      uv pip install wheel
      uv pip install cmake>=2.28
   """
}

def buildPreset(String preset, Boolean archive = false)
{
   sh """
      . .venv/bin/activate
      cmake --preset ${preset} -DCPACK_PACKAGE_VERSION=${env.PROJECT_DESCRIBE}
      cmake --build --preset ${preset}
   """

   if (archive) {
      sh """
         . .venv/bin/activate
         cpack --preset ${preset} -G ZIP
      """
      archiveArtifacts (
         artifacts: "build/${preset}/soem-*.zip",
         fingerprint: true
      )
   }
}

def dockerBuildArgs()
{
   return   '''\
   --build-arg BUILDER_UID="$( id -u )" \
   --build-arg BUILDER_GID="$( id -g )" \
   --build-arg BUILDER_USER="$( id -un )" \
   --build-arg BUILDER_GROUP="$( id -gn )" \
'''
}

def buildDocs()
{
   sh """
      . .venv/bin/activate
      uv pip install -r docs/requirements.txt
      cmake --preset docs
      cmake --build --preset docs
   """

   dir('build/docs') {
      script {
         def systemInformation = sh(script: 'cmake --system-information', returnStdout: true)
         def versionLine = systemInformation =~ /CMAKE_PROJECT_VERSION:STATIC=(.*)/
         if (versionLine) {
            env.PROJECT_VERSION = versionLine[0][1].trim()
         }
      }
   }

   publishHTML([
      allowMissing: false,
      alwaysLinkToLastBuild: false,
      keepAll: false,
      reportDir: 'build/docs/docs/sphinx/html/',
      reportFiles: 'index.html',
      reportName: 'Documentation']
   )
   zip(dir: 'build/docs/docs/sphinx',
      glob: 'html/**',
      zipFile: "build/${env.PROJECT_PREFIX}-html.zip"
   )
   archiveArtifacts (
      artifacts: "build/${env.PROJECT_PREFIX}-html.zip"
   )
   stash(
      name: "sphinx-html",
      includes: "build/${env.PROJECT_PREFIX}-html.zip"
   )
}

def installSbomTools()
{
   dir('rt-sbom') {
      checkout scmGit(
         branches: [[name: 'FETCH_HEAD']],
         userRemoteConfigs: [[
            credentialsId: 'b13fb601-0e11-4462-be4b-581c0dc1d845',
            url: 'ssh://products.intra.rt-labs.com:29418/rt-sbom',
            refspec: 'refs/tags/v0.2.0'
         ]]
      )
      sh """
         . ../.venv/bin/activate
         uv pip install .
      """
   }
}

def sbomArchive(Map args)
{
   def archive = args.archive
   def prefix = args.prefix
   def name = args.name
   sh """
      . ${env.WORKSPACE}/.venv/bin/activate
      rt-sbom source ${archive} \
         --inject sbom.spdx.json \
         --source-dir ${prefix}/ \
         --name "${name}" \
         --version "${env.PROJECT_DESCRIBE}" \
         --namespace "${env.PROJECT_SPDX_NAMESPACE}/"
   """
}

def gitArchive(Map args)
{
   def ref = args.ref
   def name = args.name
   def prefix = "${env.PROJECT_PREFIX}-${name}"
   sh """
      git archive ${ref} \
         --output ${prefix}.zip \
         --prefix ${prefix}/
   """

   sbomArchive(
      archive: "${prefix}.zip",
      prefix: "${prefix}",
      name: "${env.PROJECT_NAME}-${name}"
   )

   archiveArtifacts (
      artifacts: "${prefix}.zip"
   )
}

pipeline {
   agent any

   stages {
      stage('prepare') {
         steps {
            script {
               env.PROJECT_NAME = "soem"
               env.PROJECT_DESCRIBE = sh(
                  script: "git describe --tags --always --dirty --match 'v*'",
                  returnStdout: true
               ).trim()
               env.PROJECT_PREFIX = "${env.PROJECT_NAME}-${env.PROJECT_DESCRIBE}"
               env.PROJECT_ORGANIZATION = "RT-Labs AB"
               env.PROJECT_SPDX_NAMESPACE = "https://rt-labs.com/spdx/${env.PROJECT_NAME}/${env.PROJECT_DESCRIBE}"
            }
         }
      }
      stage("build") {
         parallel {
            stage('linux') {
               steps {
                  buildPrepare()
                  buildPreset('default', true)
                  // buildPreset('test')
                  // buildDocs()
               }
            }

            stage('linux-arm64') {
               agent {
                  dockerfile {
                     filename 'linux-arm64.Dockerfile'
                     dir '.docker'
                     additionalBuildArgs dockerBuildArgs()
                  }
               }
               steps {
                  buildPrepare()
                  buildPreset('default', true)
               }
            }

            stage('windows-x64') {
               agent {
                  dockerfile {
                     filename 'windows-x64.Dockerfile'
                     dir '.docker'
                     additionalBuildArgs dockerBuildArgs()
                  }
               }
               steps {
                  buildPrepare()
                  buildPreset('default', true)
               }
            }

         }
      }

      stage('archive') {
         steps {
            installSbomTools()

            gitArchive(
               ref: 'HEAD',
               name: "src"
            )
            gitArchive(
               ref: 'HEAD:samples',
               name: "samples"
            )
         }
      }
   }
}