#!/bin/bash

# Script de test pour le Checkpoint 25
# Vérifie que tous les tests passent après l'implémentation des templates

echo "=========================================="
echo "Checkpoint 25 - Tests Phase 7"
echo "Templates et Réutilisabilité"
echo "=========================================="
echo ""

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

# Compteurs
TESTS_PASSED=0
TESTS_FAILED=0
WARNINGS=0

# Fonction de test
test_file() {
    local file=$1
    local description=$2
    
    if [ -f "$file" ]; then
        echo -e "${GREEN}✓${NC} $description"
        ((TESTS_PASSED++))
        return 0
    else
        echo -e "${RED}✗${NC} $description"
        echo "   Fichier manquant: $file"
        ((TESTS_FAILED++))
        return 1
    fi
}

# Fonction de test de contenu
test_content() {
    local file=$1
    local pattern=$2
    local description=$3
    
    if [ -f "$file" ] && grep -q "$pattern" "$file"; then
        echo -e "${GREEN}✓${NC} $description"
        ((TESTS_PASSED++))
        return 0
    else
        echo -e "${RED}✗${NC} $description"
        ((TESTS_FAILED++))
        return 1
    fi
}

# Fonction d'avertissement
warn() {
    local message=$1
    echo -e "${YELLOW}⚠${NC} $message"
    ((WARNINGS++))
}

# Fonction de test d'API
test_api() {
    local url=$1
    local description=$2
    local expected_status=${3:-200}
    
    local response=$(curl -s -w "%{http_code}" "$url" 2>/dev/null)
    local status_code="${response: -3}"
    
    if [ "$status_code" = "$expected_status" ]; then
        echo -e "${GREEN}✓${NC} $description (HTTP $status_code)"
        ((TESTS_PASSED++))
        return 0
    else
        echo -e "${RED}✗${NC} $description (HTTP $status_code, attendu $expected_status)"
        ((TESTS_FAILED++))
        return 1
    fi
}

echo -e "${BLUE}Phase 7: Templates et Réutilisabilité${NC}"
echo "-------------------------------------"
echo ""

echo "1. Vérification des fichiers de templates"
echo "------------------------------------------"

test_file "backend/models/template.py" \
    "Modèle WorkflowTemplate créé"

test_file "backend/services/template_service.py" \
    "Service de templates créé"

test_file "backend/api/templates.py" \
    "API endpoints templates créés"

test_file "frontend/src/components/TemplateSelector/index.tsx" \
    "Composant TemplateSelector créé"

test_file "frontend/src/components/SaveAsTemplate/index.tsx" \
    "Composant SaveAsTemplate créé"

echo ""
echo "2. Vérification du contenu des templates"
echo "-----------------------------------------"

test_content "backend/models/template.py" \
    "class WorkflowTemplate" \
    "Classe WorkflowTemplate définie"

test_content "backend/services/template_service.py" \
    "create_template" \
    "Méthode create_template implémentée"

test_content "backend/services/template_service.py" \
    "instantiate_template" \
    "Méthode instantiate_template implémentée"

test_content "backend/api/templates.py" \
    "@templates_bp.route" \
    "Routes API templates définies"

echo ""
echo "3. Vérification des tests"
echo "-------------------------"

test_file "backend/test_templates.py" \
    "Tests templates créés"

test_file "backend/test_save_as_template.py" \
    "Tests save-as-template créés"

test_file "backend/test_templates_simple.py" \
    "Tests templates simples créés"

echo ""
echo "4. Préparation de l'environnement de test"
echo "------------------------------------------"

# Aller dans le répertoire backend
cd backend

# Vérifier l'environnement virtuel
if [ ! -d "venv" ]; then
    echo -e "${RED}✗${NC} Environnement virtuel manquant"
    ((TESTS_FAILED++))
    cd ..
    exit 1
else
    echo -e "${GREEN}✓${NC} Environnement virtuel trouvé"
    ((TESTS_PASSED++))
fi

# Activer l'environnement virtuel
source venv/bin/activate

# Vérifier les dépendances Flask
if python -c "import flask" 2>/dev/null; then
    echo -e "${GREEN}✓${NC} Flask disponible"
    ((TESTS_PASSED++))
else
    echo -e "${YELLOW}⚠${NC} Installation de Flask..."
    pip install -q flask flask-socketio flask-cors
    if python -c "import flask" 2>/dev/null; then
        echo -e "${GREEN}✓${NC} Flask installé avec succès"
        ((TESTS_PASSED++))
    else
        echo -e "${RED}✗${NC} Échec de l'installation de Flask"
        ((TESTS_FAILED++))
    fi
fi

# Ajouter le répertoire parent au PYTHONPATH pour les imports
export PYTHONPATH="$PYTHONPATH:../.."

echo ""
echo "5. Tests unitaires Python"
echo "--------------------------"

# Test des modèles
echo "Test des modèles de templates..."
if python -c "
import sys
sys.path.insert(0, '.')
sys.path.insert(0, '../..')
try:
    from models.template import WorkflowTemplate
    print('✓ Import WorkflowTemplate réussi')
except Exception as e:
    print(f'✗ Erreur import WorkflowTemplate: {e}')
    sys.exit(1)
" 2>/dev/null; then
    echo -e "${GREEN}✓${NC} Modèles de templates importables"
    ((TESTS_PASSED++))
else
    warn "Modèles de templates non importables"
fi

# Test des services
echo "Test des services de templates..."
if python -c "
import sys
sys.path.insert(0, '.')
sys.path.insert(0, '../..')
try:
    from services.template_service import TemplateService
    print('✓ Import TemplateService réussi')
except Exception as e:
    print(f'✗ Erreur import TemplateService: {e}')
    sys.exit(1)
" 2>/dev/null; then
    echo -e "${GREEN}✓${NC} Services de templates importables"
    ((TESTS_PASSED++))
else
    warn "Services de templates non importables"
fi

echo ""
echo "6. Test du serveur backend"
echo "--------------------------"

# Créer .env si nécessaire
if [ ! -f ".env" ]; then
    cp .env.example .env
    echo -e "${GREEN}✓${NC} Fichier .env créé"
    ((TESTS_PASSED++))
fi

# Démarrer le serveur en arrière-plan
echo "Démarrage du serveur backend..."
python app.py > server_test.log 2>&1 &
SERVER_PID=$!

# Attendre que le serveur démarre
sleep 5

# Vérifier si le serveur est en cours d'exécution
if kill -0 $SERVER_PID 2>/dev/null; then
    echo -e "${GREEN}✓${NC} Serveur backend démarré (PID: $SERVER_PID)"
    ((TESTS_PASSED++))
    
    # Attendre un peu plus pour que le serveur soit prêt
    sleep 3
    
    echo ""
    echo "7. Tests des endpoints API"
    echo "--------------------------"
    
    # Test endpoint health
    test_api "http://localhost:5001/health" "Endpoint /health"
    
    # Test endpoint templates
    test_api "http://localhost:5001/api/templates/" "Endpoint /api/templates"
    
    # Test endpoint node-types
    test_api "http://localhost:5001/api/node-types/" "Endpoint /api/node-types"
    
    # Test endpoint workflows
    test_api "http://localhost:5001/api/workflows/" "Endpoint /api/workflows"
    
    echo ""
    echo "8. Tests spécifiques aux templates"
    echo "----------------------------------"
    
    # Test création de template
    echo "Test de création de template..."
    TEMPLATE_RESPONSE=$(curl -s -X POST \
        -H "Content-Type: application/json" \
        -d '{
            "name": "Test Template",
            "description": "Template de test",
            "category": "test",
            "workflow": {
                "nodes": [],
                "edges": [],
                "variables": []
            },
            "parameters": []
        }' \
        http://localhost:5001/api/templates/ 2>/dev/null)
    
    if [ $? -eq 0 ] && echo "$TEMPLATE_RESPONSE" | grep -q "id"; then
        echo -e "${GREEN}✓${NC} Création de template réussie"
        ((TESTS_PASSED++))
        
        # Extraire l'ID du template créé
        TEMPLATE_ID=$(echo "$TEMPLATE_RESPONSE" | grep -o '"id":"[^"]*"' | cut -d'"' -f4)
        
        if [ ! -z "$TEMPLATE_ID" ]; then
            # Test récupération du template
            test_api "http://localhost:5001/api/templates/$TEMPLATE_ID" "Récupération template créé"
            
            # Test instantiation du template
            echo "Test d'instantiation de template..."
            INSTANCE_RESPONSE=$(curl -s -X POST \
                -H "Content-Type: application/json" \
                -d '{"parameters": {}}' \
                http://localhost:5001/api/templates/$TEMPLATE_ID/instantiate 2>/dev/null)
            
            if [ $? -eq 0 ] && echo "$INSTANCE_RESPONSE" | grep -q "workflow"; then
                echo -e "${GREEN}✓${NC} Instantiation de template réussie"
                ((TESTS_PASSED++))
            else
                echo -e "${RED}✗${NC} Échec de l'instantiation de template"
                ((TESTS_FAILED++))
            fi
        fi
    else
        echo -e "${RED}✗${NC} Échec de la création de template"
        ((TESTS_FAILED++))
    fi
    
    # Arrêter le serveur
    echo ""
    echo "Arrêt du serveur..."
    kill $SERVER_PID 2>/dev/null
    wait $SERVER_PID 2>/dev/null
    echo -e "${GREEN}✓${NC} Serveur arrêté"
    ((TESTS_PASSED++))
    
else
    echo -e "${RED}✗${NC} Échec du démarrage du serveur"
    echo "Vérifiez server_test.log pour plus de détails:"
    tail -10 server_test.log
    ((TESTS_FAILED++))
fi

# Retourner au répertoire parent
cd ..

echo ""
echo "9. Vérification des exigences Phase 7"
echo "--------------------------------------"

# Exigence 11.1: Templates pré-définis
test_content "backend/services/template_service.py" \
    "default_templates" \
    "Exigence 11.1: Templates pré-définis"

# Exigence 11.2: Chargement de templates
test_content "backend/services/template_service.py" \
    "instantiate_template" \
    "Exigence 11.2: Chargement de templates"

# Exigence 11.3: Substitution de paramètres
test_content "backend/services/template_service.py" \
    "substitute_parameters" \
    "Exigence 11.3: Substitution de paramètres"

# Exigence 11.4: UI de sélection
test_file "frontend/src/components/TemplateSelector/index.tsx" \
    "Exigence 11.4: UI de sélection de templates"

# Exigence 11.5: Sauvegarde comme template
test_file "frontend/src/components/SaveAsTemplate/index.tsx" \
    "Exigence 11.5: Sauvegarde comme template"

echo ""
echo "10. Documentation"
echo "-----------------"

test_file "TASK_23_COMPLETE.md" \
    "Documentation tâche 23"

test_file "TASK_24_COMPLETE.md" \
    "Documentation tâche 24"

echo ""
echo "=========================================="
echo "Résumé du Checkpoint 25"
echo "=========================================="
echo -e "Tests réussis: ${GREEN}$TESTS_PASSED${NC}"
echo -e "Tests échoués: ${RED}$TESTS_FAILED${NC}"
echo -e "Avertissements: ${YELLOW}$WARNINGS${NC}"
echo ""

if [ $TESTS_FAILED -eq 0 ]; then
    echo -e "${GREEN}✅ Checkpoint 25 RÉUSSI !${NC}"
    echo ""
    echo "Phase 7 (Templates et Réutilisabilité) complète :"
    echo "  ✓ Système de templates implémenté"
    echo "  ✓ Templates pré-définis disponibles"
    echo "  ✓ Sauvegarde comme template fonctionnelle"
    echo "  ✓ API templates complète"
    echo "  ✓ Interface utilisateur templates"
    echo ""
    
    if [ $WARNINGS -gt 0 ]; then
        echo -e "${YELLOW}Note:${NC} $WARNINGS avertissement(s) détecté(s)"
        echo "Ces avertissements n'empêchent pas le passage au checkpoint suivant."
        echo ""
    fi
    
    echo "Prêt pour la Phase 8 : Fonctionnalités Avancées"
    echo ""
    exit 0
else
    echo -e "${RED}❌ Checkpoint 25 ÉCHOUÉ${NC}"
    echo ""
    echo "Veuillez corriger les erreurs avant de continuer."
    echo ""
    exit 1
fi