JenkinsfileDev

def project = "yApp"
def major = 0
def minor = 0
def revision = 0

def appversion = "$major.$minor.$revision"

def amplify_env = ""
def cognito_pool = ""
def pool_id = ""
def cloudfront_id = ""
def awsProfile = "yApp"
def awsRegion = "us-east-2"
def containerId = ""



//environment name
def MAIN_ENV = "main"
def DEV_ENV = "dev"
def TEST_ENV = "test"

// app id
def AMPLIFY_APP_ID = "d34oy4u1icq89e"
def MAIN_CLOUDFRONT_ID = "E1J2AXX98R4GJP" 
def DEV_CLOUDFRONT_ID = "E31QWRSIU8H00V"

//file path we need to update
def LAMBDA_PATH = "amplify/backend/function/yAppLambda/src/appSettings.json"
def GOLBAL_PATH = "amplify/backend/function/yAppLambda/src/global.json"

//cognito
def POOL_URL= "https://cognito-idp.us-east-2.amazonaws.com/"
def TEST_POOL = "us-east-2_DpPbDoSUa"
def DEV_POOL = "us-east-2_AoahD29kD"
def MAIN_POOL = "us-east-2_itXR8ULJ4"

//dotnet tests path
def SOLUTION = "amplify/backend/function/Lambdas.sln"



pipeline {
    environment {
        def label = null // TODO:Update later
        def title = null // filled in later
        AWS_SDK_LOAD_CONFIG = "1"
        AWS_PROFILE = "default"
        IMAGE_NAME = 'my-docker-image' // Replace with your image name
        CONTAINER_NAME = 'my-docker-container' // Replace with your container name
        //DOCKER_REGISTRY = 'my-registry' // Optional: if you are using a private registry
        ACCESS_KEY_ID =""
        SECRET_ACCESS_KEY =""
        AWS_DEFAULT_REGION = "us-east-2"
        APK_OUTPUT_PATH = "/app/yAppMobile/app/build/outputs/apk/debug/app-debug.apk"  // Path to the APK inside the container
        HOST_OUTPUT_DIR = "output"  // Directory on the Jenkins host to store the APK
    }
    agent any
    options {
        timeout(time: 1, unit: "HOURS")
        parallelsAlwaysFailFast()
        disableConcurrentBuilds()
    }
    stages {

   
        
        stage('Initialize environment') {
            steps {
                script {
                    echo 'Initializing Amplify'
                    amplify_env = DEV_ENV
                    pool_id = DEV_POOL
                    cloudfront_id = DEV_CLOUDFRONT_ID

                    cognito_pool = "${POOL_URL}${pool_id}"
                }
            }
        }
        stage('Update Version & App settings') {
            steps {
                script {
                    //To update the version number that display in the app
                    echo "Update lambda settings"
   
                    def jsonData = [
                        Environment: "dev",
                        AwsRegion: "us-east-2",
                        UserPoolId: "${pool_id}",
                        FriendshipTableName: "Friendship-${amplify_env}",
                        PostTableName: "Post-${amplify_env}",
                        CommentTableName: "Comment-${amplify_env}",
                    ]
                    // Convert JSON data to string
                    def jsonString = groovy.json.JsonOutput.toJson(jsonData)
                    // Write JSON string to file
                    writeFile file: LAMBDA_PATH, text: jsonString

                    echo "Show the content of the file"
                    sh ("cat ${LAMBDA_PATH}")
                    //update awsconfiguration.json for jenkins
                    def sourceFile = 'yAppMobile/app/src/main/res/raw/amplifyconfigurationdev.json'
                    def destinationFile = 'yAppMobile/app/src/main/res/raw/amplifyconfiguration.json'

                    // Ensure the source file exists before attempting to read it
                    if (fileExists(sourceFile)) {
                        echo "Replacing content of ${destinationFile} with content from ${sourceFile}."

                        // Replace the content of the destination file with the source file content
                        sh(script: "cat ${sourceFile} > ${destinationFile}")
                        // Ensure the destination file exists after the replacement
                        if (fileExists(destinationFile)) {
                            echo "Content of ${destinationFile} replaced successfully."
                        } else {
                            error "Content of ${destinationFile} not replaced successfully."
                        }
                        sh ("cat ${destinationFile}")
                    } else {
                        error "Source file ${sourceFile} does not exist."
                    }


                }
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    // Pass the AWS Access Key and other build arguments during Docker build
                    sh("docker build --build-arg AWS_ACCESS_KEY_ID=${ACCESS_KEY_ID} --build-arg AWS_SECRET_ACCESS_KEY=${SECRET_ACCESS_KEY} --build-arg AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION} -t ${IMAGE_NAME} .")
                }
            }
        }

        stage('Run tests') {
            steps {
                script {
                    echo 'Running tests'
                    sh(script: "docker run ${IMAGE_NAME} dotnet test ${SOLUTION}", returnStatus: true)
                    // if (testStatus != 0) {
                    //     error("Tests failed. Exiting...")
                    // }
                }
            }
        }
          stage('Initialize Amplify') {
            steps {
                script {
                    echo 'Initializing Amplify'
                    def amplify_project = "{\
                    \"projectName\":\"yApp\",\
                    \"envName\":\"${amplify_env}\",\
                    \"defaultEditor\":\"code\"\
                    }"
                    sh(script:"docker run ${IMAGE_NAME} sh -c 'ls'")
                    sh(script: "docker run ${IMAGE_NAME} sh -c 'chmod +x ./bashDev.sh && ./bashDev.sh'")
                }
            }
        }
         stage('Build Apk') {
             steps {
                script {
                     echo "Ensuring output directory exists..."
                    sh(script: "mkdir -p ${HOST_OUTPUT_DIR}")

                    echo "Creating Docker container to build APK..."
                    sh(script: "docker create --name ${CONTAINER_NAME} ${IMAGE_NAME} sh -c 'chmod +x ./getApk.sh && ./getApk.sh'")

                    echo "Starting the container..."
                    sh(script: "docker start -a ${CONTAINER_NAME}")
                            

                }
            }
        }
        stage('Copy Apk') {
             steps {
                script {
                    
                    echo "copying apk to host"
                    sh(script: "docker cp ${CONTAINER_NAME}:${APK_OUTPUT_PATH} ${HOST_OUTPUT_DIR}/app-dev-debug.apk")

                    sh(script: "docker rm ${CONTAINER_NAME}")
                }
            }
        }
        

    }
    post {
        always {
            echo "Post run"
            // to create a webhook for the github repo
        }
        success {
            // Archive the APK file so it can be downloaded from Jenkins
            archiveArtifacts artifacts: "${HOST_OUTPUT_DIR}/app-dev-debug.apk", allowEmptyArchive: true
        }
        cleanup {
            echo "Clean up Post"
            cleanWs()
        }
    }
}