// Add this webhook in Gitea:
// http://192.168.1.37:8080/gitea-webhook/post

pipeline {
    agent { label 'rust_nodocker' }

    environment {
        CARGO_TERM_COLOR = 'never'
        RUST_BACKTRACE = '1'
        MSRV = '1.85.1'
        CARGO_TARPAULIN_VERSION = '0.37.5'
        CARGO_AUDIT_VERSION = '0.22.2'
        CARGO_DENY_VERSION = '0.20.2'
        BADGE_PUBLISH_ROOT = '/mnt/assets/coverage'
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm

                sh '''
                    set -eu

                    git submodule sync --recursive
                    git submodule update --init --recursive
                '''
            }
        }

        stage('Setup Rust') {
            steps {
                sh '''
                    set -eu

                    if ! command -v rustup >/dev/null 2>&1; then
                        echo "ERROR: rustup is not installed on this worker." >&2
                        exit 1
                    fi

                    rustup toolchain install stable \
                        --profile minimal \
                        --component rustfmt \
                        --component clippy \
                        --component llvm-tools-preview

                    rustup toolchain install "${MSRV}" \
                        --profile minimal

                    rustup default stable

                    echo
                    rustc --version
                    cargo --version

                    installed_tarpaulin=$(cargo tarpaulin --version 2>/dev/null || true)
                    if [ "${installed_tarpaulin}" != "cargo-tarpaulin-tarpaulin ${CARGO_TARPAULIN_VERSION}" ]; then
                        cargo install cargo-tarpaulin \
                            --locked \
                            --version "${CARGO_TARPAULIN_VERSION}"
                    fi

                    installed_audit=$(cargo audit --version 2>/dev/null || true)
                    if [ "${installed_audit}" != "cargo-audit-audit ${CARGO_AUDIT_VERSION}" ]; then
                        cargo install cargo-audit \
                            --locked \
                            --version "${CARGO_AUDIT_VERSION}"
                    fi

                    installed_deny=$(cargo deny --version 2>/dev/null || true)
                    if [ "${installed_deny}" != "cargo-deny ${CARGO_DENY_VERSION}" ]; then
                        cargo install cargo-deny \
                            --locked \
                            --version "${CARGO_DENY_VERSION}"
                    fi
                '''
            }
        }

        stage('Cargo audit') {
            steps {
                sh '''
                    set -eu

                    cargo audit --deny warnings
                '''
            }
        }

        stage('Cargo deny') {
            steps {
                sh '''
                    set -eu

                    cargo deny check
                '''
            }
        }

        stage('MSRV') {
            steps {
                sh '''
                    set -eu

                    echo "Checking all targets with Rust ${MSRV}..."

                    cargo "+${MSRV}" check \
                        --locked \
                        --all-targets \
                        --all-features

                    cargo "+${MSRV}" test \
                        --locked \
                        --all-targets \
                        --all-features
                '''
            }
        }

        stage('Format') {
            steps {
                sh '''
                    set -eu

                    echo "Checking formatting..."

                    cargo fmt \
                        --all \
                        -- \
                        --check
                '''
            }
        }

        stage('Check') {
            steps {
                sh '''
                    set -eu

                    echo "Running cargo check..."

                    cargo check \
                        --locked \
                        --all-targets \
                        --all-features
                '''
            }
        }

        stage('Tests') {
            steps {
                sh '''
                    set -eu

                    echo "Running tests..."

                    cargo test \
                        --locked \
                        --all-targets \
                        --all-features

                    mkdir -p coverage
                    : > "coverage/.tests-passed-${BUILD_NUMBER}"
                '''
            }
        }

        stage('Clippy') {
            steps {
                sh '''
                    set -eu

                    echo "Running Clippy..."

                    cargo clippy \
                        --locked \
                        --all-targets \
                        --all-features \
                        -- \
                        -D warnings
                '''
            }
        }

        stage('Coverage') {
            steps {
                sh '''
                    set -eu

                    cargo tarpaulin \
                        --config tarpaulin.toml \
                        --output-dir coverage

                    mv coverage/tarpaulin-report.json coverage/summary.json

                    coverage_percent=$(awk -F'"coverage":' '
                        NF > 1 {
                            split($2, value, ",")
                            print value[1]
                            exit
                        }
                    ' coverage/summary.json)
                    scripts/render-coverage-badge.sh \
                        "${coverage_percent}" \
                        coverage/coverage.svg
                    rm coverage/summary.json
                    : > "coverage/.coverage-ready-${BUILD_NUMBER}"
                '''
            }
        }
    }

    post {
        success {
            publishChecks(
                conclusion: 'SUCCESS',
                name: 'Rust CI',
                summary: 'vsg-bridge-ls passed CI.',
                text: 'Dependency audit/policy, MSRV/stable checks, formatting, tests, Clippy, and coverage completed successfully.',
                title: 'Build Successful'
            )

            echo '✅ vsg-bridge-ls passed CI.'
        }

        failure {
            publishChecks(
                conclusion: 'FAILURE',
                name: 'Rust CI',
                summary: 'vsg-bridge-ls failed CI.',
                text: 'A dependency audit/policy, MSRV/stable, formatting, test, Clippy, or coverage check failed. Check the Jenkins log.',
                title: 'Build Failed'
            )

            echo '❌ vsg-bridge-ls CI failed.'
        }

        unstable {
            publishChecks(
                conclusion: 'ACTION_REQUIRED',
                name: 'Rust CI',
                summary: 'vsg-bridge-ls CI is unstable.',
                text: 'The Jenkins build completed with an unstable status.',
                title: 'Build Unstable'
            )

            echo '⚠️ vsg-bridge-ls CI is unstable.'
        }

        cleanup {
            sh '''
                set -eu

                test_status=failing
                if [ -f "coverage/.tests-passed-${BUILD_NUMBER}" ]; then
                    test_status=passing
                fi
                scripts/render-test-badge.sh \
                    "${test_status}" \
                    coverage/test.svg

                if [ ! -f "coverage/.coverage-ready-${BUILD_NUMBER}" ]; then
                    scripts/render-coverage-badge.sh \
                        - \
                        coverage/coverage.svg
                fi

                package_version=
                if command -v cargo >/dev/null 2>&1; then
                    package_id=$(cargo pkgid --locked 2>/dev/null || true)
                    case "$package_id" in
                        *@*) package_version=${package_id##*@} ;;
                    esac
                fi
                if [ -z "$package_version" ]; then
                    package_version=$(awk '
                        $0 == "[package]" { in_package = 1; next }
                        substr($0, 1, 1) == "[" { in_package = 0 }
                        in_package && $1 == "version" && $2 == "=" {
                            gsub(/^"|"$/, "", $3)
                            print $3
                            exit
                        }
                    ' Cargo.toml)
                fi
                if [ -z "$package_version" ]; then
                    echo "could not determine package version" >&2
                    exit 2
                fi
                scripts/render-version-badge.sh \
                    "${package_version}" \
                    coverage/version.svg

                rm -f \
                    "coverage/.tests-passed-${BUILD_NUMBER}" \
                    "coverage/.coverage-ready-${BUILD_NUMBER}"
            '''

            archiveArtifacts(
                allowEmptyArchive: false,
                artifacts: 'coverage/coverage.svg,coverage/test.svg,coverage/version.svg',
                fingerprint: true
            )

            sh '''
                set -eu

                if [ "${BRANCH_NAME:-}" = "main" ]; then
                    scripts/publish-badges.sh \
                        "${BADGE_PUBLISH_ROOT}" \
                        coverage \
                        test \
                        version
                fi
            '''
        }
    }
}
