#!/bin/bash
#
# E2E tests for install.sh
#
# Tests the full installation workflow including:
# - Fresh installation
# - Version check and idempotent reinstall
# - Agent detection and configuration
# - Uninstall (via manual removal)
#
# Usage:
#   ./tests/e2e/run_install_e2e.sh [--verbose]
#
# Requirements:
# - dcg binary built (cargo build --release)
# - bash 4.0+
#
# Exit codes:
#   0 - All tests passed
#   1 - One or more tests failed

set -euo pipefail

# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
INSTALL_SCRIPT="$PROJECT_ROOT/install.sh"
VERBOSE="${1:-}"
LOG_FILE="e2e_install_$(date +%Y%m%d_%H%M%S).log"
PASSED=0
FAILED=0
TESTS=()

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m' # No Color

# Test environment
TEST_HOME=""
ORIGINAL_HOME="$HOME"

log() {
    echo "$@" | tee -a "$LOG_FILE"
}

log_verbose() {
    if [[ "$VERBOSE" == "--verbose" ]]; then
        echo "$@" | tee -a "$LOG_FILE"
    else
        echo "$@" >> "$LOG_FILE"
    fi
}

pass() {
    echo -e "  ${GREEN}✓${NC} $1"
    ((PASSED++)) || true
    TESTS+=("PASS: $1")
}

fail() {
    echo -e "  ${RED}✗${NC} $1"
    echo "    Error: $2" >> "$LOG_FILE"
    ((FAILED++)) || true
    TESTS+=("FAIL: $1 - $2")
}

# Setup isolated test environment
setup_test_env() {
    TEST_HOME=$(mktemp -d)
    export HOME="$TEST_HOME"
    export PATH="$TEST_HOME/.local/bin:$PATH"
    mkdir -p "$TEST_HOME/.local/bin"

    log_verbose "Test HOME: $TEST_HOME"
}

# Cleanup test environment
cleanup_test_env() {
    if [[ -n "$TEST_HOME" && -d "$TEST_HOME" ]]; then
        rm -rf "$TEST_HOME"
    fi
    export HOME="$ORIGINAL_HOME"
}

# Build release binary if needed
build_binary() {
    log "Building release binary..."
    if cargo build --release 2>&1 | tee -a "$LOG_FILE" | tail -3; then
        log "Build complete."
    else
        echo "Build failed!"
        exit 1
    fi
}

# ============================================================================
# Test Cases
# ============================================================================

# Test 1: Fresh installation (mock - doesn't actually download)
test_fresh_install_structure() {
    log_verbose "Running: Fresh install structure test"
    setup_test_env

    # Create mock settings structure that install.sh would create
    mkdir -p "$HOME/.claude"

    # Source install.sh functions and run configure_claude_code
    # We'll use a simplified test that checks the structure

    local settings="$HOME/.claude/settings.json"
    cat > "$settings" << EOF
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {"type": "command", "command": "$HOME/.local/bin/dcg"}
        ]
      }
    ]
  }
}
EOF

    # Verify structure
    if [[ -f "$settings" ]]; then
        if grep -q "PreToolUse" "$settings" && grep -q "Bash" "$settings"; then
            pass "Fresh install creates correct hook structure"
        else
            fail "Fresh install creates correct hook structure" "Missing required hook fields"
        fi
    else
        fail "Fresh install creates correct hook structure" "settings.json not created"
    fi

    cleanup_test_env
}

# Test 2: Agent detection
test_agent_detection() {
    log_verbose "Running: Agent detection test"
    setup_test_env

    # Create mock agent installations
    mkdir -p "$HOME/.claude"
    mkdir -p "$HOME/.codex"
    mkdir -p "$HOME/.gemini"
    mkdir -p "$HOME/.continue"

    # Source install.sh to get detect_agents function
    # We extract and run just the detection part
    source <(sed -n '/^detect_agents()/,/^}/p' "$INSTALL_SCRIPT")
    detect_agents

    log_verbose "Detected agents: ${DETECTED_AGENTS[*]:-none}"

    local found_all=true
    for agent in "claude-code" "codex-cli" "gemini-cli" "continue"; do
        local found=false
        for detected in "${DETECTED_AGENTS[@]:-}"; do
            if [[ "$detected" == "$agent" ]]; then
                found=true
                break
            fi
        done
        if [[ "$found" == "false" ]]; then
            found_all=false
            log_verbose "Missing agent: $agent"
        fi
    done

    if [[ "$found_all" == "true" ]]; then
        pass "Agent detection finds all installed agents"
    else
        fail "Agent detection finds all installed agents" "Some agents not detected"
    fi

    cleanup_test_env
}

# Test 3: Checksum verification function
test_checksum_verification() {
    log_verbose "Running: Checksum verification test"
    setup_test_env

    # Source verify_checksum function
    source <(sed -n '/^verify_checksum()/,/^}/p' "$INSTALL_SCRIPT")

    # Create test file
    local test_file="$TEST_HOME/test_checksum"
    echo -n "test content" > "$test_file"

    # Calculate correct checksum
    local correct_checksum
    if command -v sha256sum &>/dev/null; then
        correct_checksum=$(sha256sum "$test_file" | cut -d' ' -f1)
    elif command -v shasum &>/dev/null; then
        correct_checksum=$(shasum -a 256 "$test_file" | cut -d' ' -f1)
    else
        pass "Checksum verification (skipped - no sha256 tool)"
        cleanup_test_env
        return
    fi

    # Suppress output for testing
    QUIET=1
    HAS_GUM=0
    NO_GUM=1

    # Define ok/err functions used by verify_checksum
    ok() { :; }
    err() { :; }

    # Test correct checksum
    if verify_checksum "$test_file" "$correct_checksum" 2>/dev/null; then
        pass "Checksum verification succeeds with correct checksum"
    else
        fail "Checksum verification succeeds with correct checksum" "Function returned error"
    fi

    # Test wrong checksum
    local wrong_checksum="0000000000000000000000000000000000000000000000000000000000000000"
    if verify_checksum "$test_file" "$wrong_checksum" 2>/dev/null; then
        fail "Checksum verification fails with wrong checksum" "Function did not return error"
    else
        pass "Checksum verification fails with wrong checksum"
    fi

    cleanup_test_env
}

# Test 4: Version comparison
test_version_comparison() {
    log_verbose "Running: Version comparison test"
    setup_test_env

    # Source check_installed_version function
    source <(sed -n '/^check_installed_version()/,/^}/p' "$INSTALL_SCRIPT")

    DEST="$HOME/.local/bin"
    mkdir -p "$DEST"

    # Create mock dcg with specific version
    cat > "$DEST/dcg" << 'EOF'
#!/bin/bash
echo "dcg 1.2.3"
EOF
    chmod +x "$DEST/dcg"

    # Test matching version
    if check_installed_version "v1.2.3"; then
        pass "Version check matches installed version"
    else
        fail "Version check matches installed version" "v1.2.3 did not match"
    fi

    # Test non-matching version
    if check_installed_version "v2.0.0"; then
        fail "Version check detects different version" "v2.0.0 incorrectly matched"
    else
        pass "Version check detects different version"
    fi

    cleanup_test_env
}

# Test 5: Idempotent PATH detection
test_path_detection() {
    log_verbose "Running: PATH detection test"
    setup_test_env

    DEST="$HOME/.local/bin"
    mkdir -p "$DEST"

    # Add to PATH
    export PATH="$DEST:$PATH"

    # Check if detection works
    local in_path=false
    case ":$PATH:" in
        *:"$DEST":*)
            in_path=true
            ;;
    esac

    if [[ "$in_path" == "true" ]]; then
        pass "PATH detection finds existing entry"
    else
        fail "PATH detection finds existing entry" "DEST not found in PATH"
    fi

    cleanup_test_env
}

# Test 6: Claude Code settings merge preserves existing content
test_settings_merge() {
    log_verbose "Running: Settings merge test"
    setup_test_env

    # This requires python3 for JSON merge
    if ! command -v python3 &>/dev/null; then
        pass "Settings merge preserves existing content (skipped - no python3)"
        cleanup_test_env
        return
    fi

    mkdir -p "$HOME/.claude"

    # Create existing settings
    cat > "$HOME/.claude/settings.json" << 'EOF'
{
  "theme": "dark",
  "fontSize": 14,
  "hooks": {
    "PreToolUse": [
      {"matcher": "Read", "hooks": [{"type": "command", "command": "other-tool"}]}
    ]
  }
}
EOF

    # Source functions
    DEST="$HOME/.local/bin"
    HAS_GUM=0
    NO_GUM=1
    QUIET=1

    # Define needed functions
    ok() { :; }
    err() { :; }
    info() { :; }

    # Extract and source install.sh functions using the robust method
    # This inserts a return before actual execution, preserving all functions
    local tmp_script
    tmp_script=$(mktemp)
    sed '
        1d
        s/^set -euo pipefail/set -e/
        s/^umask 022/umask 022; set +e/
        /^# Run Auto-Configuration$/i\
return 0 2>/dev/null || true
    ' "$INSTALL_SCRIPT" > "$tmp_script"
    # shellcheck disable=SC1090
    source "$tmp_script" >/dev/null 2>&1 || true
    rm -f "$tmp_script"

    CLAUDE_STATUS=""
    configure_claude_code "$HOME/.claude/settings.json" "0"

    log_verbose "Final settings: $(cat "$HOME/.claude/settings.json")"

    # Check dcg was added
    if ! grep -q "dcg" "$HOME/.claude/settings.json"; then
        fail "Settings merge preserves existing content" "dcg hook not added"
        cleanup_test_env
        return
    fi

    # Check existing content preserved
    if grep -q "theme" "$HOME/.claude/settings.json" && grep -q "other-tool" "$HOME/.claude/settings.json"; then
        pass "Settings merge preserves existing content"
    else
        fail "Settings merge preserves existing content" "Existing settings were lost"
    fi

    cleanup_test_env
}

# Test 7: Lock file prevents concurrent runs
test_lock_mechanism() {
    log_verbose "Running: Lock mechanism test"
    setup_test_env

    local lock_dir="/tmp/dcg-install.lock.d"

    # Clean up any existing lock
    rm -rf "$lock_dir"

    # Test acquiring lock
    if mkdir "$lock_dir" 2>/dev/null; then
        echo $$ > "$lock_dir/pid"
        pass "Lock mechanism acquires lock successfully"

        # Test that second attempt fails
        if mkdir "$lock_dir" 2>/dev/null; then
            fail "Lock mechanism prevents concurrent runs" "Second mkdir succeeded"
        else
            pass "Lock mechanism prevents concurrent runs"
        fi

        # Cleanup lock
        rm -rf "$lock_dir"
    else
        fail "Lock mechanism acquires lock successfully" "mkdir failed"
    fi

    cleanup_test_env
}

# Test 8: Install script syntax check
test_script_syntax() {
    log_verbose "Running: Script syntax check"

    if bash -n "$INSTALL_SCRIPT" 2>&1; then
        pass "install.sh has valid bash syntax"
    else
        fail "install.sh has valid bash syntax" "Syntax errors found"
    fi
}

# ============================================================================
# Main execution
# ============================================================================

main() {
    echo "=== DCG Install Script E2E Test Suite ==="
    echo "Started: $(date)"
    echo "Log file: $LOG_FILE"
    echo ""

    # Build binary first
    build_binary

    # Run tests
    echo ""
    echo "[1/8] Testing fresh install structure..."
    test_fresh_install_structure

    echo ""
    echo "[2/8] Testing agent detection..."
    test_agent_detection

    echo ""
    echo "[3/8] Testing checksum verification..."
    test_checksum_verification

    echo ""
    echo "[4/8] Testing version comparison..."
    test_version_comparison

    echo ""
    echo "[5/8] Testing PATH detection..."
    test_path_detection

    echo ""
    echo "[6/8] Testing settings merge..."
    test_settings_merge

    echo ""
    echo "[7/8] Testing lock mechanism..."
    test_lock_mechanism

    echo ""
    echo "[8/8] Testing script syntax..."
    test_script_syntax

    # Summary
    echo ""
    echo "=== Test Summary ==="
    echo "Passed: $PASSED"
    echo "Failed: $FAILED"
    echo "Completed: $(date)"

    # Write detailed results to log
    echo "" >> "$LOG_FILE"
    echo "=== Detailed Results ===" >> "$LOG_FILE"
    for test in "${TESTS[@]}"; do
        echo "$test" >> "$LOG_FILE"
    done

    if [[ $FAILED -gt 0 ]]; then
        echo ""
        echo -e "${RED}Some tests failed! See $LOG_FILE for details.${NC}"
        exit 1
    else
        echo ""
        echo -e "${GREEN}All tests passed!${NC}"
        exit 0
    fi
}

main "$@"