String SLACK_NOTIFICATIONS_CHANNEL = '#security-team'
String PROD_ACCOUNT_ID = '437795906767'
String ASSUME_ROLE = 'prod-splitio-ff-manager-secrets-assume-role'
def TEAMS_CHOICES = ['-- Select a team --'] + getDatadogTeamsList()


pipeline {
    agent any

    environment {
        SPLITIO_WORKSPACE_ID = '5b5212f0-21c9-11ea-a4e7-0a9b522eabbd'
        HARNESS_ACCOUNT_IDENTIFIER = 'cej_iP27SSSgxFiM6TOjAw'
    }

    options {
        ansiColor('xterm')
        disableConcurrentBuilds()
        timestamps()
    }

    parameters {
        string(name: 'FLAG_NAME', defaultValue: '', description: 'Required. Name of the feature flag to be created. Must follow snake_case (e.g., my_feature_name) and cannot contain: global, admin.')
        choice(name: 'TEAMS', choices: TEAMS_CHOICES, description: 'Required. Owning team for the flag.')
        choice(name: 'TRAFFIC_TYPE', choices: ['-- Select traffic type --', 'user', 'vendor'], description: 'Required. Type of traffic associated with the flag.')
        string(name: 'JIRA_TICKET', defaultValue: '', description: 'Required. JIRA ticket ID (e.g., SEC-7493)')
        string(name: 'DESCRIPTION', defaultValue: '', description: 'Optional. Description of the flag.')
    }

    stages {
        stage('Load Shared Libraries') {
            steps {
                library "jenkins-global-libraries@master"
            }
        }

        stage('Validate Parameters') {
            steps {
                script {
                    def flagName   = params.FLAG_NAME?.trim()
                    def teams      = params.TEAMS?.trim()
                    def trafficType= params.TRAFFIC_TYPE?.trim()
                    def jiraTicket = params.JIRA_TICKET?.trim()
                    def description= params.DESCRIPTION?.trim()

                    withBuildUser {
                        env.FLAG_OWNER = env.BUILD_USER_EMAIL ?: "unknown"
                    }

                    if (!flagName) {
                        error "FLAG_NAME parameter is required."
                    }
                    if (!teams || teams == '-- Select a team --') {
                        error "TEAMS parameter is required. Please select a valid team."
                    }
                    if (!trafficType || trafficType == '-- Select traffic type --') {
                        error "TRAFFIC_TYPE parameter is required. Please select a valid traffic type."
                    }
                    if (!jiraTicket) {
                        error "JIRA_TICKET parameter is required."
                    }

                    env.VALID_FLAG_NAME    = flagName
                    env.VALID_TEAMS        = teams
                    env.VALID_TRAFFIC_TYPE = trafficType
                    env.VALID_JIRA_TICKET  = jiraTicket
                    env.VALID_DESCRIPTION  = description
                }
            }
        }

        stage('Create Feature Flag') {
            steps {
                script {
                    def args = "create \"${env.VALID_FLAG_NAME}\"" +
                               " --owners \"${env.FLAG_OWNER}\"" +
                               " --teams \"${env.VALID_TEAMS}\"" +
                               " --traffic-type \"${env.VALID_TRAFFIC_TYPE}\"" +
                               " --jira \"${env.VALID_JIRA_TICKET}\""

                    if (env.VALID_DESCRIPTION) {
                        args += " --description \"${env.VALID_DESCRIPTION}\""
                    }

                    echo "Final CLI Command: feature-flag-tool ${args}"

                    withSecrets(awsAccountId: PROD_ACCOUNT_ID, awsRole: ASSUME_ROLE, secrets: [
                        [id: 'prod/splitio-ff-manager/SPLITIO_ADMIN_API_KEY', environmentVariable: 'HARNESS_API_KEY']
                    ]) {
                        dir('splitio_ff_manager') {
                            withEcr {
                                sh """
                                    docker compose run --rm --build \
                                    -e HARNESS_ACCOUNT_IDENTIFIER \
                                    -e SPLITIO_WORKSPACE_ID \
                                    -e HARNESS_API_KEY \
                                    feature-flag-tool ${args}
                                """
                            }
                        }
                    }
                }
            }
        }
    }

    post {
        regression {
            script {
                slackNotify channel: SLACK_NOTIFICATIONS_CHANNEL
            }
        }
        fixed {
            script {
                slackNotify channel: SLACK_NOTIFICATIONS_CHANNEL
            }
        }
        cleanup {
            cleanWs()
        }
    }
}

def getDatadogTeamsList() {
    node {
        script {
            library "jenkins-global-libraries@master"
        }
        withSecrets(awsAccountId: '437795906767', awsRole: 'prod-splitio-ff-manager-secrets-assume-role', secrets: [
            [id: 'prod/splitio-ff-manager/DD_API_KEY', environmentVariable: 'DD_API_KEY'],
            [id: 'prod/splitio-ff-manager/DD_APP_KEY', environmentVariable: 'DD_APP_KEY']
        ]) {
            echo "Fetching teams from Datadog..."
            def response = sh(
                returnStdout: true,
                script: """
                  curl -s -X GET "https://api.datadoghq.com/api/v2/team" \\
                    -H "Accept: application/json" \\
                    -H "DD-API-KEY: $DD_API_KEY" \\
                    -H "DD-APPLICATION-KEY: $DD_APP_KEY"
                """
            ).trim()

            def json = readJSON text: response
            def teams = json.data.collect { it.attributes.name }
            return teams.sort()
        }
    }
}