clear

#!/bin/bash
# Define color variables

BLACK=`tput setaf 0`
RED=`tput setaf 1`
GREEN=`tput setaf 2`
YELLOW=`tput setaf 3`
BLUE=`tput setaf 4`
MAGENTA=`tput setaf 5`
CYAN=`tput setaf 6`
WHITE=`tput setaf 7`

BG_BLACK=`tput setab 0`
BG_RED=`tput setab 1`
BG_GREEN=`tput setab 2`
BG_YELLOW=`tput setab 3`
BG_BLUE=`tput setab 4`
BG_MAGENTA=`tput setab 5`
BG_CYAN=`tput setab 6`
BG_WHITE=`tput setab 7`

BOLD=`tput bold`
RESET=`tput sgr0`

# Array of color codes excluding black and white
TEXT_COLORS=($RED $GREEN $YELLOW $BLUE $MAGENTA $CYAN)
BG_COLORS=($BG_RED $BG_GREEN $BG_YELLOW $BG_BLUE $BG_MAGENTA $BG_CYAN)

# Pick random colors
RANDOM_TEXT_COLOR=${TEXT_COLORS[$RANDOM % ${#TEXT_COLORS[@]}]}
RANDOM_BG_COLOR=${BG_COLORS[$RANDOM % ${#BG_COLORS[@]}]}

#----------------------------------------------------start--------------------------------------------------#

echo "${RANDOM_BG_COLOR}${RANDOM_TEXT_COLOR}${BOLD}Starting Execution${RESET}"

# Step 1: Set Compute Zone & Region
echo "${BOLD}${BLUE}Setting Compute Zone & Region${RESET}"
export ZONE=$(gcloud compute project-info describe \
--format="value(commonInstanceMetadata.items[google-compute-default-zone])")

export REGION=$(gcloud compute project-info describe \
--format="value(commonInstanceMetadata.items[google-compute-default-region])")

# Step 2: Configure gcloud region and zone
echo "${BOLD}${CYAN}Configuring gcloud region and zone${RESET}"
gcloud config set compute/region $REGION
gcloud config set compute/zone $ZONE

# Step 3: Download demo archive
echo "${BOLD}${GREEN}Downloading demo archive from GCS${RESET}"
gsutil cp gs://spls/gsp449/gke-cloud-sql-postgres-demo.tar.gz .

# Step 4: Extract the demo archive
echo "${BOLD}${MAGENTA}Extracting demo archive${RESET}"
tar -xzvf gke-cloud-sql-postgres-demo.tar.gz

# Step 5: Navigate to the demo directory
echo "${BOLD}${YELLOW}Navigating to demo directory${RESET}"
cd gke-cloud-sql-postgres-demo

# Step 6: Remove existing create.sh if present
echo "${BOLD}${RED}Removing existing create.sh${RESET}"
rm create.sh

# Step 7: Create new create.sh script
echo "${BOLD}${BLUE}Creating new create.sh script${RESET}"
cat > create.sh <<'EOF'
#!/bin/bash -e

# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# This script will build all the GCP resources in this demo
# The resources include a GKE cluster, a Cloud SQL instance, and
# some accompanying service accounts

help() {
  echo "./create.sh POSTGRES_USERNAME PGADMIN_USERNAME"
  echo "Passwords will be entered via prompts"
}

ROOT=$(dirname "${BASH_SOURCE[0]}")

if [ -f "${ROOT}/.instance" ]; then
    export INSTANCE_NAME=$(cat ${ROOT}/.instance)
    echo "Found existing instance name."
else
    LC_CTYPE=C
    RANDOM_SUFFIX=$(tr -dc 'a-z0-9' </dev/urandom | fold -w 6 | head -n 1)
    export INSTANCE_NAME=demo-postgres-${RANDOM_SUFFIX}
    echo "$INSTANCE_NAME" > "${ROOT}"/.instance
fi

if [ -z "$INSTANCE_NAME" ] ; then
  help
  exit 1
fi

export USER_NAME=$1
if [ -z "$USER_NAME" ] ; then
  help
  exit 1
fi

export PG_ADMIN_CONSOLE_EMAIL=$2
if [ -z "$PG_ADMIN_CONSOLE_EMAIL" ]; then
  help
  exit 1
fi

CLUSTER_ZONE=$(gcloud config get-value compute/zone)
INSTANCE_REGION=$(gcloud config get-value compute/region)

export CLUSTER_ZONE
if [ -z "$CLUSTER_ZONE" ]; then
  echo "Make sure that compute/zone is set in gcloud config"
  exit 1
fi

export INSTANCE_REGION
if [ -z "$INSTANCE_REGION" ]; then
  echo "Make sure that compute/region is set in gcloud config"
  exit 1
fi

PASSWORD=$3

if [ -z "$PASSWORD" ]; then
  echo "Enter a password for both $USER_NAME and $PG_ADMIN_CONSOLE_EMAIL:"
  read -r PASSWORD
fi

if [ -z "$PASSWORD" ]; then
  echo "Password can't be blank or whitespace"
  exit 1
fi

export USER_PASSWORD=$PASSWORD
export PG_ADMIN_CONSOLE_PASSWORD=$PASSWORD

if [ -z "$PG_ADMIN_CONSOLE_PASSWORD" ]; then
  echo "Enter a password for $PG_ADMIN_CONSOLE_EMAIL"
  read -r PG_ADMIN_CONSOLE_PASSWORD
  export PG_ADMIN_CONSOLE_PASSWORD=$PG_ADMIN_CONSOLE_PASSWORD
fi

if [ -z "$PG_ADMIN_CONSOLE_PASSWORD" ] ; then
  echo "Password can't be blank or whitespace"
  exit 1
fi

ROOT=$(dirname "${BASH_SOURCE[0]}")

if "$ROOT"/scripts/prerequisites.sh; then
  "$ROOT"/scripts/enable_apis.sh
  "$ROOT"/scripts/postgres_instance.sh &
   T1=${!}
  "$ROOT"/scripts/service_account.sh
  "$ROOT"/scripts/cluster.sh &
  T2=${!}
  echo "Waiting for Postgres Instance to finish provisioning"
  wait ${T1}
  echo "Waiting for Cluster to finish provisioning"
  wait ${T2}
  "$ROOT"/scripts/configs_and_secrets.sh
  "$ROOT"/scripts/pgadmin_deployment.sh
fi
EOF

# Step 8: Assign PG_EMAIL
echo "${BOLD}${YELLOW}Assigning PG_EMAIL variable${RESET}"
PG_EMAIL=$(gcloud config get-value account)

# Step 9: Execute create.sh with arguments
echo "${BOLD}${CYAN}Executing create.sh script${RESET}"
chmod +x create.sh
./create.sh dbadmin $PG_EMAIL awesome

# Step 10: Get Pod ID and expose via LoadBalancer
echo "${BOLD}${GREEN}Getting Pod ID and exposing via LoadBalancer${RESET}"
POD_ID=$(kubectl --namespace default get pods -o name | cut -d '/' -f 2)

# Step 11: Expose Pod
echo "${BOLD}${GREEN}Exposing Pod via LoadBalancer${RESET}"
kubectl expose pod $POD_ID --port=80 --type=LoadBalancer

echo "Waiting for pgAdmin service to receive an external IP..."

# Step 12: Wait for external IP
echo "${BOLD}${MAGENTA}Waiting for pgAdmin external IP${RESET}"
EXTERNAL_IP=""

while [ -z "$EXTERNAL_IP" ]; do
  # Get all LoadBalancer services
  SERVICES=$(kubectl get svc --field-selector spec.type=LoadBalancer -o json)

  # Extract IP from services with port 80
  EXTERNAL_IP=$(echo "$SERVICES" | jq -r '
    .items[] 
    | select(.spec.ports[]?.port == 80) 
    | .status.loadBalancer.ingress[0].ip' | grep -v null | head -n1)

  if [ -z "$EXTERNAL_IP" ]; then
    # If no IP is found, wait and retry
    echo "${BOLD}${RED}No external IP found yet, retry in 30 seconds...${RESET}"
    sleep 30
  fi
done

# Step 13: pgAdmin external IP detected
echo "${BOLD}${GREEN}pgAdmin external IP detected${RESET}"

echo

# Function to display a random congratulatory message
function random_congrats() {
    MESSAGES=(
        "${GREEN}Congratulations For Completing The Lab! Keep up the great work!${RESET}"
        "${CYAN}Well done! Your hard work and effort have paid off!${RESET}"
        "${YELLOW}Amazing job! You’ve successfully completed the lab!${RESET}"
        "${BLUE}Outstanding! Your dedication has brought you success!${RESET}"
        "${MAGENTA}Great work! You’re one step closer to mastering this!${RESET}"
        "${RED}Fantastic effort! You’ve earned this achievement!${RESET}"
        "${CYAN}Congratulations! Your persistence has paid off brilliantly!${RESET}"
        "${GREEN}Bravo! You’ve completed the lab with flying colors!${RESET}"
        "${YELLOW}Excellent job! Your commitment is inspiring!${RESET}"
        "${BLUE}You did it! Keep striving for more successes like this!${RESET}"
        "${MAGENTA}Kudos! Your hard work has turned into a great accomplishment!${RESET}"
        "${RED}You’ve smashed it! Completing this lab shows your dedication!${RESET}"
        "${CYAN}Impressive work! You’re making great strides!${RESET}"
        "${GREEN}Well done! This is a big step towards mastering the topic!${RESET}"
        "${YELLOW}You nailed it! Every step you took led you to success!${RESET}"
        "${BLUE}Exceptional work! Keep this momentum going!${RESET}"
        "${MAGENTA}Fantastic! You’ve achieved something great today!${RESET}"
        "${RED}Incredible job! Your determination is truly inspiring!${RESET}"
        "${CYAN}Well deserved! Your effort has truly paid off!${RESET}"
        "${GREEN}You’ve got this! Every step was a success!${RESET}"
        "${YELLOW}Nice work! Your focus and effort are shining through!${RESET}"
        "${BLUE}Superb performance! You’re truly making progress!${RESET}"
        "${MAGENTA}Top-notch! Your skill and dedication are paying off!${RESET}"
        "${RED}Mission accomplished! This success is a reflection of your hard work!${RESET}"
        "${CYAN}You crushed it! Keep pushing towards your goals!${RESET}"
        "${GREEN}You did a great job! Stay motivated and keep learning!${RESET}"
        "${YELLOW}Well executed! You’ve made excellent progress today!${RESET}"
        "${BLUE}Remarkable! You’re on your way to becoming an expert!${RESET}"
        "${MAGENTA}Keep it up! Your persistence is showing impressive results!${RESET}"
        "${RED}This is just the beginning! Your hard work will take you far!${RESET}"
        "${CYAN}Terrific work! Your efforts are paying off in a big way!${RESET}"
        "${GREEN}You’ve made it! This achievement is a testament to your effort!${RESET}"
        "${YELLOW}Excellent execution! You’re well on your way to mastering the subject!${RESET}"
        "${BLUE}Wonderful job! Your hard work has definitely paid off!${RESET}"
        "${MAGENTA}You’re amazing! Keep up the awesome work!${RESET}"
        "${RED}What an achievement! Your perseverance is truly admirable!${RESET}"
        "${CYAN}Incredible effort! This is a huge milestone for you!${RESET}"
        "${GREEN}Awesome! You’ve done something incredible today!${RESET}"
        "${YELLOW}Great job! Keep up the excellent work and aim higher!${RESET}"
        "${BLUE}You’ve succeeded! Your dedication is your superpower!${RESET}"
        "${MAGENTA}Congratulations! Your hard work has brought great results!${RESET}"
        "${RED}Fantastic work! You’ve taken a huge leap forward today!${RESET}"
        "${CYAN}You’re on fire! Keep up the great work!${RESET}"
        "${GREEN}Well deserved! Your efforts have led to success!${RESET}"
        "${YELLOW}Incredible! You’ve achieved something special!${RESET}"
        "${BLUE}Outstanding performance! You’re truly excelling!${RESET}"
        "${MAGENTA}Terrific achievement! Keep building on this success!${RESET}"
        "${RED}Bravo! You’ve completed the lab with excellence!${RESET}"
        "${CYAN}Superb job! You’ve shown remarkable focus and effort!${RESET}"
        "${GREEN}Amazing work! You’re making impressive progress!${RESET}"
        "${YELLOW}You nailed it again! Your consistency is paying off!${RESET}"
        "${BLUE}Incredible dedication! Keep pushing forward!${RESET}"
        "${MAGENTA}Excellent work! Your success today is well earned!${RESET}"
        "${RED}You’ve made it! This is a well-deserved victory!${RESET}"
        "${CYAN}Wonderful job! Your passion and hard work are shining through!${RESET}"
        "${GREEN}You’ve done it! Keep up the hard work and success will follow!${RESET}"
        "${YELLOW}Great execution! You’re truly mastering this!${RESET}"
        "${BLUE}Impressive! This is just the beginning of your journey!${RESET}"
        "${MAGENTA}You’ve achieved something great today! Keep it up!${RESET}"
        "${RED}You’ve made remarkable progress! This is just the start!${RESET}"
    )

    RANDOM_INDEX=$((RANDOM % ${#MESSAGES[@]}))
    echo -e "${BOLD}${MESSAGES[$RANDOM_INDEX]}"
}

# Display a random congratulatory message
random_congrats

echo -e "\n"  # Adding one blank line

cd

remove_files() {
    # Loop through all files in the current directory
    for file in *; do
        # Check if the file name starts with "gsp", "arc", or "shell"
        if [[ "$file" == gsp* || "$file" == arc* || "$file" == shell* ]]; then
            # Check if it's a regular file (not a directory)
            if [[ -f "$file" ]]; then
                # Remove the file and echo the file name
                rm "$file"
                echo "File removed: $file"
            fi
        fi
    done
}

remove_files