#!/bin/bash
# Script: Exécution de tous les tests
# Description: Lance tous les tests de l'infrastructure 4NK Node
# Auteur: Assistant IA
# Date: 2024-12-19

set -e

# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
LOG_DIR="$SCRIPT_DIR/logs"
REPORT_DIR="$SCRIPT_DIR/reports"
TIMESTAMP=$(date +%Y-%m-%d_%H-%M-%S)
LOG_FILE="$LOG_DIR/test_run_$TIMESTAMP.log"
REPORT_FILE="$REPORT_DIR/test_report_$TIMESTAMP.json"

# Couleurs pour l'affichage
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Variables globales
VERBOSE=false
DEBUG=false
SKIP_UNIT=false
SKIP_INTEGRATION=false
SKIP_CONNECTIVITY=false
SKIP_EXTERNAL=false
SKIP_PERFORMANCE=true  # Par défaut, on ignore les tests de performance

# Fonctions utilitaires
log() {
    local level="$1"
    shift
    local message="$*"
    local timestamp=$(date +%Y-%m-%d\ %H:%M:%S)

    case "$level" in
        "INFO")
            echo -e "${BLUE}[$timestamp] INFO:${NC} $message" | tee -a "$LOG_FILE"
            ;;
        "SUCCESS")
            echo -e "${GREEN}[$timestamp] SUCCESS:${NC} $message" | tee -a "$LOG_FILE"
            ;;
        "WARNING")
            echo -e "${YELLOW}[$timestamp] WARNING:${NC} $message" | tee -a "$LOG_FILE"
            ;;
        "ERROR")
            echo -e "${RED}[$timestamp] ERROR:${NC} $message" | tee -a "$LOG_FILE"
            ;;
        "DEBUG")
            if [ "$DEBUG" = true ]; then
                echo -e "${YELLOW}[$timestamp] DEBUG:${NC} $message" | tee -a "$LOG_FILE"
            fi
            ;;
    esac
}

# Afficher l'aide
show_help() {
    cat << EOF
Usage: $0 [OPTIONS]

Options:
    -h, --help              Afficher cette aide
    -v, --verbose           Mode verbose
    -d, --debug             Mode debug
    --skip-unit             Ignorer les tests unitaires
    --skip-integration      Ignorer les tests d'intégration
    --skip-connectivity     Ignorer les tests de connectivité
    --skip-external         Ignorer les tests externes
    --skip-performance      Ignorer les tests de performance
    --include-performance   Inclure les tests de performance

Exemples:
    $0                      # Exécuter tous les tests
    $0 --verbose            # Mode verbose
    $0 --skip-external      # Ignorer les tests externes
    $0 --debug              # Mode debug complet
EOF
}

# Vérifier les prérequis
check_prerequisites() {
    log "INFO" "Vérification des prérequis..."

    # Vérifier Docker
    if ! command -v docker &> /dev/null; then
        log "ERROR" "Docker n'est pas installé"
        exit 1
    fi

    # Vérifier Docker Compose
    if ! command -v docker-compose &> /dev/null; then
        log "WARNING" "Docker Compose n'est pas installé, utilisation de docker compose"
    fi

    # Vérifier Python
    if ! command -v python3 &> /dev/null; then
        log "ERROR" "Python3 n'est pas installé"
        exit 1
    fi

    # Vérifier les répertoires
    mkdir -p "$LOG_DIR" "$REPORT_DIR"

    # Vérifier que les services sont démarrés
    if ! docker ps | grep -q "bitcoin"; then
        log "WARNING" "Bitcoin Core n'est pas démarré"
    fi

    if ! docker ps | grep -q "blindbit"; then
        log "WARNING" "Blindbit n'est pas démarré"
    fi

    if ! docker ps | grep -q "sdk_relay"; then
        log "WARNING" "sdk_relay n'est pas démarré"
    fi

    log "SUCCESS" "Prérequis vérifiés"
}

# Exécuter les tests unitaires
run_unit_tests() {
    if [ "$SKIP_UNIT" = true ]; then
        log "INFO" "Tests unitaires ignorés"
        return 0
    fi

    log "INFO" "Début des tests unitaires..."
    cd "$SCRIPT_DIR/unit"

    local unit_tests=(
        "test_healthcheck.sh"
        "test_docker.sh"
        "test_simple.sh"
        "test_final.sh"
    )

    local unit_results=()

    for test in "${unit_tests[@]}"; do
        if [ -f "$test" ]; then
            log "INFO" "Exécution de $test"
            if [ "$VERBOSE" = true ]; then
                if ./"$test" 2>&1 | tee -a "$LOG_FILE"; then
                    unit_results+=("$test:SUCCESS")
                    log "SUCCESS" "$test terminé avec succès"
                else
                    unit_results+=("$test:FAILED")
                    log "ERROR" "$test a échoué"
                fi
            else
                if ./"$test" >> "$LOG_FILE" 2>&1; then
                    unit_results+=("$test:SUCCESS")
                    log "SUCCESS" "$test terminé avec succès"
                else
                    unit_results+=("$test:FAILED")
                    log "ERROR" "$test a échoué"
                fi
            fi
        else
            log "WARNING" "Test $test non trouvé"
        fi
    done

    # Afficher le résumé des tests unitaires
    log "INFO" "Résumé des tests unitaires:"
    for result in "${unit_results[@]}"; do
        if [[ "$result" == *":SUCCESS" ]]; then
            log "SUCCESS" "  ✅ ${result%:SUCCESS}"
        else
            log "ERROR" "  ❌ ${result%:FAILED}"
        fi
    done

    cd "$PROJECT_ROOT"
}

# Exécuter les tests d'intégration
run_integration_tests() {
    if [ "$SKIP_INTEGRATION" = true ]; then
        log "INFO" "Tests d'intégration ignorés"
        return 0
    fi

    log "INFO" "Début des tests d'intégration..."
    cd "$SCRIPT_DIR/integration"

    local integration_tests=(
        "test_3_relays.sh"
        "test_final_sync.sh"
        "test_sync_logs.sh"
        "test_messages.sh"
    )

    local integration_results=()

    for test in "${integration_tests[@]}"; do
        if [ -f "$test" ]; then
            log "INFO" "Exécution de $test"
            if [ "$VERBOSE" = true ]; then
                if ./"$test" 2>&1 | tee -a "$LOG_FILE"; then
                    integration_results+=("$test:SUCCESS")
                    log "SUCCESS" "$test terminé avec succès"
                else
                    integration_results+=("$test:FAILED")
                    log "ERROR" "$test a échoué"
                fi
            else
                if ./"$test" >> "$LOG_FILE" 2>&1; then
                    integration_results+=("$test:SUCCESS")
                    log "SUCCESS" "$test terminé avec succès"
                else
                    integration_results+=("$test:FAILED")
                    log "ERROR" "$test a échoué"
                fi
            fi
        else
            log "WARNING" "Test $test non trouvé"
        fi
    done

    # Afficher le résumé des tests d'intégration
    log "INFO" "Résumé des tests d'intégration:"
    for result in "${integration_results[@]}"; do
        if [[ "$result" == *":SUCCESS" ]]; then
            log "SUCCESS" "  ✅ ${result%:SUCCESS}"
        else
            log "ERROR" "  ❌ ${result%:FAILED}"
        fi
    done

    cd "$PROJECT_ROOT"
}

# Exécuter les tests de connectivité
run_connectivity_tests() {
    if [ "$SKIP_CONNECTIVITY" = true ]; then
        log "INFO" "Tests de connectivité ignorés"
        return 0
    fi

    log "INFO" "Début des tests de connectivité..."
    cd "$SCRIPT_DIR/connectivity"

    local connectivity_results=()

    # Test de connectivité shell
    if [ -f "test_connectivity.sh" ]; then
        log "INFO" "Exécution de test_connectivity.sh"
        if [ "$VERBOSE" = true ]; then
            if ./test_connectivity.sh 2>&1 | tee -a "$LOG_FILE"; then
                connectivity_results+=("test_connectivity.sh:SUCCESS")
                log "SUCCESS" "test_connectivity.sh terminé avec succès"
            else
                connectivity_results+=("test_connectivity.sh:FAILED")
                log "ERROR" "test_connectivity.sh a échoué"
            fi
        else
            if ./test_connectivity.sh >> "$LOG_FILE" 2>&1; then
                connectivity_results+=("test_connectivity.sh:SUCCESS")
                log "SUCCESS" "test_connectivity.sh terminé avec succès"
            else
                connectivity_results+=("test_connectivity.sh:FAILED")
                log "ERROR" "test_connectivity.sh a échoué"
            fi
        fi
    fi

    # Test WebSocket Python
    if [ -f "test_websocket_messages.py" ]; then
        log "INFO" "Exécution de test_websocket_messages.py"
        if [ "$VERBOSE" = true ]; then
            if python3 test_websocket_messages.py 2>&1 | tee -a "$LOG_FILE"; then
                connectivity_results+=("test_websocket_messages.py:SUCCESS")
                log "SUCCESS" "test_websocket_messages.py terminé avec succès"
            else
                connectivity_results+=("test_websocket_messages.py:FAILED")
                log "ERROR" "test_websocket_messages.py a échoué"
            fi
        else
            if python3 test_websocket_messages.py >> "$LOG_FILE" 2>&1; then
                connectivity_results+=("test_websocket_messages.py:SUCCESS")
                log "SUCCESS" "test_websocket_messages.py terminé avec succès"
            else
                connectivity_results+=("test_websocket_messages.py:FAILED")
                log "ERROR" "test_websocket_messages.py a échoué"
            fi
        fi
    fi

    # Afficher le résumé des tests de connectivité
    log "INFO" "Résumé des tests de connectivité:"
    for result in "${connectivity_results[@]}"; do
        if [[ "$result" == *":SUCCESS" ]]; then
            log "SUCCESS" "  ✅ ${result%:SUCCESS}"
        else
            log "ERROR" "  ❌ ${result%:FAILED}"
        fi
    done

    cd "$PROJECT_ROOT"
}

# Exécuter les tests externes
run_external_tests() {
    if [ "$SKIP_EXTERNAL" = true ]; then
        log "INFO" "Tests externes ignorés"
        return 0
    fi

    log "INFO" "Début des tests externes..."
    cd "$SCRIPT_DIR/external"

    local external_results=()

    # Test simple dev3
    if [ -f "test_dev3_simple.py" ]; then
        log "INFO" "Exécution de test_dev3_simple.py"
        if [ "$VERBOSE" = true ]; then
            if python3 test_dev3_simple.py 2>&1 | tee -a "$LOG_FILE"; then
                external_results+=("test_dev3_simple.py:SUCCESS")
                log "SUCCESS" "test_dev3_simple.py terminé avec succès"
            else
                external_results+=("test_dev3_simple.py:FAILED")
                log "ERROR" "test_dev3_simple.py a échoué"
            fi
        else
            if python3 test_dev3_simple.py >> "$LOG_FILE" 2>&1; then
                external_results+=("test_dev3_simple.py:SUCCESS")
                log "SUCCESS" "test_dev3_simple.py terminé avec succès"
            else
                external_results+=("test_dev3_simple.py:FAILED")
                log "ERROR" "test_dev3_simple.py a échoué"
            fi
        fi
    fi

    # Test de connectivité dev3
    if [ -f "test_dev3_connectivity.py" ]; then
        log "INFO" "Exécution de test_dev3_connectivity.py"
        if [ "$VERBOSE" = true ]; then
            if python3 test_dev3_connectivity.py 2>&1 | tee -a "$LOG_FILE"; then
                external_results+=("test_dev3_connectivity.py:SUCCESS")
                log "SUCCESS" "test_dev3_connectivity.py terminé avec succès"
            else
                external_results+=("test_dev3_connectivity.py:FAILED")
                log "ERROR" "test_dev3_connectivity.py a échoué"
            fi
        else
            if python3 test_dev3_connectivity.py >> "$LOG_FILE" 2>&1; then
                external_results+=("test_dev3_connectivity.py:SUCCESS")
                log "SUCCESS" "test_dev3_connectivity.py terminé avec succès"
            else
                external_results+=("test_dev3_connectivity.py:FAILED")
                log "ERROR" "test_dev3_connectivity.py a échoué"
            fi
        fi
    fi

    # Test d'intégration dev3
    if [ -f "test_integration_dev3.sh" ]; then
        log "INFO" "Exécution de test_integration_dev3.sh"
        if [ "$VERBOSE" = true ]; then
            if ./test_integration_dev3.sh 2>&1 | tee -a "$LOG_FILE"; then
                external_results+=("test_integration_dev3.sh:SUCCESS")
                log "SUCCESS" "test_integration_dev3.sh terminé avec succès"
            else
                external_results+=("test_integration_dev3.sh:FAILED")
                log "ERROR" "test_integration_dev3.sh a échoué"
            fi
        else
            if ./test_integration_dev3.sh >> "$LOG_FILE" 2>&1; then
                external_results+=("test_integration_dev3.sh:SUCCESS")
                log "SUCCESS" "test_integration_dev3.sh terminé avec succès"
            else
                external_results+=("test_integration_dev3.sh:FAILED")
                log "ERROR" "test_integration_dev3.sh a échoué"
            fi
        fi
    fi

    # Afficher le résumé des tests externes
    log "INFO" "Résumé des tests externes:"
    for result in "${external_results[@]}"; do
        if [[ "$result" == *":SUCCESS" ]]; then
            log "SUCCESS" "  ✅ ${result%:SUCCESS}"
        else
            log "ERROR" "  ❌ ${result%:FAILED}"
        fi
    done

    cd "$PROJECT_ROOT"
}

# Générer le rapport final
generate_report() {
    log "INFO" "Génération du rapport final..."

    local total_tests=0
    local successful_tests=0
    local failed_tests=0

    # Compter les résultats (simplifié pour cet exemple)
    # En pratique, on collecterait les résultats de chaque fonction

    cat > "$REPORT_FILE" << EOF
{
    "timestamp": "$TIMESTAMP",
    "summary": {
        "total_tests": $total_tests,
        "successful_tests": $successful_tests,
        "failed_tests": $failed_tests,
        "success_rate": $(echo "scale=2; $successful_tests * 100 / $total_tests" | bc 2>/dev/null || echo "0")
    },
    "log_file": "$LOG_FILE",
    "options": {
        "verbose": $VERBOSE,
        "debug": $DEBUG,
        "skip_unit": $SKIP_UNIT,
        "skip_integration": $SKIP_INTEGRATION,
        "skip_connectivity": $SKIP_CONNECTIVITY,
        "skip_external": $SKIP_EXTERNAL,
        "skip_performance": $SKIP_PERFORMANCE
    }
}
EOF

    log "SUCCESS" "Rapport généré: $REPORT_FILE"
}

# Fonction principale
main() {
    log "INFO" "=== Début de l'exécution des tests 4NK Node ==="
    log "INFO" "Timestamp: $TIMESTAMP"
    log "INFO" "Répertoire de travail: $PROJECT_ROOT"

    # Vérifier les prérequis
    check_prerequisites

    # Exécuter les tests dans l'ordre
    run_unit_tests
    run_integration_tests
    run_connectivity_tests
    run_external_tests

    # Générer le rapport
    generate_report

    log "SUCCESS" "=== Exécution des tests terminée ==="
    log "INFO" "Logs: $LOG_FILE"
    log "INFO" "Rapport: $REPORT_FILE"
}

# Traitement des arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help)
            show_help
            exit 0
            ;;
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -d|--debug)
            DEBUG=true
            VERBOSE=true
            shift
            ;;
        --skip-unit)
            SKIP_UNIT=true
            shift
            ;;
        --skip-integration)
            SKIP_INTEGRATION=true
            shift
            ;;
        --skip-connectivity)
            SKIP_CONNECTIVITY=true
            shift
            ;;
        --skip-external)
            SKIP_EXTERNAL=true
            shift
            ;;
        --skip-performance)
            SKIP_PERFORMANCE=true
            shift
            ;;
        --include-performance)
            SKIP_PERFORMANCE=false
            shift
            ;;
        *)
            log "ERROR" "Option inconnue: $1"
            show_help
            exit 1
            ;;
    esac
done

# Exécution principale
main "$@"