package com.homelab.utilities

def clone(String path, String repo_name, String branch_name) {
    log.info("Cloning repo - ${repo_name}, branch - ${branch_name} in path - ${path}")
    dir(path) {
        try {
            sh "rm -rf ${repo_name}"
        }
        catch (Exception e) {
            log.info('Repo not present, proceeding to clone the repo.')
        }
        try {
            withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
                if (branch_name) {
                    sh "git clone -b ${branch_name} https://github.com/Homelab/${repo_name}.git"
                }
                else {
                    sh "git clone https://github.com/Homelab/${repo_name}.git"
                }
            }
        }
        catch (Exception e) {
            env.msg += "\n\nFAILED -\n  ```Unable to clone repo - ${repo_name}, branch - ${branch_name} in path - ${path}.\n  Full Erroror Details - ${e}```"
            env.error_msg_to_db += "Unable to Clone Repo ${repo_name};"
            log.error("${env.msg}")
            throw e
        }
    }
}

def branchCheckOut(String path, String branch_name) {
    log.info("Checking out to branch - ${branch_name} in path - ${path}")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            sh 'git fetch'
            try {
                sh "git checkout ${branch_name}"
                sh 'git pull --ff-only'
            }
            catch (Exception e) {
                log.info('Creating new branch')
                sh "git checkout -b ${branch_name}"
            }
            sh 'git branch'
        }
    }
}

def add(String path, String git_add_file) {
    log.info("Adding files - ${git_add_file} to git, in path - ${path}")
    try {
        dir(path) {
            sh "git add ${git_add_file}"
        }
    }
    catch (Exception e) {
        env.msg += "\n\nFAILED -\n  ```Unable to add files - ${git_add_file} to git, in path - ${path}.\n  Full Erroror Details - ${e}```"
        env.error_msg_to_db += 'Unable to Add Files;'
        log.error("${env.msg}")
        throw e
    }
}

def createTag(path, git_tag, tag_message) {
    log.info("Creating tag - ${git_tag} in git, in path - ${path}")
    try {
        dir(path) {
            sh "git tag ${git_tag} -m '${tag_message}'"
        }
    }
    catch (Exception e) {
        env.msg += "\n\nFAILED -\n  ```Unable to create tag - ${git_tag} in git, in path - ${path}.\n  Full Erroror Details - ${e}```"
        env.error_msg_to_db += "Unable to Create Tag ${git_tag};"
        log.error("${env.msg}")
        throw e
    }
}

def codeCommit(String path, String branch_name, String commit_message) {
    log.info("Commiting code with message - ${commit_message} in git, in path - ${path}")
    def global_arg = '--global'
    def gitName = 'svc-devops-homelab'
    def gitEmail = 'devops@homelab.com'
    def gitEnv = [
        "GIT_AUTHOR_NAME=${gitName}",
        "GIT_AUTHOR_EMAIL=${gitEmail}",
        "GIT_COMMITTER_NAME=${gitName}",
        "GIT_COMMITTER_EMAIL=${gitEmail}",
    ]
    dir(path) {
        withEnv(gitEnv) {
            if (sh(returnStatus: true, script: "git diff-index --quiet ${branch_name} 2>/dev/null")) {
                try {
                    sh "git commit -m '${commit_message}'"
                    return 0
                }
                catch (Exception e) {
                    env.msg += "\n\nFAILED -\n  ```Unable to commit code with message - ${commit_message} to git in path - ${path}.\n  Full Erroror Details - ${e}```"
                    env.error_msg_to_db += 'Unable to Commit;'
                    log.error("${env.msg}")
                    return 1
                }
            }
            else {
                log.info("No changes were made in branch - ${branch_name}")
                return 1
                // log.error("${env.msg}")
            }
        }
    }
}

def codePush(String path, String branch_name) {
    log.info("Pushing code in branch - ${branch_name} in path - ${path}")
    try {
        dir(path) {
            withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
                try {
                    sh "git push -f --set-upstream origin ${branch_name}"
                }
                catch (Exception e) {
                    sh 'git pull --ff-only'
                    sh 'git push -f'
                }
            }
        }
    }
    catch (Exception e) {
        env.msg += "\n\nFAILED -\n  ```Unable to push code in branch - ${branch_name} in path - ${path}.\n  Full Erroror Details - ${e}```"
        env.error_msg_to_db += "Unable to push code in branch - ${branch_name};"
        log.error("${env.msg}")
        throw e
    }
}

def tagPush(String path) {
    log.info("Pushing tag in path - ${path}")
    try {
        dir(path) {
            withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
                sh 'git push --tags'
            }
        }
    }
    catch (Exception e) {
        env.msg += "\n\nFAILED -\n  ```Unable to push tag from path - ${path}.\n  Full Erroror Details - ${e}```"
        env.error_msg_to_db += 'Unable to Push tag;'
        log.error("${env.msg}")
        throw e
    }
}

def createPR(String app_name, String repo_name, String base_branch, String target_branch, String pr_message) {
    log.info("Creating PR with message - ${pr_message} in Github for repo ${repo_name}")
    def body = "{\"title\":\"${app_name} ${base_branch} Onboarding\",\"body\":\"${pr_message}\",\"head\":\"${target_branch}\",\"base\":\"${base_branch}\"}"
    def pr_num = 'empty'

    try {
        withCredentials([usernamePassword(credentialsId: "${env.GITHUB_CRED}", usernameVariable:'user', passwordVariable: 'token')]) {
            create_pr = httpRequest httpMode: 'POST',
                customHeaders: [
                    [name: 'Accept', value: 'application/vnd.github+json'],
                    [maskValue: true, name: 'Authorization', value: 'Bearer ' + token]
                ],
                requestBody: body,
                url: "https://api.github.com/repos/Homelab/${repo_name}/pulls",
                validResponseCodes: '201',
                timeout: 10
            def create_pr_json = readJSON(text: create_pr.content)
            try {
                error_filter = create_pr_json.errors.message[0]
            }
            catch (Exception e) {
                error_filter = 'empty'
            }
            if ( error_filter.contains('No commits between') ) {
                log.info("No changes were made in branch - ${target_branch}. Skipping - PR Creation...\n${create_pr_json}")
            }
            else if ( error_filter.contains('A pull request already exists') ) {
                log.info(error_filter)
            }
            else {
                pr_num = create_pr_json.number
                pr_url = create_pr_json.url
                log.info("PR Number - ${pr_num} and URL - ${pr_url}")
            }
            return pr_num.toString()
        }
    }
    catch (Exception e) {
        env.msg = "\n\nFAILED -\n  Unable to create PR with message - ${pr_message}.\n  Full Error Details - ${e}"
        def error_code = "${e}".split('Status code')[1]
        error_code = error_code.toString()
        error_code = error_code.split(' ')
        error_code = error_code[1]
        env.error_part_msg_to_db = "Unable to Create PR for base branch - ${base_branch}, target branch - ${target_branch}, Repo Name - ${repo_name}. Failed with status code ${error_code};" //Akshay has asked to remove it
        log.error("${env.msg}")
        throw e
    }
}

def mergePR(String repo_name, String pr_num, String target_branch) {
    log.info("Merging PR ${pr_num} in repo - ${repo_name}")
    if ( "${pr_num}" == 'empty' || pr_num == null) {
        log.info("No changes were made in branch - ${target_branch}. Skipping - PR Merge...")
    }
    else {
        try {
            withCredentials([usernamePassword(credentialsId: "${env.GITHUB_CRED}", usernameVariable:'user', passwordVariable: 'token')]) {
                merge_pr = httpRequest httpMode: 'PUT',
                    customHeaders: [
                        [name: 'Accept', value: 'application/vnd.github+json'],
                        [maskValue: true, name: 'Authorization', value: 'Bearer ' + token]
                    ],
                    url: "https://api.github.com/repos/Homelab/${repo_name}/pulls/${pr_num}/merge",
                    validResponseCodes: '200',
                    timeout: 10

                def merge_pr_json = readJSON(text: merge_pr.content)
                if ( merge_pr_json.message.contains('not mergeable') ) {
                    env.msg += "\n\nFAILED -\n  Unable to merge PR - ${pr_num}. PR URL - https://github.com/Homelab/${repo_name}/pulls/${pr_num}. ${merge_pr_json.message}"
                    log.error("${env.msg}")
                    error("${env.msg}")
                }
                else {
                    log.info("PR Merge was SUCCESSFUL. Message - ${merge_pr_json.message}")
                }
            }
        }
        catch (Exception e) {
            env.msg = "\n\nFAILED -\n  Unable to merge PR - ${pr_num} \n  Full Error Details - ${e}"
            def error_code = "${e}".split('Status code')[1]
            error_code = error_code.toString()
            error_code = error_code.split(' ')
            error_code = error_code[1]
            env.error_part_msg_to_db = "Unable to Merge PR - ${pr_num}, Repo Name - ${repo_name} status code ${error_code};" //Akshay has asked to remove it
            log.error("${env.msg}")
            throw e
        }
    }
}

def deleteBranch(String path, String base_branch, String target_branch) {
    log.info("Deleting branch - ${target_branch}")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            sh 'git fetch'
            try {
                sh "git checkout ${base_branch}"
                sh "git branch -d ${target_branch}"
                sh "git push -d origin ${target_branch}"
            }
            catch (Exception e) {
                env.msg = "\n\nFAILED -\n  Unable to delete branch - ${target_branch}.\n  Full Error Details - ${e}"
                env.error_msg_to_db = "Unable to Delete Branch ${target_branch};"
                log.error("${env.msg}")
                throw e
            }
            sh 'git branch'
        }
    }
}

def preDeleteBranch(String path, String base_branch, String target_branch) {
    log.info("Pre Deleting branch - ${target_branch}")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            try {
                sh 'git fetch'
                sh "git checkout ${base_branch}"
                sh "git push -d origin ${target_branch}"
            }
            catch (Exception e) {
                echo "Pre Delete Branch - Unable to delete branch ${target_branch}"
            }
            sh 'git branch'
        }
    }
}

def fetchDiffFilesForPullRequest(String path , String target_branch){
    log.info("check diff from target branch - ${target_branch}")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            try {
                sh "git fetch origin ${target_branch}:${target_branch}"
                sh "git branch"
                def changedFiles = sh(script: "git diff --name-only HEAD ${target_branch}", returnStdout: true).trim()
                echo "${changedFiles}"
                return changedFiles
            }
            catch (Exception e) {
                echo "failed to get the diff files from ${target_branch}"
            }
        }
    }
}
def fetchDiffFilesForPushRequest(String path ){
    log.info("check diff of current and previous commit for ${path}")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            try {
                sh "git fetch origin"

                // Get the latest commit hash and the previous commit hash
                def currentCommit = sh(script: "git rev-parse HEAD", returnStdout: true).trim()
                def previousCommit = sh(script: "git rev-parse HEAD~1", returnStdout: true).trim()
                
                // Capture the list of changed files in a Groovy variable
                def changedFiles = sh(script: "git diff --name-only ${previousCommit} ${currentCommit}", returnStdout: true).trim()
                
                return changedFiles
            }
            catch (Exception e) {
                echo "failed to get the diff files for ${path}"
            }
        }
    }
}

def fetchLatestCommitId(String path, String branch) {
    log.info("Checking the latest commit for branch '${branch}' in path '${path}'")
    dir(path) {
        withCredentials([gitUsernamePassword(credentialsId: "${env.GITHUB_CRED}", gitToolName: 'git-tool')]) {
            try {
                // Fetch the latest changes for the specific branch
                sh "git fetch origin ${branch}:${branch}"

                // Check out the specified branch
                sh "git checkout ${branch}"

                // Get the latest commit hash for the branch
                def currentCommit = sh(script: "git rev-parse ${branch}", returnStdout: true).trim()
                
                return currentCommit
            } catch (Exception e) {
                echo "Failed to get the latest commit for branch '${branch}' in path '${path}': ${e.message}"
                return null
            }
        }
    }
}