pipeline {
  agent {
    kubernetes {
      inheritFrom "xuanim"
      yamlFile 'misc/ci/normal.yaml'
    }
  }

  options {
    skipDefaultCheckout()
  }

  environment {
    TZ="Asia/Shanghai"

    ZENTAO_RELEASE_PATH = "${WORKSPACE}/release"
    XUANXUAN_SRC_PATH = "${WORKSPACE}/xuansrc"
    SRC_ZDOO_PATH = "${WORKSPACE}/zdoo"
    SRC_ZDOOEXT_PATH = "${WORKSPACE}/zdooext"
    SRC_ZENTAOEXT_PATH = "${WORKSPACE}/zentaoext"

    MIDDLE_IMAGE_REPO = "hub.qc.oop.cc/zentao-package-ext"
    MIDDLE_IMAGE_TAG = """${sh(
                        returnStdout: true,
                        script: 'date +%Y%m%d%H%M-${BUILD_ID}'
    ).trim()}"""

    MIRROR = "true"

    BUILD_BASIC = "true"
    PUBLISH_ZIP = "true"
    PUBLISH_IMAGE = "true"
    PUBLISH_ZBOX = "true"

    // set to blank for auto-detect from ci.json
    DOWNGRADE_ENABLED = "false"
    DOWNGRADE_VERSIONS = ""
  }

  stages {

    stage("Basic Build") {

      agent {
        kubernetes {
          inheritFrom "zentao-package build-docker xuanim"
          yamlFile 'misc/ci/basic-build.yaml'
        }
      }

      stages {
        stage("Pull") {
          steps {
            checkout scm
            script {
              env.XUANVERSION = sh(returnStdout: true,script: 'jq -r .pkg.xuanxuan.gitVersion < ci.json').trim()
              env.ZENTAOEXT_VERSION = sh(returnStdout: true,script: 'jq -r .pkg.zentaoext.gitVersion < ci.json').trim()
              env.ZENTAOEXT_GIT_REPO = sh(returnStdout: true,script: 'jq -r .pkg.zentaoext.gitRepo < ci.json').trim()
              env.ZDOO_VERSION = sh(returnStdout: true,script: 'jq -r .pkg.zdoo.gitVersion < ci.json').trim()
              env.ZDOOEXT_VERSION = sh(returnStdout: true,script: 'jq -r .pkg.zdooext.gitVersion < ci.json').trim()

            }

            dir('xuansrc') {
              checkout scmGit(branches: [[name: "${env.XUANVERSION}"]],
                userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: 'https://git.zcorp.cc/easycorp/xuanxuan.git']]
              )
            }

            dir('zdoo') {
              checkout scmGit(branches: [[name: "${env.ZDOO_VERSION}"]],
                extensions: [cloneOption(depth: 2, noTags: false, reference: '', shallow: true)],
                userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: 'https://git.zcorp.cc/easycorp/zdoo.git']]
              )
            }

            dir('zdooext') {
              checkout scmGit(branches: [[name: "${env.ZDOOEXT_VERSION}"]],
                extensions: [cloneOption(depth: 2, noTags: false, reference: '', shallow: true)],
                userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: 'https://git.zcorp.cc/easycorp/zdooext.git']]
              )
            }

            dir('zentaoext') {
              checkout scmGit(branches: [[name: "${env.ZENTAOEXT_VERSION}"]],
                extensions: [cloneOption(depth: 2, noTags: false, reference: '', shallow: true)],
                userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: "${env.ZENTAOEXT_GIT_REPO}"]]
              )
            }

          }
        }

        stage("Setup Global Env") {
          steps {
            script {
              env.GIT_URL = sh(returnStdout: true, script: 'git config --get remote.origin.url').trim()
              env.GIT_COMMIT = sh(returnStdout: true, script: 'git rev-parse HEAD').trim()
              env.GIT_TAG_BUILD_TYPE = 'snapshot'
              env.GIT_TAG_BUILD_GROUP = sh(returnStdout: true, script: 'echo `date +%Y%m%d`.devops').trim()
              env.GIT_TAGGER_NAME = sh(returnStdout: true, script: 'git show -s --format=%an').trim()

              env.CI_PUBLIC_IMAGE_NAMESPACE = sh(returnStdout: true,script: 'jq -r .image.public.namespace.' + env.GIT_TAG_BUILD_TYPE + ' < ci.json').trim()
              env.CI_INTERNAL_IMAGE_NAMESPACE = sh(returnStdout: true,script: 'jq -r .image.internal.namespace.' + env.GIT_TAG_BUILD_TYPE + ' < ci.json').trim()

              // def ximUsers = sh(returnStdout: true,script: 'jq -r .notice.users < ci.json').trim()
              env.XIM_USERS = 'qishiyao,zhaoke,zhengyuansheng'
              // env.XIM_GROUPS = sh(returnStdout: true,script: 'jq -r .notice.groups < ci.json').trim()

              env.PMS_VERSION = sh(returnStdout: true, script: 'cat ${SRC_ZENTAOEXT_PATH}/VERSION').trim()
              env.BIZ_VERSION = sh(returnStdout: true, script: 'cat ${SRC_ZENTAOEXT_PATH}/BIZVERSION').trim()
              env.MAX_VERSION = sh(returnStdout: true, script: 'cat ${SRC_ZENTAOEXT_PATH}/MAXVERSION').trim()
              env.IPD_VERSION = sh(returnStdout: true, script: 'cat ${SRC_ZENTAOEXT_PATH}/IPDVERSION').trim()

              env.CI_DOWNGRADE_ENABLED = sh(returnStdout: true, script: 'test -n "${DOWNGRADE_ENABLED}" && echo ${DOWNGRADE_ENABLED} || (jq -r .downgrade.enabled < ci.json)').trim()
              env.ARTIFACT_REPOSITORY = sh(returnStdout: true, script: 'misc/parse_tag.sh $TAG_NAME type | grep release >/dev/null && echo easycorp || echo easycorp-snapshot').trim()
              env.ARTIFACT_HOST = "nexus.qc.oop.cc"
              env.ARTIFACT_PROTOCOL = "https"
              env.ARTIFACT_CRED_ID = "nexus-jenkins"
            }

          }
        }

        stage("Build") {
          when {
            environment name:'BUILD_BASIC', value:'true'
          }
          stages {
            stage("make ciCommon") {
              steps {
                container('xuanimbot') {
                  sh 'git config --global --add safe.directory $(pwd)'
                  sh '/usr/local/bin/xuanimbot --title "`echo -n 5byA5aeL5p6E5bu656aF6YGT | base64 --decode`" --url "${BUILD_URL}" --content "Build by Tag ${TAG_NAME}" --debug --custom'
                }
                withCredentials([gitUsernamePassword(credentialsId: 'git-zcorp-cc-jenkins-bot-http',gitToolName: 'git-tool')]) {
                  container('package') {
                    sh 'mkdir ${ZENTAO_RELEASE_PATH} && chown 1000:1000 ${ZENTAO_RELEASE_PATH}'
                    sh 'git config --global pull.ff only'
                    sh 'cp -av ${ZENTAO_BUILD_PATH}/adminer www/'
                    sh 'pwd && ls -l && make ciCommon'
                    sh 'ls -l ${ZENTAO_RELEASE_PATH}'
                  }
                }
              }
            }

            stage("zentaoext") {
              steps {
                container('package') {
                  sh 'cd $SRC_ZENTAOEXT_PATH && make'
                  sh 'cp ${ZENTAO_BUILD_PATH}/zentao*.zip ./'
                  sh 'cp ${ZENTAO_BUILD_PATH}/docker/Dockerfile.release.ext ./Dockerfile.release.ext'
                }
                container('docker') {
                  sh 'docker build --pull -t ${MIDDLE_IMAGE_REPO}:${MIDDLE_IMAGE_TAG} -f Dockerfile.release.ext ${ZENTAO_RELEASE_PATH}'
                  sh 'docker push ${MIDDLE_IMAGE_REPO}:${MIDDLE_IMAGE_TAG}'
                }
              }
            }

          }
        } // End Build
      }
    }

    stage("Publish") {
      environment {
        OUTPUT_PKG_PATH = "${ZENTAO_RELEASE_PATH}/output"
      }

      stages {
        stage("Merge and Upload") {
          when {
            environment name:'PUBLISH_ZIP', value:'true'
          }
          matrix {
            agent {
              kubernetes {
                containerTemplate {
                    name "package"
                    image "${MIDDLE_IMAGE_REPO}:${MIDDLE_IMAGE_TAG}"
                    command "sleep"
                    args "99d"
                }
              }
            }
            options {
              skipDefaultCheckout()
            }

            axes {
              axis {
                name "ZLANG"
                values "cn"
              }
              axis {
                name "PHPVERSION"
                values "k8s.php8.1"
              }
            }
            excludes {
              exclude {
                axis {
                  name 'ZLANG'
                  values 'en'
                }
                axis {
                  name "PHPVERSION"
                  values "k8s.php7.2_7.4", "k8s.php8.1"
                }
              }
            }

            stages {

              stage("ZIP") {
                environment {
                  ARTIFACT_NAME = """${sh(
                            returnStdout: true,
                            script: 'test ${ZLANG} = cn && echo -n ZenTaoPMS || echo -n ZenTaoALM'
                  ).trim()}"""
                  INT_FLAG = """${sh(
                            returnStdout: true,
                            script: 'test ${ZLANG} = cn && echo -n "int." || echo -n ""'
                  ).trim()}"""
                }

                stages {
                  stage("package zip") {
                    steps{
                        echo "${env.ZLANG} <=> ${env.PHPVERSION}"
                        container('package') {
                          sh 'mkdir $ZENTAO_RELEASE_PATH'
                          sh '${ZENTAO_BUILD_PATH}/package.sh zip'
                          sh 'mkdir $OUTPUT_PKG_PATH'
                        }
                    }
                  }

                  stage("upload zip") {
                    steps {
                      nexusArtifactUploader(
                        nexusVersion: 'nexus3',
                        protocol: env.ARTIFACT_PROTOCOL,
                        nexusUrl: env.ARTIFACT_HOST,
                        groupId: 'zentao.pmsPack' + '.' + env.GIT_TAG_BUILD_GROUP,
                        version: env.PMS_VERSION,
                        repository: env.ARTIFACT_REPOSITORY,
                        credentialsId: env.ARTIFACT_CRED_ID,
                        artifacts: [
                          [artifactId: env.ARTIFACT_NAME,
                            classifier: env.PHPVERSION,
                            file: env.ZENTAO_RELEASE_PATH + '/base.zip',
                            type: 'zip']
                        ]
                      )

                      sh 'mkdir ${OUTPUT_PKG_PATH}/${PMS_VERSION}'
                      sh 'cp ${ZENTAO_RELEASE_PATH}/base.zip ${OUTPUT_PKG_PATH}/${PMS_VERSION}/${ARTIFACT_NAME}-${PMS_VERSION}-${PHPVERSION}.zip'

                      script {
                        def pkgVersionMap = [
                          "biz": ["bizPack", env.BIZ_VERSION],
                          "max": ["maxPack", env.MAX_VERSION],
                          "ipd": ["ipdPack", env.IPD_VERSION]
                        ]

                        for (entry in pkgVersionMap.entrySet()) {
                          echo "set ExtName to ${entry.key}"
                          def ExtName = entry.key
                          echo "set SubGroup to ${entry.value[0]}"
                          def SubGroup = entry.value[0]
                          echo "set Zversion to ${entry.value[1]}"
                          def Zversion = entry.value[1]

                          nexusArtifactUploader(
                            nexusVersion: 'nexus3',
                            protocol: env.ARTIFACT_PROTOCOL,
                            nexusUrl: env.ARTIFACT_HOST,
                            groupId: 'zentao.' + SubGroup + '.' + env.GIT_TAG_BUILD_GROUP,
                            version: Zversion,
                            repository: env.ARTIFACT_REPOSITORY,
                            credentialsId: env.ARTIFACT_CRED_ID,
                            artifacts: [
                              [artifactId: env.ARTIFACT_NAME,
                                classifier: env.PHPVERSION,
                                file: env.ZENTAO_RELEASE_PATH + '/' + ExtName + '.zip',
                                type: 'zip'],
                              [artifactId: env.ARTIFACT_NAME,
                                classifier: 'update.' + env.PHPVERSION,
                                file: env.ZENTAO_RELEASE_PATH + '/' + ExtName + '.update.zip',
                                type: 'zip']
                            ]
                          )
                          sh 'mkdir ${OUTPUT_PKG_PATH}/' + Zversion
                          def moveCmd1 = String.format('mv ${ZENTAO_RELEASE_PATH}/%s.zip ${OUTPUT_PKG_PATH}/%s/${ARTIFACT_NAME}-%s-${PHPVERSION}.zip', ExtName, Zversion, Zversion)
                          sh moveCmd1

                          def moveCmd2 = String.format('mv ${ZENTAO_RELEASE_PATH}/%s.update.zip ${OUTPUT_PKG_PATH}/%s/${ARTIFACT_NAME}-%s-update.${PHPVERSION}.zip', ExtName, Zversion, Zversion)
                          sh moveCmd2

                        } // End for loop
                      }


                    }
                  } // End upload zip

                  stage("syspack") {
                    when {
                      // buildingTag()
                      environment name: 'GIT_TAG_BUILD_TYPE', value: 'release'
                    }
                    steps{
                      sh 'env | grep GIT_TAG'
                        container('package') {
                          sh '${ZENTAO_BUILD_PATH}/package.sh deb'
                          sh '${ZENTAO_BUILD_PATH}/package.sh rpm'
                        }
                    }
                  }

                  stage("upload syspack") {
                    when {
                      environment name: 'GIT_TAG_BUILD_TYPE', value: 'release'
                    }

                    steps {
                      sh 'mv ${ZENTAO_RELEASE_PATH}/zentao.rpm ${OUTPUT_PKG_PATH}/${PMS_VERSION}/${ARTIFACT_NAME}-${PMS_VERSION}-${PHPVERSION}-1.noarch.rpm'
                      sh 'mv ${ZENTAO_RELEASE_PATH}/zentao.deb ${OUTPUT_PKG_PATH}/${PMS_VERSION}/${ARTIFACT_NAME}_${PMS_VERSION}-${PHPVERSION}-1_all.deb'
                    }
                  } // End upload syspack cn
                } // end stages
              } // end stage frame

            } // End matrix stages
          } // End matrix

        } // End Merge and Upload Max

        stage("Notice ZIP") {
          when {
            environment name:'PUBLISH_ZIP', value:'true'
          }
          steps {
            checkout scmGit(branches: [[name: "master"]],
              extensions: [cloneOption(depth: 2, noTags: false, reference: '', shallow: true)],
              userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: 'https://git.zcorp.cc/devops/zentao-package.git']]
            )
            container('xuanimbot') {
              sh 'env | grep GIT'
              sh 'git config --global --add safe.directory $(pwd)'
              sh './gen_build_report.sh > success.md'
              sh '/usr/local/bin/xuanimbot --title "`echo -n 56aF6YGT5rqQ56CB5YyF5p6E5bu65oiQ5Yqf | base64 --decode`" --url "${RUN_DISPLAY_URL}" --content-file success.md --debug --custom'
            }
          }
        }

        stage("Docker Image") {
          when {
            environment name:'PUBLISH_IMAGE', value:'true'
          }

          agent {
            kubernetes {
              inheritFrom "dind xuanim"
              yamlFile 'misc/ci/publish-image.yaml'
            }
          }

          environment {
            REGISTRY_HOST="hub.zentao.net"
            CI_BUILD_PUBLIC_IMAGE="true"
            CI_PHP_VER="8.1.23"
          }

          stages() {
            stage("prepare") {
              steps {
                sh 'env'
                checkout scmGit(branches: [[name: "master"]],
                  extensions: [cloneOption(depth: 2, noTags: false, reference: '', shallow: true)],
                  userRemoteConfigs: [[credentialsId: 'git-zcorp-cc-jenkins-bot-http', url: 'https://git.zcorp.cc/app/zentao.git']]
                )
                container('docker') {
                  sh "sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories"
                  sh "apk --no-cache add make bash jq git tzdata"
                  sh "make markdown-init"
                }
              }
            }

            stage("docker ipd") {
              environment {
                ZENTAO_URL = """${sh(
                            returnStdout: true,
                            script: "echo ${ARTIFACT_PROTOCOL}://${ARTIFACT_HOST}/repository/${ARTIFACT_REPOSITORY}/zentao/ipdPack/`echo ${GIT_TAG_BUILD_GROUP} | tr . /`/ZenTaoPMS"
                  ).trim()}"""
              }
              steps {
                container('docker') {
                  withDockerRegistry(credentialsId: 'hub-qucheng-push', url: 'https://' + env.REGISTRY_HOST) {
                    sh "docker buildx create --name mybuilder --driver docker-container --bootstrap"
                    sh "docker buildx use mybuilder"
                    sh 'make build-ipd-k8s'
                  }
                }
              }
            }

            stage("Notice Image") {
              steps {
                container('docker') {
                  sh 'make markdown-render > ./report.md'
                }
                container('xuanimbot') {
                  sh 'git config --global --add safe.directory $(pwd)'
                  sh '/usr/local/bin/xuanimbot --title "`echo -n 56aF6YGT6ZWc5YOP5p6E5bu65oiQ5Yqf | base64 --decode`" --url "${RUN_DISPLAY_URL}" --content-file ./report.md --debug --custom'
                }
              }
            }

          }
        } // End Docker Image

      }

      post {
        failure {
          container('xuanimbot') {
            sh 'git config --global --add safe.directory $(pwd)'
            sh '/usr/local/bin/xuanimbot --title "zentaopms build failed" --url "${BUILD_URL}" --content "" --debug --custom'
          }
        }
      }
    } // end publish

  }

}