ccd

#!/bin/bash

TAGS_FILE=".tags.env"
WORKSPACE_ROOT=".workspace"

# Build related
GRADLE_ASSEMBLE_CMD="./gradlew assemble"

function askYesNo() {
    while true; do
        read -n 1 -s yn
        case $yn in
            y|Y) eval "$1"; break ;;
            n|N)  eval "$2"; break ;;
            *)     echo "Please answer yes (y) or no (n)." ;;
        esac
    done
}

function project_config() {
    project=$1
    config=$2
    case $project in
        operational-reports|reports-runner)
            name=operational
            repository="git@github.com:hmcts/hmc-operational-reports-runner.git"
            envPrefix="HMC_OPERATIONAL_REPORTS"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        cft-hearing-service|hearing-service)
            name=hearings
            repository="git@github.com:hmcts/hmc-cft-hearing-service.git"
            envPrefix="HMC_HEARING_SERVICE"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        outbound-adapter)
            name=outbound
            repository="git@github.com:hmcts/hmc-hmi-outbound-adapter.git"
            envPrefix="HMC_OUTBOUND_ADAPTER"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        inbound-adapter)
            name=inbound
            repository="git@github.com:hmcts/hmc-hmi-inbound-adapter.git"
            envPrefix="HMC_INBOUND_ADAPTER"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-data-store-api|data-store-api|data-store|datastore|data-store)
            name=ccd-data-store-api
            repository="git@github.com:hmcts/ccd-data-store-api.git"
            envPrefix="CCD_DATA_STORE_API"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-case-document-am-api|case-document-api|document-api|case-document)
            name=ccd-ccd-case-document-am-api
            repository="git@github.com:hmcts/ccd-case-document-am-api.git"
            envPrefix="CCD_CASE_DOCUMENT_AM_API"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ts-translation-service|translation-service)
            name=ts-translation-service
            repository="git@github.com:hmcts/ts-translation-service.git"
            envPrefix="TS_TRANSLATION_SERVICE"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-definition-store-api|definition-store-api|definition-store|def-store|defstore)
            name=ccd-definition-store-api
            repository="git@github.com:hmcts/ccd-definition-store-api.git"
            envPrefix="CCD_DEFINITION_STORE_API"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-user-profile-api|user-profile-api|user-profile|userprofile)
            name=ccd-user-profile-api
            repository="git@github.com:hmcts/ccd-user-profile-api.git"
            envPrefix="CCD_USER_PROFILE_API"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-api-gateway|api-gateway|gateway)
            name=ccd-api-gateway
            repository="git@github.com:hmcts/ccd-api-gateway.git"
            envPrefix="CCD_API_GATEWAY"
            ;;
        ccd-admin-web|admin-web|admin-web)
            name=ccd-admin-web
            repository="git@github.com:hmcts/ccd-admin-web.git"
            envPrefix="CCD_ADMIN_WEB"
            ;;
        dm-store|document-store)
            name=dm-store
            repository="git@github.com:hmcts/document-management-store-app.git"
            envPrefix="DM_STORE"
            buildCommand="./gradlew installDist assemble"
            ;;
        ccd-test-stubs-service|test-stubs-service)
            name=ccd-test-stubs-service
            repository="git@github.com:hmcts/ccd-test-stubs-service.git"
            envPrefix="CCD_TEST_STUBS_SERVICE"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        xui-manage-cases)
            name=xui-manage-cases
            repository="git@github.com:hmcts/rpx-xui-webapp.git"
            envPrefix="XUI_MANAGE_CASES"
            ;;
        ccd-message-publisher|message-publisher)
            name=ccd-message-publisher
            repository="git@github.com:hmcts/ccd-message-publisher.git"
            envPrefix="CCD_MESSAGE_PUBLISHER"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-case-disposer|case-disposer)
            name=ccd-case-disposer
            repository="git@github.com:hmcts/ccd-case-disposer.git"
            envPrefix="CCD_CASE_DISPOSER"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        ccd-next-hearing-date-updater|next-hearing-date-updater)
            name=ccd-next-hearing-date-updater
            repository="git@github.com:hmcts/ccd-next-hearing-date-updater.git"
            envPrefix="CCD_NEXT_HEARING_DATE_UPDATER"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        am-role-assignment-service|role-assignment-service|ras)
            name=am-role-assignment-service
            repository="git@github.com:hmcts/am-role-assignment-service.git"
            envPrefix="AM_ROLE_ASSIGNMENT_SERVICE"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        case-payment-orders|case-payment-orders-api)
            name=cpo-case-payment-orders-api
            repository="git@github.com:hmcts/cpo-case-payment-orders-api.git"
            envPrefix="CPO_CASE_PAYMENT_ORDERS_API"
            buildCommand=$GRADLE_ASSEMBLE_CMD
            ;;
        *)
            echo "Project must be one of ccd-data-store-api, ccd-definition-store-api, ccd-user-profile-api, ccd-api-gateway, xui-manage-cases, ccd-message-publisher, ccd-case-disposer, ccd-admin-web, dm-store, ccd-case-document-am-api, ts-translation-service, ccd-next-hearing-date-updater, hearing-service, operational-reports, outbound-adapter, inbound-adapter, case-payment-orders-api"
            exit 1 
            ;;
    esac
    case $config in
        name)
            echo $name
            ;;
        tagEnv)
            echo ${envPrefix}_TAG
            ;;
        useLocalEnv)
            echo ${envPrefix}_USE_LOCAL
            ;;
        repository)
            echo $repository
            ;;
        buildCommand)
            echo $buildCommand
            ;;
        *)
            echo "Config is one of name, repository, tagEnv, useLocalEnv or buildCommand. '$config' is unknown"
            exit 1
            ;;
    esac
}


function tag_unset() {
    project=$1
    tagEnv=$(project_config $project tagEnv)
    useLocalEnv=$(project_config $project useLocalEnv)
    touch $TAGS_FILE
    sed -i '' "/$tagEnv/d" $TAGS_FILE
    sed -i '' "/${useLocalEnv}/d" $TAGS_FILE
}


function tag_set() {
    project=$1
    branch=$2
    tagEnv=$(project_config $project tagEnv)
    useLocalEnv=$(project_config $project useLocalEnv)
    tagName=$(tag_name $project $branch)
    touch $TAGS_FILE
    sed -i '' "/$tagEnv/d" $TAGS_FILE
    echo "export $tagEnv=$tagName" >> $TAGS_FILE
    echo "export ${useLocalEnv}=''" >> $TAGS_FILE
}

function has_active_tags() {
    if [ $(has_tagfile) -eq 0 ]; then
        echo 0
    else
        egrep -q "_TAG=" $TAGS_FILE
        if [ $? -eq 0 ]; then
            echo 1
        else
            echo 0
        fi
    fi
}

function active_tags() {
    egrep "_TAG=" $TAGS_FILE | sed -E 's/^export +(.*)_TAG=.*/\1/'
}

function active_tag_hash() {
    tag=$1
    egrep "${tag}_TAG=" $TAGS_FILE | sed -E 's/.*[-]([a-f0-9]+)$/\1/'
}

function active_tag_branch() {
    tag=$1
    egrep "${tag}_TAG=" $TAGS_FILE | sed -E 's/.*=(.+)[-][a-f0-9]+$/\1/'
}

function tag_friendly_name() {
    tag=$1
    echo $1 | tr "[:upper:]_" "[:lower:]-"
}

function workspace_dir() {
    project=$1
    name=$(project_config $project name)
    workspace="$WORKSPACE_ROOT/$name"
    echo $workspace
}

function clean_name() {
    name=$1
    clean=$(echo $name | sed 's#/#-#')
    echo $clean
}

function git_clone() {
    project=$1
    branch=$2
    local_repository=$3
    if [ -n "$branch" ]; then
        branch_option="--branch $branch"
    fi
    workspace=$(workspace_dir $project)
    repository=$(project_config $project repository)
    rm -rf $workspace
    mkdir -p $workspace
    if [ "$local_repository" ]; then
        echo "Cloning from local repository $local_repository"
        repository=$local_repository
    fi
    result=$(git clone --depth=20 --no-tags $branch_option $repository $workspace 2>&1 || exit $?)
    exitcode=$?
    echo "$result"
    echo $result | egrep -q "Remote branch .* not found in upstream origin"
    no_branch=$?
    if [ $no_branch -eq 0 ]; then
        echo
        echo "$project does not contain the branch '$branch'"
        echo
        echo "  $(basename $0) branches $project"
        echo
        echo "To list available branches in '$project'"
        echo
        exit $exitcode
    fi
}

function available_branches() {
    project=$1
    workspace=$(workspace_dir $project)
    git_clone $project
    (cd $workspace; git branch -vr --sort refname --no-merged) | egrep -v 'HEAD|master|demo' | sed 's#origin/##'
}

git_hash() {
    project=$1
    workspace=$(workspace_dir $project)
    gitHash=$(cd $workspace && git rev-parse HEAD | cut -c -7)
    echo $gitHash
}


function tag_name() {
    project=$1
    branch=$2
    gitHash=$(git_hash $project)
    cleanBranch=$(clean_name $branch)
    branch_and_hash=${cleanBranch}-${gitHash}
    echo $branch_and_hash
}


function project_build() {
    project=$1
    workspace=$(workspace_dir $project)
    buildCommand=$(project_config $project buildCommand)
    # Build if required
    if [ -n "$buildCommand" ]; then
        (cd $workspace && eval $buildCommand || exit $?)
    fi
}


function docker_build() {
    project=$1
    branch=$2
    buildProject=$project
    workspace=$(workspace_dir $project)
    tagName=$(tag_name $project $branch)
    # ccd-api-gateway image from azure coming as ccd-api-gateway-web, to match and fix for local branch build
    if [[ $project == "ccd-api-gateway" && $branch != "master" ]]; then
        buildProject="$buildProject-web"
    fi
    imageName=${buildProject#"ccd-"}
    if [[ $project == "xui-manage-cases" ]]; then
      (cd $workspace && docker build . -t xui/webapp:$tagName || exit $?)
    fi
    if [[ $project == "am-role-assignment-service" ]]; then
      (cd $workspace && docker build . -t am/role-assignment-service:$tagName || exit $?)
    fi

    if [[ $project == "ts-translation-service" ]]; then
      (cd $workspace && docker build . -t ts/translation-service:$tagName || exit $?)
    fi

    if [[ $project == "ccd-next-hearing-date-updater" ]]; then
          (cd $workspace && docker build . -t ccd/next-hearing-date-updater:$tagName || exit $?)
    fi

    if [[ $project == "outbound-adapter" ]]; then
          (cd $workspace && docker build . -t hmc/hmi-outbound-adapter:$tagName || exit $?)
    fi
    if [[ $project == "inbound-adapter" ]]; then
          (cd $workspace && docker build . -t hmc/hmi-inbound-adapter:$tagName || exit $?)
    fi

    if [[ $project == "cft-hearing-service" || $project == "hearing-service" ]]; then
          (cd $workspace && docker build . -t hmc/cft-hearing-service:$tagName || exit $?)
    fi

    if [[ $project == "operational-reports" || $project == "reports-runner" ]]; then
          (cd $workspace && docker build . -t hmc/operational-reports-runner:$tagName || exit $?)
    fi

    if [[ $project == "case-payment-orders" || $project == "case-payment-orders-api" ]]; then
          (cd $workspace && docker build . -t cpo/case-payment-orders-api:$tagName || exit $?)
    fi

    if [[ $project != "xui-manage-cases" && $project != "am-role-assignment-service"
    && $project != "ts-translation-service" && $project != "ccd-next-hearing-date-updater"
    && $project != "hearing-service" && $project != "cft-hearing-service"
    && $project != "operational-reports" && $project != "reports-runner" 
    && $project != "outbound-adapter" && $project != "inbound-adapter" 
    && $project != "case-payment-orders" && $project != "case-payment-orders-api" ]]; then
      (cd $workspace && docker build . -t ccd/$imageName:$tagName || exit $?)
    fi


}

function available_compose_files() {
    find compose -name "*.yml" | xargs -I % basename % .yml
}

function default_compose_files() {
    cat compose/defaults.conf
}

function has_tagfile() {
    if [ -f $TAGS_FILE ]; then
        echo 1
    else
        echo 0
    fi
}

function has_active_compose_files() {
    if [ $(has_tagfile) -eq 0 ]; then
        echo 0
    else
        egrep -q "^CCD_ENABLED_COMPOSE_FILES=" $TAGS_FILE
        if [ $? -eq 0 ]; then
            echo 1
        else
            echo 0
        fi
    fi
}

function active_compose_files() {
    if [ $(has_active_compose_files) -eq 1 ]; then
        source $TAGS_FILE
        echo $CCD_ENABLED_COMPOSE_FILES
    else
        echo $(default_compose_files)
    fi
}

function create_compose_file_options() {
    for compose_file in $(active_compose_files)
    do
        compose_file_options="$compose_file_options -f compose/${compose_file}.yml"
    done
    echo $compose_file_options
}

function status_tags() {
    if [ $(has_active_tags) -eq 1 ]; then
        echo "Current overrides:"
        for tag in $(active_tags)
        do
            echo "$(tag_friendly_name $tag) branch:$(active_tag_branch $tag) hash:$(active_tag_hash $tag)"
        done
        echo -e "\n"
    else
        echo -e "No overrides, all using master\n"
    fi
}

function status_compose_files() {
    if [ $(has_active_compose_files) -eq 1 ]; then
        echo "Active compose files:"
        echo -e "$(active_compose_files)\n"
    else
        echo "Using default compose files:"
        echo -e "$(default_compose_files)\n"
    fi
}

function usage() {
    echo "Usage: $(basename $0) <command> [options]"
    echo
    echo "Commands:"
    echo "  default - setup default compose files and run them for linux/mac"
    echo "  set <project> <branch> [file://local_repository_path] - override and build project"
    echo "  unset <project...> - remove project override(s)"
    echo "  branches <project...> - list available branches"
    echo "  status - list current overrides and their status against upstream"
    echo "  update <project...> - update project override to match upstream branch; and build"
    echo "  enable <project>|defaults|show - enable a compose file"
    echo "  disable <project> - disable a compose file"
    echo "  compose [<docker-compose command> [options]] - wrap docker compose for your configuration"
    echo
    exit 1
}

function usage_default() {
    if [ $# -gt 1 ] || ([ $# -eq 1 ] && [ "$1" != "idam" ] && [ "$1" != "xui" ]); then
        echo "Setup default compose files and run them for linux/mac. Usage:"
        echo "$(basename $0) default            # setup default compose files with idam simulator"
        echo "$(basename $0) default idam       # setup default compose files with full idam stack"
        echo "$(basename $0) default xui        # setup default compose files with idam sim + xui-frontend"
        echo
        exit 1
    fi
}

function usage_set() {
    if [ "$1" == "-h" ] || ([ $# -ne 2 ] && [ $# -ne 3 ]); then
        echo "Overrides project to use the supplied branch, and build the project."
        echo "To use a local repository provide its path (file://..) as a third parameter"
        echo "Usage: $(basename $0) set <project> <branch> [file://local_repository_path]"
        echo
        exit 1
    fi
}

function usage_unset() {
    if [ $# -lt 1 -o "$1" == "-h" ]; then
        echo "Remove branch overrides for the given projects."
        echo "Usage: $(basename $0) unset <project...>"
        echo
        exit 1
    fi
}

function usage_branches() {
    if [ $# -lt 1 -o "$1" == "-h" ]; then
        echo "List available branches for the given projects."
        echo "Usage: $(basename $0) branches <project...>"
        echo
        exit 1
    fi
}

function usage_enable() {
    if [ $# -eq 1 -a "$1" == "-h" ]; then
        echo "Enable projects that will be run by 'compose'"
        echo "Usage:"
        echo "  $(basename $0) enable <project> - enable 'project'"
        echo "  $(basename $0) enable defaults - reset the enabled projects to the defaults"
        echo "  $(basename $0) enable show - currently enabled projects"
        echo
        exit 1
    fi
}

function usage_disable() {
    if [ $# -ne 1 -o "$1" == "-h" ]; then
        echo "Disable a projects from being run by 'compose'"
        echo "Usage: $(basename $0) disable <project>"
        echo
        exit 1
    fi
}

function usage_compose() {
    if [ $# -eq 1 -a "$1" == "-h" ]; then
        echo "Use docker-compose to run the configured overrides and enabled projects"
        echo "Usage: $(basename $0) compose [<docker-compose command> [options]]"
        echo
        exit 1
    fi
}

function notimplemented() {
    echo "Not Implemented yet"
    exit 1
}

function ccd_set() {
    usage_set $*
    project=$1
    branch=$2
    if [ "$branch" == "master" ]; then
        tag_unset $project
        return
    fi
    project_config $project repository
    git_clone $*
    project_build $project
    docker_build $project $branch
    tag_set $project $branch
}

function ccd_unset() {
    usage_unset $*
    projects=$*
    for project in $projects
    do
        tag_unset $project
    done
}

function ccd_branches() {
    usage_branches $*
    projects=$*
    for project in $projects
    do
        echo "Branches in '$project'"
        available_branches $project
        echo
    done
}

function ccd_init() {
    echo "creating docker network 'ccd-network'"
    docker network create ccd-network && echo "'ccd-network' created"
}

function ccd_status() {
    echo "Status:"
    echo "======="
    echo
    status_compose_files
    echo
    status_tags
    echo
}

function ccd_update() {
    notimplemented
}

function ccd_enable_show() {
    if [ $(has_active_compose_files) -eq 1 ]; then
        echo "Currently active compose files:"
        for compose_file in $(active_compose_files)
        do
            echo $compose_file
        done | sort
        echo
    else
        echo "No active compose files, using defaults."
    fi
    echo "Default compose files:"
    for compose_file in $(default_compose_files)
    do
        echo $compose_file
    done | sort
}

function ccd_enable_defaults() {
    if [ $(has_active_compose_files) -eq 1 ]; then
        sed -i '' "/CCD_ENABLED_COMPOSE_FILES/d" $TAGS_FILE
    fi
}

function ccd_enable_compose_file() {
    for compose_file in $*
    do
        if [ ! -f compose/${compose_file}.yml ]; then
            (>&2 echo "No such compose file.  Choose one of:"
            echo $(available_compose_files))
        else
            touch $TAGS_FILE
            source $TAGS_FILE
            sed -i '' "/CCD_ENABLED_COMPOSE_FILES/d" $TAGS_FILE
            existing=0
            for enabled_file in $CCD_ENABLED_COMPOSE_FILES
            do
                if [ "$compose_file" == "$enabled_file" ]; then
                    existing=1
                fi
            done
            if [ $existing -eq 0 ]; then
                echo "CCD_ENABLED_COMPOSE_FILES=\"$CCD_ENABLED_COMPOSE_FILES $compose_file\"" >> $TAGS_FILE
            else
                echo "CCD_ENABLED_COMPOSE_FILES=\"$CCD_ENABLED_COMPOSE_FILES\"" >> $TAGS_FILE
            fi
        fi
    done
}

function ccd_enable() {
    usage_enable $*
        subcommand=$1
    case $subcommand in
        show)
            ccd_enable_show
            ;;
        default|defaults)
            ccd_enable_defaults
            ;;
        *)
            ccd_enable_compose_file $*
            ;;
    esac
}

function ccd_disable() {
    if [ $(has_active_compose_files) -eq 0 ]; then
        (>&2 echo "No enabled compose files, so we can't remove this.  Currently using defaults:"
        echo $(default_compose_files))
    else
        for compose_file in $*
        do
            touch $TAGS_FILE
            source $TAGS_FILE
            sed -i '' "/CCD_ENABLED_COMPOSE_FILES/d" $TAGS_FILE
            existing=0
            for enabled_file in $CCD_ENABLED_COMPOSE_FILES
            do
                #if enabled_file is not in the list to be disabled and it's not in $new_enabled yet
                if [[ ! " $* " =~ .*\ $enabled_file\ .* ]] && [[ ! " $new_enabled " =~ .*\ $enabled_file\ .* ]]; then
                    new_enabled="$new_enabled $enabled_file"
                else
                    existing=1
                fi
            done
            if [ $existing -eq 0 ]; then
                (>&2 echo "Cannot disable \"$compose_file\", as it is not active.  Currently active:"
                echo $(active_compose_files))
            fi
            if [ "$new_enabled" != "" ]; then
                echo "CCD_ENABLED_COMPOSE_FILES=\"$new_enabled\"" >> $TAGS_FILE
            fi
        done
    fi
}

function ccd_compose() {

    print_warn_on_compose_down_if_idam_enabled $*

    usage_compose $*
    status_compose_files
    status_tags
    options="$@"
    if [ $(has_tagfile) -eq 1 ]; then
        source $TAGS_FILE
    fi
    compose_file_options=$(create_compose_file_options)
    echo "Docker compose:"
    echo -e "docker-compose $compose_file_options $options\n"
    docker-compose $compose_file_options $options
}

function print_warn_on_compose_down_if_idam_enabled {
    if [[ $(active_compose_files) == *"sidam"* ]] && [[ $1 = "down" ]]; then
        echo "WARNING - 'down' will remove Idam data. Use 'stop' to preserve data. Or if you intended to remove only CCD containers, disable Idam
        compose files first. Do you want to continue?"

        askYesNo "break" "exit"
    fi
}

function ccd_login() {
    #docker logout hmctsprod.azurecr.io &>/dev/null
    az acr login --name hmctsprod --subscription DCD-CNP-Prod
}

function echo_ccd() {
    echo -e "\033[34mCCD ::--\033[0m $@" # blue
}

function echo_error() {
    echo -e "\033[1;91mERROR ::--\033[0m $@" # red
}

function echo_break() {
    echo -e "\033[34m-----------------------------------------------------------------------------------------------------------------------\033[0m"
}

function ccd_default() {
    usage_default $*
    
    echo_break
    echo -e "\033[34m" # set blue
    echo "   _____ _____ _____     ____   ___   ____  _  _______ ____"
    echo "  / ____/ ____|  __ \\   |  _ \\ / _ \\ / ___|| |/ / ____|  _ \\"
    echo " | |   | |    | |  | |  | | | | | | | |    | ' /|  _| | |_) |"
    echo " | |___| |____| |__| |  | |_| | |_| | |___ | . \\| |___|  _ <"
    echo "  \\_____\\_____|_____/   |____/ \\___/ \\____||_|\\_\\_____|_| \\_\\"
    echo_break
    echo -e "\033[0m"  # reset color

    if [ "$1" == "idam" ]; then
        echo_ccd "Starting default CCD setup with full idam compose files..."
    else
        echo_ccd "Starting default CCD setup..."
    fi


    echo_ccd "Looking for azure cli installation..."
    if ! command -v az >/dev/null 2>&1; then
        echo_error "Azure CLI is not installed. Please install it from: https://learn.microsoft.com/cli/azure/install-azure-cli"
        exit 1
    fi
    echo_ccd "Azure CLI installation found."

    # Check if user is already logged in
    if az account show >/dev/null 2>&1; then
        echo_ccd "Skipping Azure login as already logged in..."
    else
        echo_ccd "Logging in to Azure..."
        if ! az login >/dev/null 2>&1; then
            echo_error "Azure CLI login failed. Please run 'az login' manually. "
            exit 1
        fi
        echo_ccd "Azure CLI login succeeded."
    fi
    
    echo_ccd "Logging into CCD container registries..."
    if ! ccd_login >/dev/null; then
        echo_error "CCD container registry login issues detected. Diagnosing..."
        az acr check-health -n hmctsprod --yes
        exit 1
    fi

    echo_ccd "Setting up default environment variables..."
    source ./bin/set-environment-variables.sh &>/dev/null

    compose_file_options=$(create_compose_file_options) >/dev/null
    if docker-compose $compose_file_options ps --services --filter status=running | grep -q . >/dev/null; then
        echo_ccd "Compose containers currently running running."
        echo_ccd "Do you wish to remove existing containers and volumes? (y/n)"
        askYesNo "docker-compose $compose_file_options down -v &>/dev/null; echo_ccd Containers and volumes removed." "echo_ccd Existing containers and volumes preserved."
    fi
    compose_file_options="" # reset variable

    echo_ccd "Enabling default compose files..."
    ccd_enable defaults >/dev/null
    
    # unset backend
    echo_ccd "Resetting existing backend ccd container config..."
    ccd_unset ccd-user-profile-api ccd-definition-store-api ccd-data-store-api am-role-assignment-service service-auth-provider-api ccd-test-stubs-service >/dev/null
    
    # unset frontend
    echo_ccd "Resetting existing frontend ccd container config..."
    ccd_unset ccd-api-gateway ccd-admin-web >/dev/null
    
    # unset sidam
    echo_ccd "Resetting existing idam related container config..."
    ccd_unset idam-sim fr-am fr-idm shared-db smtp-server idam-api idam-web-public idam-web-admin >/dev/null

    if [ "$1" == "idam" ]; then
        echo_ccd "Enable default stack with full idam compose files..."
        ccd_enable backend frontend sidam >/dev/null
    fi

    if [ "$1" == "xui" ]; then
        echo_ccd "Enable default stack with idam simulator and xui frontend compose files..."
        ccd_enable backend frontend idam-sim xui-frontend >/dev/null
    fi

    compose_file_options=$(create_compose_file_options) >/dev/null
    echo_ccd "Pulling latest images..."
    if ! docker-compose $compose_file_options pull; then
        echo_error "Failed to pull latest images. Continue anyways? (y/n)"
        askYesNo "echo_ccd Continuing despite pull failures." "exit 1"
    fi

    echo_ccd "Initializing ccd network..."
    ccd_init &>/dev/null # will either create or already exists

    echo_ccd "Starting up services..."
    if ! docker compose $compose_file_options up -d >/dev/null; then
        echo_error "Failed to start some containers please check logs."
        exit 1
    fi

    echo_ccd "Waiting 30 seconds for services to finish spinning up..."
    sleep 30

    if [ "$1" == "idam" ]; then
        echo_ccd "Setting IDAM_FULL_ENABLED to true for scripts..."
        export IDAM_FULL_ENABLED=true

        echo_ccd "\033[33m[--------------------] 0% Complete\033[0m - Adding IDAM clients..."
        ./bin/add-idam-clients.sh &>/dev/null || { echo_error "IDAM clients failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[####----------------] 20% Complete\033[0m - Adding IDAM roles..."
        ./bin/add-idam-roles.sh &>/dev/null || { echo_error "IDAM roles failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[########------------] 40% Complete\033[0m - Adding users..."
        ./bin/add-users.sh &>/dev/null || { echo_error "Users failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[############--------] 60% Complete\033[0m - Adding ccd roles..."
        ./bin/add-ccd-roles.sh &>/dev/null || { echo_error "Roles failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[################----] 80% Complete\033[0m - Adding role assignments..."
        ./bin/add-role-assignments.sh &>/dev/null || { echo_error "Role assignments failed to apply correctly." ; exit 1; }
        echo_ccd "\033[32m[####################] 100% Complete\033[0m - Setup complete!"
    else
        unset IDAM_FULL_ENABLED
        echo_ccd "\033[33m[--------------------] 0% Complete\033[0m - Adding users..."
        ./bin/add-users.sh &>/dev/null || { echo_error "Users failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[######--------------] 33% Complete\033[0m - Adding ccd roles..."
        ./bin/add-ccd-roles.sh &>/dev/null || { echo_error "Roles failed to apply correctly." ; exit 1; }
        echo_ccd "\033[33m[##############------] 66% Complete\033[0m - Adding role assignments..."
        ./bin/add-role-assignments.sh &>/dev/null || { echo_error "Role assignments failed to apply correctly." ; exit 1; }
        echo_ccd "\033[32m[####################] 100% Complete\033[0m - Setup complete!"
    fi

    echo_break
    if [ "$1" == "idam" ]; then
        echo_ccd "Default setup with full idam compose files complete!"
        echo_ccd "Access admin-web at https://localhost:3100/ with idam credentials ( e.g. ccd.docker.default@hmcts.net : Pa55word11 )"
    elif [ "$1" == "xui" ]; then
        echo_ccd "Default setup with idam simulator and xui frontend compose files complete!"
        echo_ccd "Access admin-web at https://localhost:3100/ with idam credentials ( e.g. ccd.docker.default@hmcts.net : Pa55word11 )"
        echo_ccd "Access xui frontend at http://localhost:3455/ with idam credentials ( e.g. master.caseworker@gmail.com : Pa55word11 )"
    else
        echo_ccd "Default setup complete!"
        echo_ccd "Access admin-web at https://localhost:3100/ with idam credentials ( e.g. ccd.docker.default@hmcts.net : Pa55word11 )"
    fi

    exit 1
}

if [ $# -lt 1 ]; then
    usage
fi

command=$1
shift
case $command in
    init)
        ccd_init
        ;;
    set)
        ccd_set $*
        ;;
    unset)
        ccd_unset $*
        ;;
    branches)
        ccd_branches $*
        ;;
    status)
        ccd_status
        ;;
    update)
        ccd_update
        ;;
    enable)
        ccd_enable $*
        ;;
    disable)
        ccd_disable $*
        ;;
    compose)
        ccd_compose "$@"
        ;;
    login)
        ccd_login
        ;;
    default|defaults)
        ccd_default $*
        ;;
    *)
        usage
        ;;
esac