#!groovy

/*
 * This work is protected under copyright law in the Kingdom of
 * The Netherlands. The rules of the Berne Convention for the
 * Protection of Literary and Artistic Works apply.
 * Digital Me B.V. is the copyright owner.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Load Jenkins shared libraries common to all projects
def libLazy = [
  remote:        'https://github.com/digital-me/jenkins-lib-lazy.git',
  branch:        'stable',
  credentialsId: null,
]

library(
  identifier: "libLazy@${libLazy.branch}",
  retriever:  modernSCM([
    $class:        'GitSCMSource',
    remote:        libLazy.remote,
    credentialsId: libLazy.credentialsId
  ]),
  changelog: false,
)

// Load Jenkins shared libraries to customize this project
def libCustom = [
  remote:        'ssh://git@code.in.digital-me.nl:2222/DEVops/JenkinsLibCustom.git',
  branch:        'stable',
  credentialsId: 'bot-ci-dgm-rsa',
]

library(
  identifier: "libCustom@${libCustom.branch}",
  retriever:  modernSCM([
    $class:        'GitSCMSource',
    remote:        libCustom.remote,
    credentialsId: libCustom.credentialsId
  ]),
  changelog: false,
)

// Define the remotes and the working and deploy branches
def remote = 'origin'
def workingBranch = 'master'
def deployBranches = [ 'acceptance', 'production', ]

// Define the directory where the package will be build
def buildDir = 'app/build/outputs/apk'

// Initialize lazyConfig for this pipeline
lazyConfig(
  name: 'dummy-and',
  env: [
    RELEASE:          true,
    JAVA_HOME:        '/usr/java/latest',
    ANDROID_HOME:     '/opt/android/sdk',
    GRADLE_USER_HOME: '/opt/android/gradle',
    GRADLE_OPTS:      '-XX:MaxMetaspaceSize=256m -Xmx1792m -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant -Dme.jenkins -Dorg.gradle.daemon=false -Dkotlin.compiler.execution.strategy=in-process',
    GOOGLE_API_CID:   'dappre-google-api',
  ],
  noIndex:       '(.+_.+|production)',   // Avoid automatic indexing for release and private branches
  xmppTargets:   'noise@conference.qiy.nl',
)

// Define lazyStages
lazyStage {
  name = 'validate'
  onlyif = (! deployBranches.contains(lazyConfig['branch']) )
  tasks = [
    pre: {
      def currentVersion = androidVersion()
      currentBuild.displayName = "#${env.BUILD_NUMBER} ${currentVersion.string}-${currentVersion.number}"
      // Try to see if we can still merge the deploy branches 
      deployBranches.each { deployBranch ->
        gitMerge(workingBranch, deployBranch)
      }
      // Go back to working branch for validation
      sh("git checkout ${lazyConfig['branch']}")
    },
    run: {
      // Check project info with Fastlane
      withEnv(["VERSION=${currentBuild.displayName}"],) {
        fastLane('android', 'info')
      }
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}

lazyStage {
  name = 'test'
  onlyif = (! deployBranches.contains(lazyConfig['branch']) )
  tasks = [
    run: {
      fastLane('android', 'test')
    },
    post: {
      junit(testResults: 'fastlane/report.xml,**/build/test-results/*/*.xml', allowEmptyResults: true)
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}

lazyStage {
  name = 'package'
  tasks = [
    pre: {
      def currentVersion = androidVersion()
      currentBuild.displayName = "#${env.BUILD_NUMBER} ${currentVersion.string}-${currentVersion.number}"
    },
    run: {
      fastLane('android', 'build')
    },
    args: "-v /opt/android:/opt/android"
      + " -v /opt/certificates:/opt/certificates"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
    post: {
      junit(testResults: 'fastlane/report.xml,**/build/test-results/*/*.xml', allowEmptyResults: true)
      archiveArtifacts(artifacts: "${buildDir}/**", allowEmptyArchive: false)
    },
  ]
}

// Release stage only only if criteria are met
lazyStage {
  name = 'release'
  onlyif = ( lazyConfig['branch'] == workingBranch && lazyConfig.env.RELEASE )
  // Ask version if release flag and set and we are in the branch to fork release from 
  input = [
    message: 'Version string',
    parameters: [string(defaultValue: '', description: 'Version string to be release NEXT (no build number)', name: 'VERSION')]
  ]
  tasks = [
    run: {
      def currentVersion = androidVersion()

      // Define next version based on optional input
      def nextVersion = [ string: currentVersion.string, number: currentVersion.number + 1 ]
      if (env.lazyInput) {
        nextVersion = [ string: env.lazyInput, number: nextVersion.number ]
      }

      gitAuth('bot-ci-dgm', {
        // Refresh latest changelogs before releasing
        sh("git checkout ${workingBranch}")
        fastChangeLogs(nextVersion.number, 'android')
        gitCommit("Provide changelogs for version ${currentVersion.number}", 'fastlane/metadata/android')
        gitPush(remote, workingBranch)

        // Refresh each deploy branches with changes from the working branch
        deployBranches.each { deployBranch ->
          gitMerge(workingBranch, deployBranch)
          gitPush(remote, deployBranch)
        }

        // Tag the working branch
        sh("git checkout ${workingBranch}")
        gitTag("${currentVersion.string}-${currentVersion.number}", remote)

        // Refresh latest changelogs and bump version in working branch before deploying
        androidVersion(nextVersion)
        gitCommit("Update version to ${nextVersion.string}-${nextVersion.number}", 'app/build.gradle')

        // Publish working branch with latest changelogs and next version
        gitPush(remote, workingBranch)
      })
    },
    on: 'android',
  ]
}

// From alpha to beta, only for deploy branches
lazyStage {
  name = 'alpha'
  onlyif = ( deployBranches.contains(lazyConfig['branch']) )
  input = 'Deploy to alpha users?'
  tasks = [
    pre: {
      unarchive(mapping:["${buildDir}/" : '.'])
    },
    run: {
      if ( !lazyConfig.env.DRYRUN ) {
        withCredentials([file(credentialsId: env.GOOGLE_API_CID, variable: 'GOOGLE_API_FILE')]) {
          sh('cp $GOOGLE_API_FILE ~/GoogleAPICredentials.json')
          fastLane('android', 'alpha')
        }
      }
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}

lazyStage {
  name = 'beta'
  onlyif = ( deployBranches.contains(lazyConfig['branch']) )
  input = 'Promote to beta users?'
  tasks = [
    pre: {
      unarchive(mapping:["${buildDir}/" : '.'])
    },
    run: {
      if ( !lazyConfig.env.DRYRUN ) {
        withCredentials([file(credentialsId: env.GOOGLE_API_CID, variable: 'GOOGLE_API_FILE')]) {
          sh('cp $GOOGLE_API_FILE ~/GoogleAPICredentials.json')
          def currentVersion = androidVersion()
          withEnv(["VERSION=${currentVersion.string}-${currentVersion.number}"],) {
            fastLane('android', 'beta')
          }
        }
      }
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}

lazyStage {
  name = 'beta_firebase'
  onlyif = (! deployBranches.contains(lazyConfig['branch']) && lazyConfig['branch'] != workingBranch && lazyConfig.env.RELEASE )
  tasks = [
    pre: {
      unarchive(mapping:["${buildDir}/" : '.'])
    },
    run: {
      if ( !lazyConfig.env.DRYRUN ) {
        fastLane('android', 'beta_firebase', "fl_branch:\"${lazyConfig['branch']}\"")
      }
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}
/*
lazyStage {
  name = 'production'
  onlyif = ( deployBranches.contains(lazyConfig['branch']) )
  input = 'Promote to production users?'
  tasks = [
    pre: {
      unarchive(mapping:["${buildDir}/" : '.'])
    },
    run: {
      if ( !lazyConfig.env.DRYRUN ) {
        withCredentials([file(credentialsId: env.GOOGLE_API_CID, variable: 'GOOGLE_API_FILE')]) {
          sh('cp $GOOGLE_API_FILE ~/GoogleAPICredentials.json')
          def currentVersion = androidVersion()
          withEnv(["VERSION=${currentVersion.string}-${currentVersion.number}"],) {
            fastLane('android', 'production')
          }
        }
      }
    },
    args: "-v /opt/android:/opt/android"
      + " -e ANDROID_HOME=${env.ANDROID_HOME}"
      + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
    in: [ 'centos7' ],
    on: 'android',
  ]
}
*/