pipeline {
    agent any

    environment {
        DEBIAN_IP           = 'debian_machine_ip'
        SSH_CREDENTIALS_ID  = 'jenkins_root_ssh'
        REMOTE_SCRIPT       = '/opt/ble-test/ble_api/api/ble.py'
    }

    parameters {
        string(name: 'host_ip',    defaultValue: '172.20.20.51',  description: 'IP of the host that runs the BLE test')
        string(name: 'test_count', defaultValue: '25', description: 'Number of test iterations')
        string(name: 'BT_USB_ID',  defaultValue: '0bda:c821', description: 'USB ID of the BLE dongle')
    }

    stages {
        stage('Run BLE Test') {
            steps {
                // ----- 1. Compute a 6‑digit hash from the epoch seconds
                script {
                    // epoch seconds at the moment the build starts
                    def epochSec = System.currentTimeMillis() / 1000
                    // keep only the last 6 decimal digits
                    def hash = String.format("%06d", epochSec % 1_000_000)
                    env.SCREEN_SESSION = "ble_test_${hash}"
                }

                // ----- 2. Retry SSH 3× in case of a transient hiccup
                retry(3) {
                    // ----- 3. Timeout the whole test (adjust as needed)
                    timeout(time: 5, unit: 'MINUTES') {
                        sshagent([env.SSH_CREDENTIALS_ID]) {
                            sh """
                            ssh -o StrictHostKeyChecking=no \\
                                -o ServerAliveInterval=60 \\
                                -o ServerAliveCountMax=120 \\
                                root@${params.host_ip} <<'EOF'
                                # Ensure screen is present
                                if ! command -v screen > /dev/null; then
                                    echo "screen not found - installing"
                                    apt-get update && apt-get install -y screen
                                fi

                                # Start the test in a detached screen session
                                screen -dmS ${env.SCREEN_SESSION} bash -c '
                                    echo "===== BLE test starting: \$(date)" > /tmp/ble_test.log
                                    usbreset ${params.BT_USB_ID}
                                    sleep 5
                                    cd /opt/ble-test/ble_api
                                    git pull
                                    cd /opt/ble-test/ble_api/api
                                    python3 -u ${REMOTE_SCRIPT} ${params.test_count} 2>&1 | tee -a /tmp/ble_test.log
                                    echo "===== BLE test finished: \$(date)" >> /tmp/ble_test.log
                                '

                                # Give screen a moment to spin up
                                sleep 2
                                EOF
                            """
                        }

                        // Small pause so the screen session has a chance to start
                        sh 'sleep 2'

                        // Verify that the test reported completion
                        sh """
                        ssh -o StrictHostKeyChecking=no \\
                            -o ServerAliveInterval=60 \\
                            -o ServerAliveCountMax=120 \\
                            root@${params.host_ip} <<'EOF'
                            if grep -q "BLE test finished" /tmp/ble_test.log; then
                                echo "Test completed successfully."
                            else
                                echo "Test did NOT finish - aborting build."
                                exit 1
                            fi
                            EOF
                        """
                    }   // end timeout
                }       // end retry
            }           // end steps
        }               // end stage
    }                   // end stages

    // ----- 4. Clean up the screen session on the remote host
    post {
        always {
            sh """
            ssh -o StrictHostKeyChecking=no \\
                -o ServerAliveInterval=60 \\
                -o ServerAliveCountMax=120 \\
                root@${params.host_ip} <<'EOF'
                if screen -list | grep -q ${env.SCREEN_SESSION}; then
                    screen -S ${env.SCREEN_SESSION} -X quit
                fi
                EOF
            """
        }
    }
}