#!/bin/bash
#
# E2E tests for DCG self-update mechanism
#
# Tests the full update workflow including:
# - Version checking (--check flag)
# - Backup listing (--list-backups)
# - Error handling for invalid versions
# - Rollback functionality
#
# Usage:
#   ./tests/e2e/run_update_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)"
VERBOSE="${1:-}"
LOG_FILE="e2e_update_$(date +%Y%m%d_%H%M%S).log"
PASSED=0
FAILED=0
SKIPPED=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"
DCG_BINARY=""

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")
}

skip() {
    echo -e "  ${YELLOW}○${NC} $1 (skipped)"
    ((SKIPPED++)) || true
    TESTS+=("SKIP: $1")
}

# 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"
    mkdir -p "$TEST_HOME/.local/share/dcg/backups"
    mkdir -p "$TEST_HOME/.cache/dcg"

    # Copy dcg binary to test environment
    cp "$DCG_BINARY" "$TEST_HOME/.local/bin/dcg"
    chmod +x "$TEST_HOME/.local/bin/dcg"

    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 -p dcg 2>&1 | tee -a "$LOG_FILE" | tail -3; then
        DCG_BINARY="$PROJECT_ROOT/target/release/dcg"
        if [[ ! -f "$DCG_BINARY" ]]; then
            echo "Binary not found at $DCG_BINARY"
            exit 1
        fi
        log "Build complete."
    else
        echo "Build failed!"
        exit 1
    fi
}

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

# Test 1: Version display
test_version_display() {
    log_verbose "Running: Version display test"
    setup_test_env

    local output
    output=$("$TEST_HOME/.local/bin/dcg" --version 2>&1 || true)
    log_verbose "Version output: $output"

    if echo "$output" | grep -qE "dcg [0-9]+\.[0-9]+\.[0-9]+"; then
        pass "Version display shows valid semver"
    else
        fail "Version display shows valid semver" "Output: $output"
    fi

    # Extract version number
    local version
    version=$(echo "$output" | grep -oP "[0-9]+\.[0-9]+\.[0-9]+" | head -1 || true)
    if [[ -n "$version" ]]; then
        log_verbose "Parsed version: $version"
        pass "Version can be parsed as semver"
    else
        fail "Version can be parsed as semver" "Could not extract version"
    fi

    cleanup_test_env
}

# Test 2: Update check command
test_update_check() {
    log_verbose "Running: Update check test"
    setup_test_env

    # Note: This test may fail if no network access or rate limited
    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --check 2>&1) || exit_code=$?
    log_verbose "Update check output: $output"
    log_verbose "Exit code: $exit_code"

    # Accept either success (shows version info) or network error (graceful failure)
    if echo "$output" | grep -qiE "(current version|latest version|up to date|network error|error|failed to fetch)"; then
        pass "Update check produces expected output"
    else
        fail "Update check produces expected output" "Unexpected output: $output"
    fi

    cleanup_test_env
}

# Test 3: Update check with --json flag
test_update_check_json() {
    log_verbose "Running: Update check JSON output test"
    setup_test_env

    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --check --json 2>&1) || exit_code=$?
    log_verbose "JSON output: $output"

    # If network available, should return JSON
    # If network error, may return error message
    if echo "$output" | grep -qE '^\{.*\}$|"current_version"|network error|failed'; then
        pass "Update check --json produces valid output"
    else
        # Some versions may not support --json flag yet
        skip "Update check --json (flag may not be implemented)"
    fi

    cleanup_test_env
}

# Test 4: Backup list command
test_backup_list() {
    log_verbose "Running: Backup list test"
    setup_test_env

    # Create mock backups
    local backup_dir="$TEST_HOME/.local/share/dcg/backups"
    mkdir -p "$backup_dir"

    # Create mock backup files
    echo "mock binary v1" > "$backup_dir/dcg-0.2.11-1737100000"
    cat > "$backup_dir/dcg-0.2.11-1737100000.json" << 'EOF'
{
  "version": "0.2.11",
  "created_at": 1737100000,
  "original_path": "/usr/local/bin/dcg"
}
EOF

    echo "mock binary v2" > "$backup_dir/dcg-0.2.12-1737200000"
    cat > "$backup_dir/dcg-0.2.12-1737200000.json" << 'EOF'
{
  "version": "0.2.12",
  "created_at": 1737200000,
  "original_path": "/usr/local/bin/dcg"
}
EOF

    log_verbose "Created mock backups in $backup_dir"

    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --list-backups 2>&1) || exit_code=$?
    log_verbose "Backup list output: $output"

    if echo "$output" | grep -qE "(v?0\.2\.12|v?0\.2\.11|backup|No backup)"; then
        pass "Backup list shows available backups"
    else
        fail "Backup list shows available backups" "Output: $output"
    fi

    cleanup_test_env
}

# Test 5: Empty backup list
test_empty_backup_list() {
    log_verbose "Running: Empty backup list test"
    setup_test_env

    # Ensure backup directory is empty
    rm -rf "$TEST_HOME/.local/share/dcg/backups"/*

    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --list-backups 2>&1) || exit_code=$?
    log_verbose "Empty backup list output: $output"

    if echo "$output" | grep -qiE "(no backup|empty|available)"; then
        pass "Empty backup list handled gracefully"
    else
        fail "Empty backup list handled gracefully" "Output: $output"
    fi

    cleanup_test_env
}

# Test 6: Invalid version error handling
test_invalid_version() {
    log_verbose "Running: Invalid version error handling test"
    setup_test_env

    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --version "99.99.99" 2>&1) || exit_code=$?
    log_verbose "Invalid version output: $output (exit code: $exit_code)"

    # Should fail gracefully with an error message
    if [[ $exit_code -ne 0 ]] || echo "$output" | grep -qiE "(not found|unavailable|error|fail|invalid)"; then
        pass "Invalid version handled gracefully"
    else
        fail "Invalid version handled gracefully" "Expected error, got: $output"
    fi

    cleanup_test_env
}

# Test 7: Help text includes update subcommand
test_help_includes_update() {
    log_verbose "Running: Help text includes update test"
    setup_test_env

    local output
    output=$("$TEST_HOME/.local/bin/dcg" --help 2>&1 || true)
    log_verbose "Help output length: ${#output}"

    if echo "$output" | grep -qi "update"; then
        pass "Help text includes update subcommand"
    else
        fail "Help text includes update subcommand" "update not found in help"
    fi

    cleanup_test_env
}

# Test 8: Update subcommand help
test_update_help() {
    log_verbose "Running: Update subcommand help test"
    setup_test_env

    local output
    output=$("$TEST_HOME/.local/bin/dcg" update --help 2>&1 || true)
    log_verbose "Update help output: $output"

    # Check for expected flags
    local found_flags=0
    if echo "$output" | grep -qE "(-c|--check)"; then
        ((found_flags++)) || true
    fi
    if echo "$output" | grep -qE "(--list-backups|--rollback)"; then
        ((found_flags++)) || true
    fi

    if [[ $found_flags -ge 1 ]]; then
        pass "Update help shows expected flags"
    else
        fail "Update help shows expected flags" "Missing expected flags in: $output"
    fi

    cleanup_test_env
}

# Test 9: Rollback without backups fails gracefully
test_rollback_no_backups() {
    log_verbose "Running: Rollback without backups test"
    setup_test_env

    # Ensure no backups exist
    rm -rf "$TEST_HOME/.local/share/dcg/backups"/*

    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" update --rollback 2>&1) || exit_code=$?
    log_verbose "Rollback output: $output (exit code: $exit_code)"

    # Should fail with meaningful error
    if [[ $exit_code -ne 0 ]] || echo "$output" | grep -qiE "(no backup|not available|error|fail)"; then
        pass "Rollback without backups fails gracefully"
    else
        fail "Rollback without backups fails gracefully" "Expected error, got: $output"
    fi

    cleanup_test_env
}

# Test 10: DCG_NO_UPDATE_CHECK environment variable
test_update_check_disabled() {
    log_verbose "Running: Update check disabled by env var test"
    setup_test_env

    # Set environment variable to disable update checks
    export DCG_NO_UPDATE_CHECK=1

    # The binary should respect this - exact behavior depends on implementation
    # Just verify it doesn't crash
    local output
    local exit_code=0
    output=$("$TEST_HOME/.local/bin/dcg" --version 2>&1) || exit_code=$?

    unset DCG_NO_UPDATE_CHECK

    if [[ $exit_code -eq 0 ]]; then
        pass "DCG_NO_UPDATE_CHECK env var does not crash binary"
    else
        fail "DCG_NO_UPDATE_CHECK env var does not crash binary" "Exit code: $exit_code"
    fi

    cleanup_test_env
}

# Test 11: Binary hash check (same version = no change)
test_same_version_no_change() {
    log_verbose "Running: Same version no-op test"
    setup_test_env

    # Get current version
    local current_version
    current_version=$("$TEST_HOME/.local/bin/dcg" --version 2>&1 | grep -oP "[0-9]+\.[0-9]+\.[0-9]+" | head -1 || echo "")

    if [[ -z "$current_version" ]]; then
        skip "Same version no-op (could not determine version)"
        cleanup_test_env
        return
    fi

    # Get hash before
    local before_hash
    before_hash=$(sha256sum "$TEST_HOME/.local/bin/dcg" | cut -d' ' -f1)
    log_verbose "Before hash: $before_hash"

    # Attempt update to same version (should be no-op or graceful message)
    local output
    output=$("$TEST_HOME/.local/bin/dcg" update --version "$current_version" 2>&1 || true)
    log_verbose "Same version update output: $output"

    # Get hash after
    local after_hash
    after_hash=$(sha256sum "$TEST_HOME/.local/bin/dcg" | cut -d' ' -f1)
    log_verbose "After hash: $after_hash"

    # Binary should be unchanged OR update should report up-to-date
    if [[ "$before_hash" == "$after_hash" ]] || echo "$output" | grep -qiE "(up.to.date|already|current|same)"; then
        pass "Same version update is handled correctly"
    else
        pass "Same version update performed reinstall (acceptable behavior)"
    fi

    cleanup_test_env
}

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

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

    # Build binary first
    build_binary

    # Run tests
    echo ""
    echo "[1/11] Testing version display..."
    test_version_display

    echo ""
    echo "[2/11] Testing update check..."
    test_update_check

    echo ""
    echo "[3/11] Testing update check JSON..."
    test_update_check_json

    echo ""
    echo "[4/11] Testing backup list..."
    test_backup_list

    echo ""
    echo "[5/11] Testing empty backup list..."
    test_empty_backup_list

    echo ""
    echo "[6/11] Testing invalid version handling..."
    test_invalid_version

    echo ""
    echo "[7/11] Testing help includes update..."
    test_help_includes_update

    echo ""
    echo "[8/11] Testing update subcommand help..."
    test_update_help

    echo ""
    echo "[9/11] Testing rollback without backups..."
    test_rollback_no_backups

    echo ""
    echo "[10/11] Testing DCG_NO_UPDATE_CHECK..."
    test_update_check_disabled

    echo ""
    echo "[11/11] Testing same version no-op..."
    test_same_version_no_change

    # Summary
    echo ""
    echo "=== Test Summary ==="
    echo "Passed:  $PASSED"
    echo "Failed:  $FAILED"
    echo "Skipped: $SKIPPED"
    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 "$@"