CI (Continuous Integration):
- Developers merge code to main branch frequently
- Every merge triggers automated build + tests
- Catches bugs early, prevents integration hell

CD (Continuous Delivery):
- Code is always in a deployable state
- Deployment to staging is automated
- Production deployment requires manual approval

CD (Continuous Deployment):
- Every change that passes tests goes to production
- Fully automated, no manual gates
- Requires high test confidence

Jenkins role:
Developer pushes code → Jenkins detects change →
Pulls code → Builds → Runs tests → Creates artifact →
Deploys to staging → (optional) Deploys to production

Jenkins is the ORCHESTRATOR — it does not build or test
itself, it runs the tools that do (Maven, npm, pytest, etc.)

Freestyle Job:
- Configured through Jenkins UI (point and click)
- Simple, good for basic tasks
- Hard to version control
- Limited flow control

Pipeline Job (recommended):
- Defined in code (Jenkinsfile)
- Version controlled with your source code
- Supports complex workflows (parallel, conditions)
- Two syntaxes: Declarative and Scripted

// Declarative Pipeline (recommended):
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                sh './deploy.sh'
            }
        }
    }
}

// Always use Pipeline over Freestyle for real projects

pipeline {
    agent any
    
    environment {
        DOCKER_IMAGE = "myapp:${env.BUILD_NUMBER}"
        DEPLOY_ENV = "staging"
    }
    
    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', 
                    url: 'https://github.com/org/repo.git'
            }
        }
        
        stage('Build') {
            steps {
                sh 'npm ci'
                sh 'npm run build'
            }
        }
        
        stage('Test') {
            parallel {
                stage('Unit Tests') {
                    steps { sh 'npm run test:unit' }
                }
                stage('Integration Tests') {
                    steps { sh 'npm run test:integration' }
                }
            }
        }
        
        stage('Docker Build') {
            steps {
                sh "docker build -t ${DOCKER_IMAGE} ."
            }
        }
        
        stage('Deploy to Staging') {
            steps {
                sh "./deploy.sh ${DEPLOY_ENV}"
            }
        }
        
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            input {
                message "Deploy to production?"
                ok "Yes, deploy"
            }
            steps {
                sh './deploy.sh production'
            }
        }
    }
    
    post {
        success {
            slackSend message: "Build #${env.BUILD_NUMBER} succeeded"
        }
        failure {
            slackSend message: "Build #${env.BUILD_NUMBER} FAILED"
            mail to: 'team@company.com',
                 subject: "Build Failed",
                 body: "Check Jenkins for details"
        }
        always {
            cleanWs()  // clean workspace
        }
    }
}

// Declarative — structured, opinionated, easier
pipeline {
    agent any
    stages {
        stage('Build') {
            steps { sh 'make build' }
        }
    }
}

// Scripted — flexible, Groovy-based, more powerful
node {
    stage('Build') {
        sh 'make build'
    }
    if (env.BRANCH_NAME == 'main') {
        stage('Deploy') {
            sh 'make deploy'
        }
    }
}

// Declarative is recommended for most use cases
// Scripted is for complex logic that Declarative cannot handle

Master (Controller):
- Manages Jenkins configuration
- Schedules builds
- Distributes work to agents
- Serves the Jenkins UI
- Should NOT run builds itself (in production)

Agent (Node/Slave):
- Executes build jobs assigned by master
- Can be physical machines, VMs, or Docker containers
- Multiple agents for parallel execution
- Can have labels (linux, windows, docker, gpu)

pipeline {
    agent { label 'linux && docker' }
    // This job runs only on agents with both labels
}

// Why use agents?
// 1. Distribute load (master does not get overloaded)
// 2. Different environments (Linux, Windows, macOS)
// 3. Parallel execution (multiple builds simultaneously)
// 4. Security (isolate build environments)

Essential plugins:
- Pipeline          → pipeline as code support
- Git               → Git SCM integration
- Docker Pipeline   → build/run Docker in pipelines
- Credentials       → secure credential management
- Blue Ocean        → modern UI for pipelines
- Slack Notification → send build status to Slack
- JUnit             → test result reporting
- SonarQube Scanner → code quality analysis
- Artifactory       → artifact management
- Role-Based Access  → fine-grained permissions

// Interview tip: know at least 5-6 plugins and
// explain WHY you use each one, not just the name

// NEVER hardcode credentials in Jenkinsfile

// Use Jenkins Credentials store:
// Manage Jenkins → Credentials → Add Credentials

// Access in pipeline:
pipeline {
    agent any
    environment {
        DB_CREDS = credentials('db-credentials')
        // Creates DB_CREDS_USR and DB_CREDS_PSW
    }
    stages {
        stage('Deploy') {
            steps {
                withCredentials([
                    string(credentialsId: 'api-key', 
                           variable: 'API_KEY')
                ]) {
                    sh 'deploy.sh --key $API_KEY'
                }
                // API_KEY is masked in logs
            }
        }
    }
}

Jenkins:
+ Self-hosted (full control)
+ 1800+ plugins
+ Complex pipeline support
- Maintenance overhead
- Needs infrastructure

GitHub Actions:
+ Cloud-hosted (no maintenance)
+ Native GitHub integration
+ Free for public repos
- Vendor lock-in
- Limited for complex workflows

GitLab CI:
+ Built into GitLab
+ Good Docker support
+ Auto DevOps feature
- Tied to GitLab ecosystem

In Indian IT:
- Enterprise/service companies → Jenkins (legacy + control)
- Startups → GitHub Actions (simplicity)
- GitLab shops → GitLab CI