@Library('shared-lib') _

import tech.avroid.kube.PodTemplates
import tech.avroid.scm.Git
import tech.avroid.jenkins.Notifications
import tech.avroid.jenkins.Jenkins

String projectName = 'cloud' // Replace with your Harbor project name
String repositoryName = 'msg-messenger-core-api' // Replace with your Harbor repository name
String k8sAppName = repositoryName
String pageSize = 100 // maximum number of artifacts to return 100
String apiUrl = "https://${JENKINS_DOCKER_REGISTRY}/api/v2.0/projects/${projectName}" +
                                                 "/repositories/${repositoryName}/artifacts"
properties([
    buildDiscarder(logRotator(artifactDaysToKeepStr: '',
                              artifactNumToKeepStr: '10',
                              daysToKeepStr: '',
                              numToKeepStr: '10')),
    disableConcurrentBuilds(),
    parameters([
          choice(
            name: 'ENV',
            choices: ['DEV'],
            description: 'Select one of environments'
          ),
          [$class: 'ChoiceParameter',
            choiceType: 'PT_SINGLE_SELECT',
            filterLength: 1,
            filterable: true,
            name: 'APP_VERSION',
            script: [$class: 'GroovyScript',
            script: [sandbox: false, script: """
import groovy.json.JsonSlurperClassic
import groovy.json.model.*
import com.cloudbees.plugins.credentials.CredentialsProvider
import com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials
import java.util.regex.Pattern

def createGetHttpClient(String url, String jenkinsCreds) {
    def jenkinsCredentials = CredentialsProvider.lookupCredentials(StandardUsernamePasswordCredentials.class)
    def credentials = jenkinsCredentials.findResult { it.id == jenkinsCreds ? it : null }
    String auth = credentials.username + ":" + credentials.password;
    String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes("utf-8"));
    String authHeaderValue = "Basic " + encodedAuth;
    def httpClient = new URL(url).openConnection() as HttpURLConnection
    httpClient.setRequestMethod('GET');
    httpClient.setRequestProperty("Authorization", authHeaderValue);
    httpClient.setRequestProperty("Accept", "application/json");
    return httpClient
}

String harborApiUrl = "https://${JENKINS_DOCKER_REGISTRY}/api/v2.0/projects/cloud/repositories/msg-messenger-core-api/" +
                      "artifacts?page=1&page_size=100&with_tag=true&sort=-push_time"

def httpClientHarbor = createGetHttpClient(harborApiUrl, "${JENKINS_HARBOR_CREDENTIALS}")
httpClientHarbor.connect()

List imageVersions = []
def harborResponse = new JsonSlurperClassic().parseText(httpClientHarbor.inputStream.text)

harborResponse.each { image ->
    image.tags.each { tag ->
        imageVersions.add(tag.name)
    }
}

return  imageVersions
"""]],
          ]
    ])

])


String repoPath = 'Apps-Backend/msg-messenger-core-api.git'
String branch = 'develop'
String valuesPath = ".helm/values.${params.ENV.toLowerCase()}.yaml"
String namespace = "tavro-cloud-${params.ENV.toLowerCase()}"


String helmChart = 'helm-msg-messenger-core-api'
String helmRepoPath = 'avroid/helm-msg-messenger-core-api'
String helmRepo = "${env.JENKINS_NEXUS_URL}/repository/avroid-charts"


Map configuration = [
    vaultUrl: env.JENKINS_VAULT_URL,
    vaultCredentialId: "${JENKINS_VAULT_TOKEN}",
    engineVersion: 2
]

List dockerCreds = [
  [path: 'team-devops/services/ci-cd/Jenkins/jenkins.avroid.tech', engineVersion: 2,
  secretValues:
    [
      [vaultKey: 'k8s_jenkins_deploy_token'],
    ]
  ]
]

Git git = new Git(this, env.JENKINS_GIT_CREDENTIALS_SSH)
PodTemplates slaveTemplates = new PodTemplates(this, env.JENKINS_DOCKER_REGISTRY,
                                               ["${env.JENKINS_K8S_HARBOR_SECRET}"],
                                               'avroid-office')

slaveTemplates.jnlp {
    slaveTemplates.helm {
        try {
            node(POD_LABEL){
                withVault([configuration: configuration, vaultSecrets: dockerCreds]) {
                    stage('get repo with values'){
                        gitVars = git.clone([urlRepo: "${env.JENKINS_GIT_REPOSITORY_SSH_URL}/${repoPath}",
                                                branch: branch])
                    }
                    container('helm'){
                        stage('deploy'){
                            echo "Deploying version ${env.APP_VERSION} to ${namespace} namespace"
                            sh """#!/bin/sh
                                helm repo add avroid ${helmRepo}
                                helm -n ${namespace} upgrade -f ${valuesPath} \
                                        --set image.tag=${env.APP_VERSION} \
                                        --install ${k8sAppName} ${helmRepoPath} \
                                        --wait
                            """
                        }
                    }
                }
            }
        } catch(err) {
            errorMessage = err.getMessage()

            println 'ERROR: ' + errorMessage

            currentBuild.result = 'FAILURE'

            String currentBuildUser = Jenkins.GetCurrentBuildUser(script: this)
            String emailSubject = "${currentBuild.currentResult}. " +
                                    "Pipeline task: ${currentBuild.fullDisplayName}"

            Notifications.email(
                script: this,
                subject: emailSubject,
                errorString: errorMessage,
                recipientProviders: [],
                to: "${currentBuildUser}@avroid.team"
            )
        }
    }
}