#!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
    ])
)

// 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
    ])
)

// 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',
    ],
    noIndex: '(.+_.+|production)',   // Avoid automatic indexing for release and private branches
)

// 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: {
            fastLane('android', 'test', '', 'rh-ruby24')
        },
        args: "-v /opt/android:/opt/android"
            + " -e JAVA_HOME=${env.JAVA_HOME}"
            + " -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', '', 'rh-ruby24')
        },
        args: "-v /opt/android:/opt/android"
            + " -v /opt/certificates:/opt/certificates"
            + " -e JAVA_HOME=${env.JAVA_HOME}"
            + " -e ANDROID_HOME=${env.ANDROID_HOME}"
            + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
        in: [ 'centos7' ],
        on: 'android',
        post: {
            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)
            })
        },
        in: [ 'centos7' ],
        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 ) {
                fastLane('android', 'alpha', '', 'rh-ruby24')
            }
        },
        args: "-v /opt/android:/opt/android"
            + " -e JAVA_HOME=${env.JAVA_HOME}"
            + " -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 ) {
                fastLane('android', 'beta', '', 'rh-ruby24')
            }
        },
        args: "-v /opt/android:/opt/android"
        + " -e JAVA_HOME=${env.JAVA_HOME}"
        + " -e ANDROID_HOME=${env.ANDROID_HOME}"
        + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
        in: [ 'centos7' ],
        on: 'android',
    ]
}

lazyStage {
    name = 'beta_crash'
    onlyif = (! deployBranches.contains(lazyConfig['branch']) && lazyConfig['branch'] != workingBranch && lazyConfig.env.RELEASE )
    input = 'Promote to Crashlytics Beta users?'
    tasks = [
        pre: {
            unarchive(mapping:["${buildDir}/" : '.'])
        },
        run: {
            if ( !lazyConfig.env.DRYRUN ) {
                fastLane('android', 'beta_crash', "fl_branch:\"${lazyConfig['branch']}\"", 'rh-ruby24')
            }
        },
        args: "-v /opt/android:/opt/android"
            + " -e JAVA_HOME=${env.JAVA_HOME}"
            + " -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 ) {
                fastLane('android', 'production', '', 'rh-ruby24')
            }
        },
        args: "-v /opt/android:/opt/android"
            + " -e JAVA_HOME=${env.JAVA_HOME}"
            + " -e ANDROID_HOME=${env.ANDROID_HOME}"
            + " -e GRADLE_USER_HOME=${env.GRADLE_USER_HOME}",
        in: [ 'centos7' ],
        on: 'android',
    ]
}
*/