#!/usr/bin/env bash
# zebra_day activation entrypoint.
#
# Source from the repository root:
#   source ./activate <deploy-name>

if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    echo "Error: this script must be sourced, not executed."
    echo "Usage: source ./activate <deploy-name>"
    exit 1
fi

_zday_script_path() {
    if [[ -n "${ZSH_VERSION:-}" ]]; then
        printf '%s\n' "${(%):-%x}"
    elif [[ -n "${BASH_SOURCE[0]:-}" ]]; then
        printf '%s\n' "${BASH_SOURCE[0]}"
    else
        printf '%s\n' "$0"
    fi
}

_ZDAY_SCRIPT_PATH="$(_zday_script_path)"
ZEBRA_DAY_PROJECT_ROOT="$(cd "$(dirname "${_ZDAY_SCRIPT_PATH}")" && pwd)"
unset -f _zday_script_path
unset _ZDAY_SCRIPT_PATH

_GREEN='\033[0;32m'
_YELLOW='\033[1;33m'
_BLUE='\033[0;34m'
_CYAN='\033[0;36m'
_NC='\033[0m'
_ZDAY_ENV_BASE="ZEBRA_DAY"
_ZDAY_PYTHON=""
_ZDAY_ENV_FILE="${ZEBRA_DAY_PROJECT_ROOT}/environment.yaml"
_ZDAY_WORKSPACE_ROOT="$(cd "${ZEBRA_DAY_PROJECT_ROOT}/../.." && pwd)"
_ZDAY_DAYLILY_TAPDB_ROOT="${_ZDAY_WORKSPACE_ROOT}/daylily/daylily-tapdb"
_ZDAY_DAYLILY_AUTH_COGNITO_ROOT="${_ZDAY_WORKSPACE_ROOT}/daylily-auth-cognito"
_ZDAY_CLI_CORE_YO_VERSION="2.0.0"

_zday_sanitize_deployment_code() {
    local raw_value="$1"
    local sanitized=""
    sanitized="$(printf '%s' "$raw_value" | LC_ALL=C sed -E 's/[^A-Za-z0-9-]+/-/g; s/^-+//; s/-+$//')"
    if [[ -z "$sanitized" ]]; then
        sanitized="local"
    fi
    printf '%s\n' "$sanitized"
}

_zday_validate_deploy_name() {
    local deploy_name="$1"
    if [[ ! "$deploy_name" =~ ^[A-Za-z0-9-]{2,24}$ ]]; then
        echo -e "  ${_YELLOW}✗${_NC} deploy-name must match ^[A-Za-z0-9-]{2,24}$"
        return 1
    fi
}

_zday_config_path() {
    local xdg_config_home="${XDG_CONFIG_HOME:-$HOME/.config}"
    local deployment_code="$1"
    printf '%s/zebra_day/zebra-day-config-%s.yaml\n' "$xdg_config_home" "$deployment_code"
}

_zday_tapdb_config_path() {
    local deployment_code="$1"
    local client_id="$2"
    local xdg_config_home="${XDG_CONFIG_HOME:-$HOME/.config}"
    printf '%s/tapdb/%s/zebra-day-%s/tapdb-config.yaml\n' "$xdg_config_home" "$client_id" "$deployment_code"
}

_zday_tapdb_template_path() {
    local deployment_code="$1"
    local database_name="$2"
    local config_dir="${ZEBRA_DAY_PROJECT_ROOT}/config"
    local primary="${config_dir}/tapdb-config-${database_name}.yaml"
    if [[ -f "$primary" ]]; then
        printf '%s\n' "$primary"
        return 0
    fi
    local suffix="-${deployment_code}"
    if [[ "$database_name" == *"$suffix" ]]; then
        local base_name="${database_name%"$suffix"}"
        local fallback="${config_dir}/tapdb-config-${base_name}.yaml"
        if [[ -f "$fallback" ]]; then
            printf '%s\n' "$fallback"
            return 0
        fi
    fi
    return 1
}

_zday_prepare_tapdb_config_path() {
    local deployment_code="$1"
    local client_id="$2"
    local database_name="$3"
    local user_path="$(_zday_tapdb_config_path "$deployment_code" "$client_id")"
    if [[ -f "$user_path" ]]; then
        chmod 600 "$user_path" 2>/dev/null || true
        printf '%s\n' "$user_path"
        return 0
    fi

    local template_path=""
    template_path="$(_zday_tapdb_template_path "$deployment_code" "$database_name" 2>/dev/null || true)"
    if [[ -n "$template_path" && -f "$template_path" ]]; then
        mkdir -p "$(dirname "${user_path}")" || return 1
        cp "$template_path" "$user_path" || return 1
        chmod 600 "$user_path" || return 1
    fi
    printf '%s\n' "$user_path"
}

_zday_ensure_postgres_runtime() {
    if command -v initdb >/dev/null 2>&1 && command -v pg_ctl >/dev/null 2>&1; then
        return 0
    fi
    echo -e "  ${_CYAN}→${_NC} Installing PostgreSQL runtime into ${_ZDAY_ENV_NAME}"
    conda install -y -n "${_ZDAY_ENV_NAME}" -c conda-forge postgresql || return 1
    if [[ -n "${CONDA_PREFIX:-}" ]] && [[ -d "${CONDA_PREFIX}/bin" ]]; then
        export PATH="${CONDA_PREFIX}/bin:$PATH"
        hash -r 2>/dev/null || true
    fi
    command -v initdb >/dev/null 2>&1 && command -v pg_ctl >/dev/null 2>&1
}

_zday_require_python_import() {
    local module_name="$1"
    local package_name="$2"
    if "${_ZDAY_PYTHON:-python}" -c "import importlib.util, sys; sys.exit(0 if importlib.util.find_spec('${module_name}') else 1)" >/dev/null 2>&1; then
        return 0
    fi
    echo -e "  ${_YELLOW}✗${_NC} Missing Python package: ${package_name}"
    return 1
}

_zday_distribution_is_editable_from_repo() {
    local dist_name="$1"
    local repo_root="$2"
    local pip_show_output=""
    local editable_project_location=""
    pip_show_output="$("${_ZDAY_PYTHON:-python}" -m pip show "$dist_name" 2>/dev/null || true)"
    if [[ -z "$pip_show_output" ]]; then
        return 2
    fi
    editable_project_location="$(printf '%s\n' "$pip_show_output" | awk -F': ' '$1 == "Editable project location" { print $2; exit }')"
    if [[ -z "$editable_project_location" ]]; then
        return 2
    fi
    editable_project_location="$(cd "$editable_project_location" 2>/dev/null && pwd)"
    if [[ -z "$editable_project_location" ]]; then
        return 1
    fi
    if [[ "$editable_project_location" != "$repo_root" ]]; then
        return 1
    fi
    return 0
}

_zday_distribution_version_is() {
    local dist_name="$1"
    local expected="$2"
    "${_ZDAY_PYTHON:-python}" -c "from importlib.metadata import version; import sys; sys.exit(0 if version('${dist_name}') == '${expected}' else 1)" >/dev/null 2>&1
}

_zday_ensure_editable_repo() {
    local label="$1"
    local module_name="$2"
    local repo_root="$3"
    local dist_name="$4"
    if [[ -z "$repo_root" ]] || [[ ! -d "$repo_root" ]]; then
        echo -e "  ${_YELLOW}✗${_NC} Missing local ${label} checkout: ${repo_root}"
        return 1
    fi
    if _zday_distribution_is_editable_from_repo "$dist_name" "$repo_root"; then
        echo -e "  ${_GREEN}✓${_NC} Using local ${label} checkout: ${repo_root}"
        return 0
    fi
    echo -e "  ${_CYAN}→${_NC} Installing local ${label} checkout..."
    if ! "${_ZDAY_PYTHON:-python}" -m pip install -e "$repo_root" -q; then
        echo -e "  ${_YELLOW}✗${_NC} Failed to install local ${label} checkout from ${repo_root}"
        return 1
    fi
    if ! _zday_distribution_is_editable_from_repo "$dist_name" "$repo_root"; then
        echo -e "  ${_YELLOW}✗${_NC} ${label} is not installed editable from ${repo_root}"
        return 1
    fi
    _zday_require_python_import "$module_name" "$dist_name" || return 1
    echo -e "  ${_GREEN}✓${_NC} Using local ${label} checkout: ${repo_root}"
}

if [[ "$#" -ne 1 ]]; then
    echo -e "  ${_YELLOW}✗${_NC} zebra_day activation requires exactly one deploy-name."
    echo "Usage: source ./activate <deploy-name>"
    return 1
fi

_zday_deployment_code="$1"
if ! _zday_validate_deploy_name "${_zday_deployment_code}"; then
    return 1
fi
_zday_deployment_code="$(_zday_sanitize_deployment_code "${_zday_deployment_code}")"
export ZEBRA_DAY_DEPLOYMENT_CODE="${_zday_deployment_code}"
export DEPLOYMENT_CODE="${_zday_deployment_code}"
export LSMC_DEPLOYMENT_CODE="${_zday_deployment_code}"
export ZEBRA_DAY_PROJECT_ROOT
export ZDAY_PROJECT_ROOT="${ZEBRA_DAY_PROJECT_ROOT}"
export ZEBRA_DAY_ACTIVE=1
_ZDAY_ENV_NAME="${_ZDAY_ENV_BASE}-${_zday_deployment_code}"
_ZDAY_TAPDB_CLIENT_ID="zebra-day"
_ZDAY_TAPDB_DATABASE_NAME="zebra-day-${_zday_deployment_code}"
_ZDAY_TAPDB_ENV="dev"
_ZDAY_TAPDB_CONFIG_PATH="$(_zday_prepare_tapdb_config_path "${_zday_deployment_code}" "${_ZDAY_TAPDB_CLIENT_ID}" "${_ZDAY_TAPDB_DATABASE_NAME}")"
export ZEBRA_DAY_CONFIG_PATH="${ZEBRA_DAY_CONFIG_PATH:-$(_zday_config_path "${_zday_deployment_code}")}"

echo -e "${_BLUE}Activating zebra_day environment...${_NC}"

if ! command -v conda >/dev/null 2>&1; then
    echo -e "  ${_YELLOW}✗${_NC} conda is required for zebra_day activation."
    return 1
fi

source "$(conda info --base)/etc/profile.d/conda.sh" 2>/dev/null || true

if conda info --envs | grep -q "${_ZDAY_ENV_NAME}"; then
    echo -e "  ${_GREEN}✓${_NC} Activating conda environment: ${_ZDAY_ENV_NAME}"
else
    echo -e "  ${_CYAN}→${_NC} Creating conda environment: ${_ZDAY_ENV_NAME}"
    conda env create -n "${_ZDAY_ENV_NAME}" -f "${_ZDAY_ENV_FILE}" || return 1
fi

conda activate "${_ZDAY_ENV_NAME}" || return 1

if [[ "${CONDA_DEFAULT_ENV:-}" != "${_ZDAY_ENV_NAME}" ]]; then
    echo -e "  ${_YELLOW}✗${_NC} Failed to activate ${_ZDAY_ENV_NAME}"
    return 1
fi

if [[ -n "${CONDA_PREFIX:-}" ]] && [[ -d "${CONDA_PREFIX}/bin" ]]; then
    export PATH="${CONDA_PREFIX}/bin:$PATH"
    _ZDAY_PYTHON="${CONDA_PREFIX}/bin/python"
else
    _ZDAY_PYTHON="python"
fi

if [[ ! -x "${_ZDAY_PYTHON}" ]]; then
    echo -e "  ${_YELLOW}✗${_NC} Missing python interpreter in ${CONDA_PREFIX:-<unset>}"
    return 1
fi

_zday_ensure_postgres_runtime || {
    echo -e "  ${_YELLOW}✗${_NC} PostgreSQL runtime tools are required (initdb, pg_ctl)"
    return 1
}

echo -e "  ${_CYAN}→${_NC} Installing zebra_day editable checkout"
"${_ZDAY_PYTHON}" -m pip install -e "${ZEBRA_DAY_PROJECT_ROOT}" -q || return 1

if ! _zday_ensure_editable_repo \
    "daylily-tapdb" \
    "daylily_tapdb" \
    "${_ZDAY_DAYLILY_TAPDB_ROOT}" \
    "daylily-tapdb"; then
    return 1
fi
if ! _zday_ensure_editable_repo \
    "daylily-auth-cognito" \
    "daylily_auth_cognito" \
    "${_ZDAY_DAYLILY_AUTH_COGNITO_ROOT}" \
    "daylily-auth-cognito"; then
    return 1
fi
if ! _zday_distribution_version_is "cli-core-yo" "${_ZDAY_CLI_CORE_YO_VERSION}"; then
    echo -e "  ${_CYAN}→${_NC} Installing published cli-core-yo ${_ZDAY_CLI_CORE_YO_VERSION}..."
    "${_ZDAY_PYTHON}" -m pip install "cli-core-yo==${_ZDAY_CLI_CORE_YO_VERSION}" -q || return 1
fi
_zday_require_python_import "cli_core_yo" "cli-core-yo" || return 1

mkdir -p "$(dirname "${ZEBRA_DAY_CONFIG_PATH}")" || return 1
mkdir -p "$(dirname "${_ZDAY_TAPDB_CONFIG_PATH}")" || return 1

hash -r 2>/dev/null || true

echo -e "  ${_GREEN}✓${_NC} Deployment: ${_zday_deployment_code}"
echo -e "  ${_GREEN}✓${_NC} CONDA_DEFAULT_ENV=${CONDA_DEFAULT_ENV}"
echo -e "  ${_GREEN}✓${_NC} Config path: ${ZEBRA_DAY_CONFIG_PATH}"
echo -e "  ${_GREEN}✓${_NC} TapDB config path: ${_ZDAY_TAPDB_CONFIG_PATH}"
echo -e "  ${_GREEN}✓${_NC} Runtime namespace: ${_ZDAY_TAPDB_CLIENT_ID}/${_ZDAY_TAPDB_DATABASE_NAME}"
echo
echo "  Next:"
echo "    zday config init"
echo "    zday config status"
echo "    zday gui start"

unset _zday_deployment_code
unset _ZDAY_ENV_NAME
unset _ZDAY_PYTHON
