#!/bin/bash
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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
#
#   http://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.

# Function to get the git branch and commit hash
function get_git_info() {
    local git_info
    git_info=$(git log -1 --pretty=format:"%h")
    local git_branch
    git_branch=$(git rev-parse --abbrev-ref HEAD)
    echo "${git_branch}_${git_info}"
}

# OS detection
OS=$(uname -s)

# Function to check if process exists - OS specific implementations
function process_exists() {
    local check_pid=$1
    if [ "$OS" = "Darwin" ]; then
        ps -p "${check_pid}" >/dev/null
    else
        [[ -e /proc/${check_pid} ]]
    fi
}

# Function to send signal to process - OS specific implementations
function send_signal_to_pid() {
    local target_pid=$1
    local signal=$2
    if [ "$OS" = "Darwin" ]; then
        kill "-${signal}" "${target_pid}"
    else
        kill -s "${signal}" "${target_pid}"
    fi
}

# Function to wait for a process with specific name to exit
function wait_for_process() {
    local process_name=$1
    local timeout=$2
    local start_time
    start_time=$(date +%s)
    local end_time=$((start_time + timeout))
    local continue_outer_loop=false

    while [[ $(date +%s) -lt ${end_time} ]]; do
        continue_outer_loop=false
        local proc_pid
        for proc_pid in $(pgrep -x "${process_name}"); do
            if process_exists "${proc_pid}"; then
                sleep 0.1
                continue_outer_loop=true
                break
            fi
        done
        [[ $continue_outer_loop == true ]] && continue
        return 0
    done

    echo "Timeout waiting for process ${process_name} to exit."
    return 1
}

# Function to wait for a process with specific PID to exit
function wait_for_process_pid() {
    local wait_pid=$1
    local timeout=$2
    local start_time
    start_time=$(date +%s)
    local end_time=$((start_time + timeout))

    while [[ $(date +%s) -lt ${end_time} ]]; do
        if ! process_exists "${wait_pid}"; then
            return 0
        fi
        sleep 0.1
    done

    echo "Timeout waiting for process with PID ${wait_pid} to exit."
    return 1
}

# Function to send a signal to a process
function send_signal() {
    local process_name=$1
    local pids
    pids=$(pgrep -x "${process_name}") || true
    local signal=$2

    if [[ -n "${pids}" ]]; then
        local proc_pid
        for proc_pid in ${pids}; do
            if process_exists "${proc_pid}"; then
                send_signal_to_pid "${proc_pid}" "${signal}"
            fi
        done
    fi
}

# Function to exit with error if a process with the given PID is running
exit_if_process_is_not_running() {
    local check_pid="$1"

    if kill -0 "$check_pid" 2>/dev/null; then
        echo "Process with PID $check_pid is running."
        return 0
    else
        echo "Error: Process with PID $check_pid is not running."
        exit 1
    fi
}

# Exit hook for profile.sh
function on_exit_profile() {
    # Gracefully stop the server
    send_signal "iggy-server" "KILL"
    send_signal "iggy-bench" "KILL"
    send_signal "flamegraph" "KILL"
    send_signal "perf" "KILL"
}

# Exit hook for run-benches.sh
function on_exit_bench() {
    send_signal "iggy-server" "KILL"
    # Use exact match for iggy-bench to avoid killing iggy-bench-dashboard
    pids=$(pgrep -x "iggy-bench") || true
    if [[ -n "${pids}" ]]; then
        local bench_pid
        for bench_pid in ${pids}; do
            if process_exists "${bench_pid}"; then
                send_signal_to_pid "${bench_pid}" "KILL"
            fi
        done
    fi
}

# ---------------------------------------------------------------------------
# Server lifecycle helpers for example-runner scripts
# ---------------------------------------------------------------------------

readonly EXAMPLES_LOG_FILE="iggy-server.log"
readonly EXAMPLES_PID_FILE="iggy-server.pid"
readonly EXAMPLES_SERVER_TIMEOUT=300
readonly EXAMPLES_STOP_TIMEOUT=5

# Resolve and validate the server binary path.
# Usage: resolve_server_binary [target]
# Sets global SERVER_BIN.
function resolve_server_binary() {
    local target="${1:-}"
    if [ -n "${target}" ]; then
        SERVER_BIN="target/${target}/debug/iggy-server"
    else
        SERVER_BIN="target/debug/iggy-server"
    fi

    if [ ! -f "${SERVER_BIN}" ]; then
        echo "Error: Server binary not found at ${SERVER_BIN}"
        echo "Please build the server binary before running this script:"
        if [ -n "${target}" ]; then
            echo "  cargo build --target ${target} --bin iggy-server"
        else
            echo "  cargo build --bin iggy-server"
        fi
        exit 1
    fi
    echo "Using server binary at ${SERVER_BIN}"
}

# Resolve and validate the CLI binary path.
# Usage: resolve_cli_binary [target]
# Sets global CLI_BIN.
function resolve_cli_binary() {
    local target="${1:-}"
    if [ -n "${target}" ]; then
        CLI_BIN="target/${target}/debug/iggy"
    else
        CLI_BIN="target/debug/iggy"
    fi

    if [ ! -f "${CLI_BIN}" ]; then
        echo "Error: CLI binary not found at ${CLI_BIN}"
        echo "Please build the CLI and examples before running this script:"
        if [ -n "${target}" ]; then
            echo "  cargo build --target ${target} --bin iggy --examples"
        else
            echo "  cargo build --bin iggy --examples"
        fi
        exit 1
    fi
    echo "Using CLI binary at ${CLI_BIN}"
}

# Remove old server data, log, and PID files.
function cleanup_server_state() {
    rm -fr local_data
    rm -f "${EXAMPLES_LOG_FILE}" "${EXAMPLES_PID_FILE}"
}

# Start the plain (non-TLS) iggy server in background.
# Usage: start_plain_server [extra_args...]
function start_plain_server() {
    echo "Starting server from ${SERVER_BIN}..."
    IGGY_ROOT_USERNAME=iggy IGGY_ROOT_PASSWORD=iggy \
        ${SERVER_BIN} "$@" &>"${EXAMPLES_LOG_FILE}" &
    echo $! >"${EXAMPLES_PID_FILE}"
}

# Start the TLS-enabled iggy server in background.
# Usage: start_tls_server [extra_args...]
function start_tls_server() {
    echo "Starting TLS server from ${SERVER_BIN}..."
    IGGY_ROOT_USERNAME=iggy IGGY_ROOT_PASSWORD=iggy \
        IGGY_TCP_TLS_ENABLED=true \
        IGGY_TCP_TLS_CERT_FILE=core/certs/iggy_cert.pem \
        IGGY_TCP_TLS_KEY_FILE=core/certs/iggy_key.pem \
        ${SERVER_BIN} "$@" &>"${EXAMPLES_LOG_FILE}" &
    echo $! >"${EXAMPLES_PID_FILE}"
}

# Block until "has started" appears in the server log or timeout.
# Usage: wait_for_server_ready [label]
function wait_for_server_ready() {
    local label="${1:-Iggy}"
    local elapsed=0
    while ! grep -q "has started" "${EXAMPLES_LOG_FILE}"; do
        if [ ${elapsed} -gt ${EXAMPLES_SERVER_TIMEOUT} ]; then
            echo "${label} server did not start within ${EXAMPLES_SERVER_TIMEOUT} seconds."
            ps fx 2>/dev/null || ps aux
            cat "${EXAMPLES_LOG_FILE}"
            exit 1
        fi
        echo "Waiting for ${label} server to start... ${elapsed}"
        sleep 1
        ((elapsed += 1))
    done
}

# Gracefully stop the server: SIGTERM, wait up to EXAMPLES_STOP_TIMEOUT
# seconds for exit, then SIGKILL if still alive.
function stop_server() {
    if [ ! -e "${EXAMPLES_PID_FILE}" ]; then
        return
    fi
    local pid
    pid="$(cat "${EXAMPLES_PID_FILE}")"
    rm -f "${EXAMPLES_PID_FILE}"

    kill -TERM "${pid}" 2>/dev/null || true

    if wait_for_process_pid "${pid}" "${EXAMPLES_STOP_TIMEOUT}" 2>/dev/null; then
        return
    fi

    echo "Server PID ${pid} did not exit after ${EXAMPLES_STOP_TIMEOUT}s, sending SIGKILL..."
    kill -KILL "${pid}" 2>/dev/null || true
    wait_for_process_pid "${pid}" 2 2>/dev/null || true
}

# Print final result and dump the log on failure.
function report_result() {
    local exit_code=$1
    if [ "${exit_code}" -eq 0 ]; then
        echo "Test passed"
    else
        echo "Test failed, see log file:"
        test -e "${EXAMPLES_LOG_FILE}" && cat "${EXAMPLES_LOG_FILE}"
    fi
    rm -f "${EXAMPLES_LOG_FILE}" "${EXAMPLES_PID_FILE}"
}

# Portable timeout wrapper (macOS has gtimeout via coreutils, Linux has timeout).
function portable_timeout() {
    local secs="$1"
    shift
    if command -v timeout >/dev/null 2>&1; then
        timeout "${secs}" "$@"
    elif command -v gtimeout >/dev/null 2>&1; then
        gtimeout "${secs}" "$@"
    else
        "$@"
    fi
}

# Run commands extracted from a README file.
# Usage: run_readme_commands readme_file grep_pattern [cmd_timeout [grep_exclude]]
# Reads matching lines, strips backticks/comments, executes each.
# Calls TRANSFORM_COMMAND function on each command if defined.
# Returns: sets global EXAMPLES_EXIT_CODE.
function run_readme_commands() {
    local readme_file="$1"
    local grep_pattern="$2"
    local cmd_timeout="${3:-0}"
    local grep_exclude="${4:-}"

    if [ ! -f "${readme_file}" ]; then
        return
    fi

    local commands
    commands=$(grep -E "${grep_pattern}" "${readme_file}" || true)
    if [ -n "${grep_exclude}" ]; then
        commands=$(echo "${commands}" | grep -v "${grep_exclude}" || true)
    fi
    if [ -z "${commands}" ]; then
        return
    fi

    while IFS= read -r command; do
        command=$(echo "${command}" | tr -d '`' | sed 's/^#.*//')
        if [ -z "${command}" ]; then
            continue
        fi

        if declare -f TRANSFORM_COMMAND >/dev/null 2>&1; then
            command=$(TRANSFORM_COMMAND "${command}")
        fi

        echo -e "\e[33mChecking command from ${readme_file}:\e[0m ${command}"
        echo ""

        set +e
        if [ "${cmd_timeout}" -gt 0 ] 2>/dev/null; then
            eval "portable_timeout ${cmd_timeout} ${command}"
            local test_exit_code=$?
            if [[ ${test_exit_code} -ne 0 && ${test_exit_code} -ne 124 ]]; then
                EXAMPLES_EXIT_CODE=${test_exit_code}
            fi
        else
            eval "${command}"
            EXAMPLES_EXIT_CODE=$?
        fi
        set -e

        if [ "${EXAMPLES_EXIT_CODE}" -ne 0 ]; then
            echo ""
            echo -e "\e[31mCommand failed:\e[0m ${command}"
            echo ""
            return
        fi

        sleep 2
    done <<< "${commands}"
}