#!/usr/bin/env bash
# =============================================================================
# BLOOM LIMS - Environment Activation Script (TapDB runtime)
# =============================================================================

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

_bloom_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
}

_BLOOM_SCRIPT_PATH="$(_bloom_script_path)"
BLOOM_ROOT="$(cd "$(dirname "${_BLOOM_SCRIPT_PATH}")" && pwd)"
unset -f _bloom_script_path
unset _BLOOM_SCRIPT_PATH

_GREEN='\033[0;32m'
_YELLOW='\033[1;33m'
_BLUE='\033[0;34m'
_CYAN='\033[0;36m'
_NC='\033[0m'
_BLOOM_PYTHON=""

_bloom_resolve_local_repo() {
    local module_dir="$1"
    shift
    local candidate=""
    local candidate_path=""
    local fallback=""
    for candidate in "$@"; do
        [[ -d "$candidate" ]] || continue
        candidate_path="$(cd "$candidate" 2>/dev/null && pwd)"
        [[ -n "$candidate_path" ]] || continue
        [[ -d "${candidate_path}/${module_dir}" ]] || continue
        if [[ -d "${candidate_path}/.git" ]]; then
            printf '%s\n' "$candidate_path"
            return 0
        fi
        if [[ -z "$fallback" ]]; then
            fallback="$candidate_path"
        fi
    done
    [[ -n "$fallback" ]] && printf '%s\n' "$fallback"
}

_bloom_module_is_from_repo() {
    local module_name="$1"
    local repo_root="$2"
    "${_BLOOM_PYTHON:-python}" - "$module_name" "$repo_root" <<'PY' >/dev/null 2>&1
import importlib
import pathlib
import sys

module = importlib.import_module(sys.argv[1])
repo_root = pathlib.Path(sys.argv[2]).resolve()
module_file = getattr(module, "__file__", "")
if not module_file:
    raise SystemExit(1)
module_path = pathlib.Path(module_file).resolve()
raise SystemExit(0 if module_path == repo_root or repo_root in module_path.parents else 1)
PY
}

_bloom_ensure_editable_repo() {
    local label="$1"
    local module_name="$2"
    local repo_root="$3"
    local extras="${4:-}"
    local install_target=""
    if [[ -z "$repo_root" ]]; then
        return 0
    fi
    if _bloom_module_is_from_repo "$module_name" "$repo_root"; then
        echo -e "  ${_GREEN}✓${_NC} Using local ${label} checkout: ${repo_root}"
        return 0
    fi
    install_target="${repo_root}${extras}"
    echo -e "  ${_CYAN}→${_NC} Installing local ${label} checkout..."
    if ! "${_BLOOM_PYTHON:-python}" -m pip install --no-deps -e "$install_target" -q; then
        echo -e "  ${_YELLOW}⚠${_NC} Failed to install local ${label} checkout from ${repo_root}"
        return 1
    fi
    if ! _bloom_module_is_from_repo "$module_name" "$repo_root"; then
        echo -e "  ${_YELLOW}⚠${_NC} ${label} still resolves outside ${repo_root}"
        return 1
    fi
    echo -e "  ${_GREEN}✓${_NC} Using local ${label} checkout: ${repo_root}"
}

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

if command -v conda &> /dev/null; then
    if [[ -n "${ZSH_VERSION:-}" ]]; then
        eval "$(conda shell.zsh hook)" 2>/dev/null || true
    elif [[ -n "${BASH_VERSION:-}" ]]; then
        eval "$(conda shell.bash hook)" 2>/dev/null || true
    else
        source "$(conda info --base)/etc/profile.d/conda.sh" 2>/dev/null || true
    fi

    if conda info --envs | grep -q "^BLOOM "; then
        echo -e "  ${_GREEN}✓${_NC} Activating conda environment: BLOOM"
        conda activate BLOOM
        if [[ -n "$CONDA_PREFIX" ]] && [[ -d "$CONDA_PREFIX/bin" ]]; then
            export PATH="$CONDA_PREFIX/bin:$PATH"
        fi
    else
        echo -e "  ${_YELLOW}⚠${_NC} Conda environment 'BLOOM' not found."
        if [[ -f "$BLOOM_ROOT/bloom_env.yaml" ]]; then
            echo -e "  ${_CYAN}→${_NC} Installing conda environment from bloom_env.yaml..."
            if conda env create -f "$BLOOM_ROOT/bloom_env.yaml"; then
                echo -e "  ${_GREEN}✓${_NC} Conda environment created successfully"
                conda activate BLOOM
                if [[ -n "$CONDA_PREFIX" ]] && [[ -d "$CONDA_PREFIX/bin" ]]; then
                    export PATH="$CONDA_PREFIX/bin:$PATH"
                fi
            else
                echo -e "  ${_YELLOW}⚠${_NC} Failed to create conda environment."
            fi
        else
            echo -e "  ${_YELLOW}⚠${_NC} bloom_env.yaml not found."
        fi
    fi
else
    echo -e "  ${_YELLOW}⚠${_NC} Conda not found."
    return 1
fi

if [[ "${CONDA_DEFAULT_ENV:-}" != "BLOOM" ]] || [[ -z "${CONDA_PREFIX:-}" ]] || [[ ! -x "${CONDA_PREFIX}/bin/python" ]]; then
    echo -e "  ${_YELLOW}⚠${_NC} BLOOM conda environment is required."
    echo -e "  ${_CYAN}→${_NC} Run 'conda env create -f bloom_env.yaml' if needed, then retry 'source ./activate'."
    return 1
fi

_BLOOM_PYTHON="${CONDA_PREFIX}/bin/python"
_BLOOM_PYTHON_BIN="$(dirname "${_BLOOM_PYTHON}")"
export PATH="${_BLOOM_PYTHON_BIN}:$PATH"

if ! _bloom_ensure_editable_repo "Bloom" "bloom_lims" "$BLOOM_ROOT"; then
    return 1
fi

_BLOOM_TAPDB_REPO="$(_bloom_resolve_local_repo \
    daylily_tapdb \
    "$BLOOM_ROOT/../daylily-tapdb" \
    "$BLOOM_ROOT/../lims_repos/daylily-tapdb"
)"
if ! _bloom_ensure_editable_repo "daylily-tapdb" "daylily_tapdb" "${_BLOOM_TAPDB_REPO:-}" "[cli,admin,aurora,dev]"; then
    return 1
fi

_BLOOM_DAYCOG_REPO="$(_bloom_resolve_local_repo \
    daylily_cognito \
    "$BLOOM_ROOT/../daylily-cognito" \
    "$BLOOM_ROOT/../lims_repos/daylily-cognito"
)"
if ! _bloom_ensure_editable_repo "daylily-cognito" "daylily_cognito" "${_BLOOM_DAYCOG_REPO:-}"; then
    return 1
fi

_BLOOM_CLI_CORE_REPO="$(_bloom_resolve_local_repo \
    cli_core_yo \
    "$BLOOM_ROOT/../cli-core-yo" \
    "$BLOOM_ROOT/../lims_repos/cli-core-yo"
)"
if ! _bloom_ensure_editable_repo "cli-core-yo" "cli_core_yo" "${_BLOOM_CLI_CORE_REPO:-}"; then
    return 1
fi

if command -v rehash >/dev/null 2>&1; then
    rehash
elif command -v hash >/dev/null 2>&1; then
    hash -r 2>/dev/null || true
fi

if [[ "$-" == *i* ]]; then
    if [[ -n "${ZSH_VERSION:-}" ]]; then
        if eval "$(_BLOOM_COMPLETE=zsh_source bloom 2>/dev/null)" 2>/dev/null; then
            echo -e "  ${_GREEN}✓${_NC} Enabled tab completion for 'bloom' (zsh)"
        fi
    elif [[ -n "${BASH_VERSION:-}" ]]; then
        if eval "$(_BLOOM_COMPLETE=bash_source bloom 2>/dev/null)" 2>/dev/null; then
            echo -e "  ${_GREEN}✓${_NC} Enabled tab completion for 'bloom' (bash)"
        fi
    fi
fi

# TapDB/AWS runtime defaults for BLOOM
export TAPDB_ENV="${TAPDB_ENV:-dev}"
export TAPDB_CLIENT_ID="${TAPDB_CLIENT_ID:-bloom}"
export TAPDB_DATABASE_NAME="${TAPDB_DATABASE_NAME:-bloom}"
export TAPDB_STRICT_NAMESPACE="${TAPDB_STRICT_NAMESPACE:-1}"
export MERIDIAN_ENVIRONMENT="${MERIDIAN_ENVIRONMENT:-production}"
export MERIDIAN_SANDBOX_PREFIX="${MERIDIAN_SANDBOX_PREFIX-}"
export BLOOM_TAPDB_LOCAL_PG_PORT="${BLOOM_TAPDB_LOCAL_PG_PORT:-5566}"
export TAPDB_DEV_PORT="${TAPDB_DEV_PORT:-$BLOOM_TAPDB_LOCAL_PG_PORT}"
export TAPDB_TEST_PORT="${TAPDB_TEST_PORT:-$BLOOM_TAPDB_LOCAL_PG_PORT}"
_BLOOM_DEFAULT_TAPDB_CONFIG_PATH="$BLOOM_ROOT/config/tapdb-config-${TAPDB_DATABASE_NAME}.yaml"
if [[ -z "${TAPDB_CONFIG_PATH:-}" ]]; then
    if [[ -f "$_BLOOM_DEFAULT_TAPDB_CONFIG_PATH" ]]; then
        export TAPDB_CONFIG_PATH="$_BLOOM_DEFAULT_TAPDB_CONFIG_PATH"
    fi
fi
export BLOOM_COGNITO_APP_NAME="${BLOOM_COGNITO_APP_NAME:-bloom}"
export AWS_PROFILE="${AWS_PROFILE:-lsmc}"
export AWS_REGION="${AWS_REGION:-us-west-2}"
export AWS_DEFAULT_REGION="${AWS_DEFAULT_REGION:-$AWS_REGION}"

echo -e "  ${_GREEN}✓${_NC} TAPDB_ENV=${TAPDB_ENV}"
echo -e "  ${_GREEN}✓${_NC} TAPDB_CLIENT_ID=${TAPDB_CLIENT_ID}"
echo -e "  ${_GREEN}✓${_NC} TAPDB_DATABASE_NAME=${TAPDB_DATABASE_NAME}"
echo -e "  ${_GREEN}✓${_NC} TAPDB_STRICT_NAMESPACE=${TAPDB_STRICT_NAMESPACE}"
echo -e "  ${_GREEN}✓${_NC} MERIDIAN_ENVIRONMENT=${MERIDIAN_ENVIRONMENT}"
echo -e "  ${_GREEN}✓${_NC} MERIDIAN_SANDBOX_PREFIX=${MERIDIAN_SANDBOX_PREFIX}"
if [[ -n "${TAPDB_CONFIG_PATH:-}" ]]; then
    echo -e "  ${_GREEN}✓${_NC} TAPDB_CONFIG_PATH=${TAPDB_CONFIG_PATH}"
else
    echo -e "  ${_YELLOW}⚠${_NC} TAPDB_CONFIG_PATH is not set"
fi
echo -e "  ${_GREEN}✓${_NC} TAPDB_DEV_PORT=${TAPDB_DEV_PORT}"
echo -e "  ${_GREEN}✓${_NC} TAPDB_TEST_PORT=${TAPDB_TEST_PORT}"
echo -e "  ${_GREEN}✓${_NC} BLOOM_COGNITO_APP_NAME=${BLOOM_COGNITO_APP_NAME}"
echo -e "  ${_GREEN}✓${_NC} AWS_PROFILE=${AWS_PROFILE}"
echo -e "  ${_GREEN}✓${_NC} AWS_REGION=${AWS_REGION}"

export BLOOM_ROOT

deactivate_bloom() {
    unset BLOOM_ROOT
    unset TAPDB_ENV
    unset TAPDB_CLIENT_ID
    unset TAPDB_DATABASE_NAME
    unset TAPDB_STRICT_NAMESPACE
    unset MERIDIAN_ENVIRONMENT
    unset MERIDIAN_SANDBOX_PREFIX
    unset TAPDB_CONFIG_PATH
    unset BLOOM_TAPDB_LOCAL_PG_PORT
    unset TAPDB_DEV_PORT
    unset TAPDB_TEST_PORT
    unset BLOOM_COGNITO_APP_NAME
    if [[ "$CONDA_DEFAULT_ENV" == "BLOOM" ]]; then
        conda deactivate 2>/dev/null
    fi
    echo "BLOOM LIMS environment deactivated."
    unset -f deactivate_bloom
}

echo ""
echo -e "${_CYAN}BLOOM LIMS environment activated!${_NC}"
echo ""
echo "Command groups:"
echo ""
echo -e "  ${_CYAN}bloom server${_NC}    start, stop, status, logs"
echo -e "  ${_CYAN}bloom db${_NC}        init, start, stop, status, migrate, seed, shell, reset"
echo -e "  ${_CYAN}bloom config${_NC}    path, init, show, validate, edit, reset, shell, doctor, status"
echo -e "  ${_CYAN}tapdb${_NC}           shared DB/runtime lifecycle"
echo -e "  ${_CYAN}daycog${_NC}          shared Cognito lifecycle where Bloom delegates"
echo -e "  ${_CYAN}bloom info${_NC}      Show environment information"
echo -e "  ${_CYAN}bloom version${_NC}   Show CLI version"
echo ""
echo -e "  ${_GREEN}bloom --help${_NC}          Show all available commands"
echo -e "  ${_GREEN}deactivate_bloom${_NC}      Deactivate this environment"
echo ""

unset _BLOOM_CLI_CORE_REPO
unset _BLOOM_DAYCOG_REPO
unset _BLOOM_TAPDB_REPO
