#!/usr/bin/env bash

function gitops_odh_help() {
  [[ -n "$1" ]] && echo_warning "$1"
  reset_colors
  cat << EOM
Usage:
  mas gitops_odh [options]

Where ${COLOR_YELLOW}specified${TEXT_RESET} each option may also be defined by setting the appropriate environment variable.
When no options are specified on the command line, interactive-mode will be enabled by default.

GitOps Configuration:
  -d, --dir ${COLOR_YELLOW}GITOPS_WORKING_DIR${TEXT_RESET}           Directory for GitOps repository
  -a, --account-id ${COLOR_YELLOW}ACCOUNT_ID${TEXT_RESET}            Account name that the cluster belongs to
  -r, --region-id ${COLOR_YELLOW}CLUSTER_ID${TEXT_RESET}             Region ID
  -c, --cluster-id ${COLOR_YELLOW}CLUSTER_ID${TEXT_RESET}            Cluster ID
  -m, --aiservice-instance-id ${COLOR_YELLOW}AISERVICE_INSTANCE_ID${TEXT_RESET}  AI Service Instance ID

Secrets Manager:
      --secrets-path ${COLOR_YELLOW}SECRETS_PATH${TEXT_RESET}                    Secrets Manager path
      --secrets-key-seperator ${COLOR_YELLOW}SECRETS_KEY_SEPERATOR${TEXT_RESET}  Secrets Manager key seperator string

ibm aiservice(required):
      --aiservice-namespace ${TEXT_RESET}AISERVICE_NAMESPACE${TEXT_RESET}
      --aiservice-instance-id ${TEXT_RESET}AISERVICE_INSTANCE_ID${TEXT_RESET}

ODH Configuration:
      --odh-channel
      --odh-catalog-source
      --odh-operator-version
      --odh-namespace
      --pull-secret-name
      --opendatahub-name
      --opendatahub-operator-group
      --odh-install-plan
      --opendatahub-channel
      --opendatahub-source
      --opendatahub-source-namespace
      --aiservice-odh-model-deployment-type
Pipeline Configuration:
      --odh-pipeline-name
      --odh-pipeline-namespace
      --odh-pipeline-operator-name
      --odh-pipeline-source
      --odh-pipeline-source-namespace
      --odh-pipeline-channel
      --odh-pipeline-installplan
      --pipeline-catalog-source

Service Mesh:
      --service-mesh-namespace
      --service-mesh-channel
      --service-mesh-catalog-source
      --service-mesh-source-namespace

Serverless:
      --serverless-namespace
      --serverless-channel
      --serverless-operator-name
      --serverless-operator-source
      --serverless-operator-source-namespace

Authorino:
      --authorino-catalog-source

Storage:
      --storage-provider
      --storage-accesskey
      --storage-secretkey
      --storage-host
      --storage-port
      --storage-ssl
      --storage-region
      --pipelines-bucket
      --primary-storage-class

Database:
      --db-host
      --db-port
      --db-user
      --db-database
      --db-secret-name
      --db-secret-value

Automatic GitHub Push:
  -P, --github-push ${COLOR_YELLOW}GITHUB_PUSH${TEXT_RESET}        Enable automatic push to GitHub
  -H, --github-host ${COLOR_YELLOW}GITHUB_HOST${TEXT_RESET}        GitHub Hostname for your GitOps repository
  -O, --github-org  ${COLOR_YELLOW}GITHUB_ORG${TEXT_RESET}         Github org for your GitOps repository
  -R, --github-repo ${COLOR_YELLOW}GITHUB_REPO${TEXT_RESET}        Github repo for your GitOps repository
  -B, --git-branch ${COLOR_YELLOW}GIT_BRANCH${TEXT_RESET}          Git branch to commit to of your GitOps repository
  -M, --git-commit-msg ${COLOR_YELLOW}GIT_COMMIT_MSG${TEXT_RESET}  Git commit message to use when committing to of your GitOps repository
  -S , --github-ssh  ${COLOR_YELLOW}GIT_SSH${TEXT_RESET}           Git ssh key path

Other Commands:
  -h, --help                                      Show this help message
EOM
  [[ -n "$1" ]] && exit 1 || exit 0
}


function gitops_odh_noninteractive() {
  GITOPS_WORKING_DIR=$PWD/working-dir  
  SECRETS_KEY_SEPERATOR="/"
  GIT_COMMIT_MSG="gitops-odh commit"



  export OPENSHIFT_NAMESPACE="${OPENSHIFT_NAMESPACE:-"openshift-operators"}"
  export ODH_PIPELINE_CHANNEL="${ODH_PIPELINE_CHANNEL:-"latest"}"
  export ODH_PIPELINE_INSTALLPLAN="${ODH_PIPELINE_INSTALLPLAN:-"manual"}"
  export PIPELINE_CATALOG_SOURCE="${PIPELINE_CATALOG_SOURCE:-"redhat-operators"}"
  export SERVICE_MESH_NAMESPACE="${SERVICE_MESH_NAMESPACE:-"openshift-operators"}"
  export SERVICE_MESH_CHANNEL="${SERVICE_MESH_CHANNEL:-"stable"}"
  export SERVICE_MESH_CATALOG_SOURCE="${SERVICE_MESH_CATALOG_SOURCE:-"redhat-operators"}"
  export SERVICE_MESH_SOURCENAMESPACE="${SERVICE_MESH_SOURCENAMESPACE:-"openshift-marketplace"}"
  export OPERATOR_NAME="${OPERATOR_NAME:-"openshift-pipelines-operator-rh"}"
  export SERVERLESS_CHANNEL="${SERVERLESS_CHANNEL:-"stable"}"
  export AUTHORINO_CATALOG_SOURCE="${AUTHORINO_CATALOG_SOURCE:-"community-operators"}"
  export ODH_CHANNEL="${ODH_CHANNEL:-"fast"}"
  export ODH_CATALOG_SOURCE="${ODH_CATALOG_SOURCE:-"community-operators"}"
  export ODH_OPERATOR_VERSION="${ODH_OPERATOR_VERSION:-"opendatahub-operator.v2.19.0"}"
  export ODH_NAMESPACE="${ODH_NAMESPACE:-"opendatahub"}"

  export AISERVICE_NAMESPACE="${AISERVICE_NAMESPACE:-"${AISERVICE_INSTANCE_ID}-aiservice"}"

  export SERVERLESS_NAMESPACE="${SERVERLESS_NAMESPACE:-"openshift-serverless"}"
  export SERVERLESS_OPERATOR_NAME="${SERVERLESS_OPERATOR_NAME:-"serverless-operator"}"
  export SERVERLESS_OPERATOR_SOURCE="${SERVERLESS_OPERATOR_SOURCE:-"redhat-operators"}"
  export SERVERLESS_OPERATOR_SOURCE_NAMESPACE="${SERVERLESS_OPERATOR_SOURCE_NAMESPACE:-"openshift-marketplace"}"

  export OPENDATAHUB_OPERATORGROUP_NAME="${OPENDATAHUB_OPERATORGROUP_NAME:-"opendatahub-operator-group"}"
  export OPENDATAHUB_NAME="${OPENDATAHUB_NAME:-"opendatahub-operator"}"
  export OPENDATAHUB_NAMESPACE="${OPENDATAHUB_NAMESPACE:-"opendatahub"}"
  export ODH_INSTALL_PLAN="${ODH_INSTALL_PLAN:-"Automatic"}"
  export OPENDATAHUB_CHANNEL="${OPENDATAHUB_CHANNEL:-"fast"}"
  export OPENDATAHUB_SOURCE="${OPENDATAHUB_SOURCE:-"community-operators"}"
  export OPENDATAHUB_SOURCE_NAMESPACE="${OPENDATAHUB_SOURCE_NAMESPACE:-"openshift-marketplace"}"
  export AISERVICE_STORAGE_PROVIDER="${AISERVICE_STORAGE_PROVIDER:-"aws"}"
  export AISERVICE_STORAGE_SSL="${AISERVICE_STORAGE_SSL:-"true"}"
  export AISERVICE_STORAGE_REGION="${AISERVICE_STORAGE_REGION:-""}"
  export PRIMARY_STORAGE_CLASS="${PRIMARY_STORAGE_CLASS:-"nfs-client"}"
  export AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE="${AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE:-"serverless"}"


  while [[ $# -gt 0 ]]; do
    key="$1"; shift
    case $key in
      -d|--dir) export GITOPS_WORKING_DIR="$1"; shift ;;
      -a|--account-id) export ACCOUNT_ID="$1"; shift ;;
      -c|--cluster-id) export CLUSTER_ID="$1"; shift ;;
      -m|--aiservice-instance-id) export AISERVICE_INSTANCE_ID="$1"; shift ;;

      # AWS Secrets Manager Configuration
      --sm-aws-secret-region)
        export SM_AWS_REGION=$1
        export REGION_ID=$1
        shift
        ;;
      --sm-aws-access-key)
        export SM_AWS_ACCESS_KEY_ID=$1 && shift
        ;;
      --sm-aws-secret-key)
        export SM_AWS_SECRET_ACCESS_KEY=$1 && shift
        ;;
      --secrets-path)
        export SECRETS_PATH=$1 && shift
        ;;

            # Automatic GitHub Push
      -P|--github-push)
        export GITHUB_PUSH=true
        ;;
      -H|--github-host)
        export GITHUB_HOST=$1 && shift
        ;;
      -O|--github-org)
        export GITHUB_ORG=$1 && shift
        ;;
      -R|--github-repo)
        export GITHUB_REPO=$1 && shift
        ;;
      -S|--github-ssh)
        export GIT_SSH=$1 && shift
        ;;
      -B|--git-branch)
        export GIT_BRANCH=$1 && shift
        ;;
      -M|--git-commit-msg)
        export GIT_COMMIT_MSG=$1 && shift
        ;;


      --odh-channel)
        export ODH_CHANNEL=$1 && shift
        ;;
      --odh-catalog-source)
        export ODH_CATALOG_SOURCE=$1 && shift
        ;;
      --odh-operator-version)
        export ODH_OPERATOR_VERSION=$1 && shift
        ;;
      --odh-namespace)
        export ODH_NAMESPACE=$1 && shift
        ;;
      --openshift-namespace)
        export OPENSHIFT_NAMESPACE=$1 && shift
        ;;
      --pull-secret-name)
        export PULL_SECRET_NAME=$1 && shift
        ;;

      --opendatahub-name)
        export OPENDATAHUB_NAME=$1 && shift
        ;;
      --opendatahub-operator-group)
        export OPENDATAHUB_OPERATORGROUP_NAME=$1 && shift
        ;;
      --odh-install-plan)
        export ODH_INSTALL_PLAN=$1 && shift
        ;;
      --opendatahub-channel)
        export OPENDATAHUB_CHANNEL=$1 && shift
        ;;
      --opendatahub-source)
        export OPENDATAHUB_SOURCE=$1 && shift
        ;;
      --opendatahub-namespace)
        export OPENDATAHUB_NAMESPACE=$1 && shift
        ;;
      --opendatahub-source-namespace)
        export OPENDATAHUB_SOURCE_NAMESPACE=$1 && shift
        ;;
      --odh-pipeline-channel)
        export ODH_PIPELINE_CHANNEL=$1 && shift
        ;;
      --odh-pipeline-installplan)
        export ODH_PIPELINE_INSTALLPLAN=$1 && shift
        ;;
      --pipeline-catalog-source)
        export PIPELINE_CATALOG_SOURCE=$1 && shift
        ;;

      --service-mesh-namespace)
        export SERVICE_MESH_NAMESPACE=$1 && shift
        ;;
      --service-mesh-channel)
        export SERVICE_MESH_CHANNEL=$1 && shift
        ;;
      --service-mesh-catalog-source)
        export SERVICE_MESH_CATALOG_SOURCE=$1 && shift
        ;;
      --service-mesh-source-namespace)
        export SERVICE_MESH_SOURCE_NAMESPACE=$1 && shift
        ;;

      --serverless-namespace)
        export SERVERLESS_NAMESPACE=$1 && shift
        ;;
      --serverless-channel)
        export SERVERLESS_CHANNEL=$1 && shift
        ;;
      --serverless-operator-name)
        export SERVERLESS_OPERATOR_NAME=$1 && shift
        ;;
      --serverless-operator-source)
        export SERVERLESS_OPERATOR_SOURCE=$1 && shift
        ;;
      --serverless-operator-source-namespace)
        export SERVERLESS_OPERATOR_SOURCE_NAMESPACE=$1 && shift
        ;;

      --authorino-catalog-source)
        export AUTHORINO_CATALOG_SOURCE=$1 && shift
        ;;

      --aiservice-namespace)
        export AISERVICE_NAMESPACE=$1 && shift
        ;;

      --storage-provider)
        export AISERVICE_STORAGE_PROVIDER=$1 && shift
        ;;
      --storage-ssl)
        export AISERVICE_STORAGE_SSL=$1 && shift
        ;;
      --storage-region)
        export AISERVICE_STORAGE_REGION=$1 && shift
        ;;
      --aiservice-odh-model-deployment-type)
        export AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE=$1 && shift
        ;;
      --primary-storage-class)
        export PRIMARY_STORAGE_CLASS=$1 && shift
        ;;

      --operator-name)
        export OPERATOR_NAME=$1 && shift
        ;;

      # GitHub
      -P|--github-push) export GITHUB_PUSH=true ;;
      -H|--github-host) export GITHUB_HOST="$1"; shift ;;
      -O|--github-org) export GITHUB_ORG="$1"; shift ;;
      -R|--github-repo) export GITHUB_REPO="$1"; shift ;;
      -B|--git-branch) export GIT_BRANCH="$1"; shift ;;
      -M|--git-commit-msg) export GIT_COMMIT_MSG="$1"; shift ;;
      -S|--github-ssh) export GIT_SSH="$1"; shift ;;

      -h|--help) gitops_odh_help ;;
      *) gitops_odh_help "Unknown option $key" ;;
    esac
  done

  [[ -z "$GITOPS_WORKING_DIR" ]] && gitops_odh_help "Missing GITOPS_WORKING_DIR"
  [[ -z "$ACCOUNT_ID" ]] && gitops_odh_help "Missing ACCOUNT_ID"
  [[ -z "$CLUSTER_ID" ]] && gitops_odh_help "Missing CLUSTER_ID"
  [[ -z "$AISERVICE_INSTANCE_ID" ]] && gitops_odh_help "Missing AISERVICE_INSTANCE_ID"
  [[ -z "$OPENDATAHUB_SOURCE" ]] && gitops_odh_help "Missing OPENDATAHUB_SOURCE"
  [[ -z "$AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE" ]] && gitops_odh_help "Missing AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE"

  if [[ "$GITHUB_PUSH" == "true" ]]; then
    [[ -z "$GITHUB_HOST" ]] && gitops_odh_help "GITHUB_HOST is not set"
    [[ -z "$GITHUB_ORG" ]] && gitops_odh_help "GITHUB_ORG is not set"
    [[ -z "$GITHUB_REPO" ]] && gitops_odh_help "GITHUB_REPO is not set"
    [[ -z "$GIT_BRANCH" ]] && gitops_odh_help "GIT_BRANCH is not set"
  fi

}

function gitops_odh() {
  # Remove the subcommand (e.g., "create-gitops")
  shift
  if [[ $# -gt 0 ]]; then
    gitops_odh_noninteractive "$@"
  else
    echo "Interactive mode not implemented."
    exit 1
  fi

  # Error trap
  set -o pipefail
  trap 'echo "[ERROR] Error occurred at $BASH_SOURCE, line $LINENO, exited with $?"; exit 1' ERR

  # Prepare directories
  rm -rf "$GITOPS_WORKING_DIR"
  mkdir -p "${GITOPS_WORKING_DIR}"
  GITOPS_CLUSTER_DIR=${GITOPS_WORKING_DIR}/${GITHUB_REPO}/${ACCOUNT_ID}/${CLUSTER_ID}/${AISERVICE_INSTANCE_ID}
  

  echo
  echo_h2 "Review Settings"
  echo "${TEXT_DIM}"
  echo_h2 "Target"
  echo_reset_dim "Account ID ............................ ${COLOR_MAGENTA}${ACCOUNT_ID}"
  echo_reset_dim "Cluster ID ............................ ${COLOR_MAGENTA}${CLUSTER_ID}"
  echo_reset_dim "AI Service Instance ID ................ ${COLOR_MAGENTA}${AISERVICE_INSTANCE_ID}"
  echo_reset_dim "OpenDataHub Source ................... ${COLOR_MAGENTA}${OPENDATAHUB_SOURCE}"
  echo_reset_dim "AiService Model Deployment Type ...... ${COLOR_MAGENTA}${AISERVICE_ODH_MODEL_DEPLOYMENT_TYPE}"
  echo_reset_dim "Secrets Path .......................... ${COLOR_MAGENTA}${SECRETS_PATH}"
  reset_colors

  CURRENT_DIR=$PWD
  
  AVP_TYPE=aws
  sm_login

  # Set up secret key and fetch secret
  export SECRET_ACCOUNT_PATH="${ACCOUNT_ID}${SECRETS_KEY_SEPERATOR}${CLUSTER_ID}${SECRETS_KEY_SEPERATOR}"
  export ODH_SECRET="${ACCOUNT_ID}${SECRETS_KEY_SEPERATOR}${CLUSTER_ID}${SECRETS_KEY_SEPERATOR}storage"
  export SECRET_KEY_IMAGE_PULL_SECRET_B64="${SECRET_ACCOUNT_PATH}ibm_entitlement#image_pull_secret_b64"

  if [ -z $GIT_SSH ]; then
    export GIT_SSH=false
  fi

  sm_verify_secret_exists ${ACCOUNT_ID}${SECRETS_KEY_SEPERATOR}${CLUSTER_ID}${SECRETS_KEY_SEPERATOR}ibm_entitlement "image_pull_secret_b64"

  echo_h2 "ODH Secret Summary"
  echo_reset_dim "AI Service Namespace ................... ${COLOR_MAGENTA}${AISERVICE_NAMESPACE}"
  echo_reset_dim "STORAGE_HOST ............................. ${COLOR_MAGENTA}${STORAGE_HOST}"
  echo_reset_dim "STORAGE_BUCKET ........................... ${COLOR_MAGENTA}${STORAGE_BUCKET}"

  echo_reset_dim "AISERVICE_STORAGE_SSL ................. ${COLOR_MAGENTA}${AISERVICE_STORAGE_SSL}"
  reset_colors


  # Clone github target repo
  # ---------------------------------------------------------------------------
  if [ "$GITHUB_PUSH" == "true" ]; then
    echo "GITOPS_WORKING_DIR  ${GITOPS_WORKING_DIR}"
    echo "GITOPS_CLUSTER_DIR  ${GITOPS_CLUSTER_DIR}"
    echo_h2 "Cloning GitHub repo $GITHUB_ORG $GITHUB_REPO"
    clone_target_git_repo $GITHUB_HOST $GITHUB_ORG $GITHUB_REPO $GIT_BRANCH $GITOPS_WORKING_DIR $GIT_SSH
  fi

  mkdir -p ${GITOPS_CLUSTER_DIR}
  # Render YAML
  echo_h2 "Generating OpenDataHub GitOps YAML"
  echo "${GITOPS_CLUSTER_DIR}"
  echo "Output: ${GITOPS_CLUSTER_DIR}/ibm-mas-odh-install.yaml"

  jinjanate_commmon $CLI_DIR/templates/gitops/appset-configs/cluster/instance/ibm-mas-odh-install.yaml.j2 ${GITOPS_CLUSTER_DIR}/ibm-mas-odh-install.yaml
  TAGS="[{\"Key\": \"source\", \"Value\": \"gitops_odh\"}, {\"Key\": \"account\", \"Value\": \"${ACCOUNT_ID}\"}, {\"Key\": \"cluster\", \"Value\": \"${CLUSTER_ID}\"}]"

  # GitHub push
  if [[ "$GITHUB_PUSH" == "true" ]]; then
    echo_h2 "Pushing changes to GitHub"
    echo "Github push" "$GITHUB_HOST" "$GITHUB_ORG" "$GITHUB_REPO" "$GIT_BRANCH" "Working: " "${GITOPS_WORKING_DIR}/${GITHUB_REPO}" " Commit :" "$GIT_COMMIT_MSG"
    save_to_target_git_repo "$GITHUB_HOST" "$GITHUB_ORG" "$GITHUB_REPO" "$GIT_BRANCH" "${GITOPS_WORKING_DIR}/${GITHUB_REPO}" "$GIT_COMMIT_MSG"
    remove_git_repo_clone "${GITOPS_WORKING_DIR}/${GITHUB_REPO}"
  fi

  echo_h2 "ODH GitOps completed."
}
