properties(
    [
        pipelineTriggers([[$class: "tv.justin.jenkins.twitchgithub.GitHubPushTrigger"]]),
    ]
)

void setBuildStatus(String repo, String message, String state) {
    step([
        $class: "GitHubCommitStatusSetter",
        reposSource: [$class: "ManuallyEnteredRepositorySource", url: "https://git-aws.internal.justin.tv/${repo}"],
        contextSource: [$class: "ManuallyEnteredCommitContextSource", context: "ci/jenkins/build-status"],
        errorHandlers: [[$class: "ChangingBuildStatusErrorHandler", result: "UNSTABLE"]],
        statusResultSource: [ $class: "ConditionalStatusResultSource", results: [[$class: "AnyBuildResult", message: message, state: state]] ]
    ]);
}

pipeline {
    agent any

    environment {
        // General config
        REPO                        = "danielnf/destiny"

        // Staging
        AWS_STAGING_ID             = "twitch-subs-dev-tcs-access-key"
        AWS_STAGING_SECRET_ID      = "twitch-subs-dev-tcs-secret-key"
        STAGING_ECR_URL            = "958836777662.dkr.ecr.us-west-2.amazonaws.com"

        // Production
        PRODUCTION_ECR_URL         = "522398581884.dkr.ecr.us-west-2.amazonaws.com"
        AWS_PRODUCTION_ID          = "twitch-subs-aws-tcs-access-key"
        AWS_PRODUCTION_SECRET_ID   = "twitch-subs-aws-tcs-secret-key"
    }

    options {
        disableConcurrentBuilds()
        timeout(time: 10, unit: 'MINUTES')
        ansiColor('xterm')
        timestamps()
    }

    stages {
        stage('Setup Tests') {
            steps {
                echo 'Checking out code'
                checkout scm

                echo 'Build Environment'
                sh 'env'
                sh 'docker ps'
                sh 'docker-compose ps'
            }
        }

        stage('Run Tests') {
           steps {
                sh 'make docker-test'
           }
        }

        stage('Build Docker Container') {
            steps {
                sh "docker build -t ${REPO} ."
            }
        }

        stage('Push to ECR/S3 when NOT master') {
            when {
                not {
                    branch "master"
                }
            }

            steps {
                withCredentials([
                    string(credentialsId: "${env.AWS_STAGING_ID}", variable: 'AWS_ACCESS_KEY_ID'),
                    string(credentialsId: "${env.AWS_STAGING_SECRET_ID}", variable: 'AWS_SECRET_ACCESS_KEY'),
                    file(credentialsId: 'aws_config', variable: 'AWS_CONFIG_FILE')
                ]) {
                    script {
                        /* ECR Login */
                        sh "aws ecr get-login --no-include-email --region us-west-2 | cut -d' ' -f6 | docker login -u AWS --password-stdin ${STAGING_ECR_URL}"

                        /* Push to ECR - tag latest IF master */
                        sh "docker tag ${REPO} ${STAGING_ECR_URL}/${REPO}:${GIT_COMMIT}"
                        sh "docker push ${STAGING_ECR_URL}/${REPO}:${GIT_COMMIT}"
                    }
                }
            }
        }

        stage('Push to AWS ECR when master') {
            when {
                branch "master"
            }

            steps {
                /* Staging Account */
                withCredentials([
                    string(credentialsId: AWS_STAGING_ID, variable: 'AWS_ACCESS_KEY_ID'),
                    string(credentialsId: AWS_STAGING_SECRET_ID, variable: 'AWS_SECRET_ACCESS_KEY'),
                    file(credentialsId: 'aws_config', variable: 'AWS_CONFIG_FILE')
                ]) {
                    script {
                        /* ECR Login */
                        sh "aws ecr get-login --no-include-email --region us-west-2 | cut -d' ' -f6 | docker login -u AWS --password-stdin ${STAGING_ECR_URL}"

                        /* Push to ECR - tag latest IF master */
                        sh "docker tag ${REPO} ${STAGING_ECR_URL}/${REPO}:${GIT_COMMIT}"
                        sh "docker push ${STAGING_ECR_URL}/${REPO}:${GIT_COMMIT}"

                        sh "docker tag ${REPO} ${STAGING_ECR_URL}/${REPO}:latest"
                        sh "docker push ${STAGING_ECR_URL}/${REPO}:latest"
                    }
                }

                /* Production Account */
                withCredentials([
                    string(credentialsId: AWS_PRODUCTION_ID, variable: 'AWS_ACCESS_KEY_ID'),
                    string(credentialsId: AWS_PRODUCTION_SECRET_ID, variable: 'AWS_SECRET_ACCESS_KEY'),
                    file(credentialsId: 'aws_config', variable: 'AWS_CONFIG_FILE')
                ]) {
                    script {
                        /* ECR Login */
                        sh "aws ecr get-login --no-include-email --region us-west-2 | cut -d' ' -f6 | docker login -u AWS --password-stdin ${PRODUCTION_ECR_URL}"

                        /* Push to ECR - tag latest IF master */
                        sh "docker tag ${REPO} ${PRODUCTION_ECR_URL}/${REPO}:${GIT_COMMIT}"
                        sh "docker push ${PRODUCTION_ECR_URL}/${REPO}:${GIT_COMMIT}"

                        sh "docker tag ${REPO} ${PRODUCTION_ECR_URL}/${REPO}:latest"
                        sh "docker push ${PRODUCTION_ECR_URL}/${REPO}:latest"
                    }
                }
            }
        }
    }

    post {
        success {
            setBuildStatus(REPO, "PR Deployment Successful", "SUCCESS")
        }

        failure {
            setBuildStatus(REPO, "PR Deployment Failed", "FAILURE")
        }

        always {
            sh 'docker-compose -f jenkins/docker-compose.yml down -v'
        }
    }
}
