rpa_vision_v3/visual_workflow_builder/launch.sh

#!/bin/bash

# Script de lancement principal pour Visual Workflow Builder
# Simplifie le démarrage et l'arrêt de l'application complète

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"

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

# Fonction d'aide
show_help() {
    echo -e "${BLUE}Visual Workflow Builder - Script de Lancement${NC}"
    echo ""
    echo "Usage: $0 [COMMAND] [OPTIONS]"
    echo ""
    echo -e "${YELLOW}Commandes:${NC}"
    echo "  start       Démarrer l'application complète (backend + frontend)"
    echo "  stop        Arrêter l'application complète"
    echo "  restart     Redémarrer l'application complète"
    echo "  status      Afficher le statut des services"
    echo "  logs        Afficher les logs en temps réel"
    echo "  test        Lancer les tests"
    echo "  setup       Configuration initiale"
    echo "  clean       Nettoyer les fichiers temporaires"
    echo ""
    echo -e "${YELLOW}Options:${NC}"
    echo "  --dev       Mode développement (avec hot reload)"
    echo "  --prod      Mode production"
    echo "  --port      Port personnalisé pour le frontend (défaut: 3000)"
    echo "  --backend-port  Port personnalisé pour le backend (défaut: 5001)"
    echo "  --help      Afficher cette aide"
    echo ""
    echo -e "${YELLOW}Exemples:${NC}"
    echo "  $0 start --dev          # Démarrer en mode développement"
    echo "  $0 start --prod         # Démarrer en mode production"
    echo "  $0 test                 # Lancer tous les tests"
    echo "  $0 status               # Vérifier le statut"
    echo ""
}

# Variables par défaut
MODE="dev"
FRONTEND_PORT=3000
BACKEND_PORT=5001
COMMAND=""

# Parser les arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        start|stop|restart|status|logs|test|setup|clean)
            COMMAND="$1"
            shift
            ;;
        --dev)
            MODE="dev"
            shift
            ;;
        --prod)
            MODE="prod"
            shift
            ;;
        --port)
            FRONTEND_PORT="$2"
            shift 2
            ;;
        --backend-port)
            BACKEND_PORT="$2"
            shift 2
            ;;
        --help)
            show_help
            exit 0
            ;;
        *)
            echo -e "${RED}Option inconnue: $1${NC}"
            show_help
            exit 1
            ;;
    esac
done

# Si aucune commande, afficher l'aide
if [ -z "$COMMAND" ]; then
    show_help
    exit 1
fi

# Fichiers PID pour tracking des processus
BACKEND_PID_FILE="$SCRIPT_DIR/.backend.pid"
FRONTEND_PID_FILE="$SCRIPT_DIR/.frontend.pid"

# Fonction pour vérifier si un processus est en cours
is_running() {
    local pid_file="$1"
    if [ -f "$pid_file" ]; then
        local pid=$(cat "$pid_file")
        if ps -p "$pid" > /dev/null 2>&1; then
            return 0
        else
            rm -f "$pid_file"
            return 1
        fi
    fi
    return 1
}

# Fonction pour arrêter un processus
stop_process() {
    local pid_file="$1"
    local name="$2"
    
    if is_running "$pid_file"; then
        local pid=$(cat "$pid_file")
        echo -e "${YELLOW}Arrêt de $name (PID: $pid)...${NC}"
        
        # Essayer d'abord SIGTERM
        kill "$pid" 2>/dev/null || true
        
        # Attendre un peu
        sleep 2
        
        # Si toujours en cours, forcer avec SIGKILL
        if ps -p "$pid" > /dev/null 2>&1; then
            echo -e "${YELLOW}Force l'arrêt de $name...${NC}"
            kill -9 "$pid" 2>/dev/null || true
        fi
        
        rm -f "$pid_file"
        echo -e "${GREEN}$name arrêté${NC}"
    else
        echo -e "${CYAN}$name n'est pas en cours d'exécution${NC}"
    fi
}

# Fonction pour démarrer le backend
start_backend() {
    if is_running "$BACKEND_PID_FILE"; then
        echo -e "${CYAN}Backend déjà en cours d'exécution${NC}"
        return 0
    fi
    
    echo -e "${BLUE}Démarrage du backend sur le port $BACKEND_PORT...${NC}"
    
    cd backend
    
    # Vérifier l'environnement virtuel
    if [ ! -d "venv" ]; then
        echo -e "${YELLOW}Création de l'environnement virtuel...${NC}"
        python3 -m venv venv
    fi
    
    # Activer l'environnement virtuel
    source venv/bin/activate
    
    # Installer les dépendances si nécessaire
    if [ ! -f ".deps_installed" ] || [ "requirements.txt" -nt ".deps_installed" ]; then
        echo -e "${YELLOW}Installation des dépendances Python...${NC}"
        pip install -r requirements.txt
        touch .deps_installed
    fi
    
    # Démarrer le backend
    export PORT="$BACKEND_PORT"
    export FLASK_ENV="$MODE"
    
    if [ "$MODE" = "dev" ]; then
        python app.py > ../backend.log 2>&1 &
    else
        gunicorn --bind 0.0.0.0:$BACKEND_PORT --workers 4 app:app > ../backend.log 2>&1 &
    fi
    
    echo $! > "$BACKEND_PID_FILE"
    cd ..
    
    # Attendre que le backend soit prêt
    echo -e "${YELLOW}Attente du démarrage du backend...${NC}"
    for i in {1..30}; do
        if curl -s "http://localhost:$BACKEND_PORT/health" > /dev/null 2>&1; then
            echo -e "${GREEN}Backend démarré avec succès sur le port $BACKEND_PORT${NC}"
            return 0
        fi
        sleep 1
    done
    
    echo -e "${RED}Échec du démarrage du backend${NC}"
    return 1
}

# Fonction pour démarrer le frontend
start_frontend() {
    if is_running "$FRONTEND_PID_FILE"; then
        echo -e "${CYAN}Frontend déjà en cours d'exécution${NC}"
        return 0
    fi
    
    echo -e "${BLUE}Démarrage du frontend sur le port $FRONTEND_PORT...${NC}"
    
    cd frontend
    
    # Installer les dépendances si nécessaire
    if [ ! -d "node_modules" ] || [ "package.json" -nt "node_modules/.package-lock.json" ]; then
        echo -e "${YELLOW}Installation des dépendances Node.js...${NC}"
        npm install
        touch node_modules/.package-lock.json
    fi
    
    # Configurer les variables d'environnement
    export PORT="$FRONTEND_PORT"
    export REACT_APP_API_URL="http://localhost:$BACKEND_PORT"
    
    if [ "$MODE" = "dev" ]; then
        npm start > ../frontend.log 2>&1 &
    else
        # Build et serve en production
        if [ ! -d "build" ] || [ "src" -nt "build" ]; then
            echo -e "${YELLOW}Build de production...${NC}"
            npm run build
        fi
        npx serve -s build -l $FRONTEND_PORT > ../frontend.log 2>&1 &
    fi
    
    echo $! > "$FRONTEND_PID_FILE"
    cd ..
    
    # Attendre que le frontend soit prêt
    echo -e "${YELLOW}Attente du démarrage du frontend...${NC}"
    for i in {1..60}; do
        if curl -s "http://localhost:$FRONTEND_PORT" > /dev/null 2>&1; then
            echo -e "${GREEN}Frontend démarré avec succès sur le port $FRONTEND_PORT${NC}"
            return 0
        fi
        sleep 1
    done
    
    echo -e "${RED}Échec du démarrage du frontend${NC}"
    return 1
}

# Commande START
cmd_start() {
    echo -e "${PURPLE}🚀 Démarrage de Visual Workflow Builder${NC}"
    echo -e "${CYAN}Mode: $MODE${NC}"
    echo -e "${CYAN}Frontend: http://localhost:$FRONTEND_PORT${NC}"
    echo -e "${CYAN}Backend: http://localhost:$BACKEND_PORT${NC}"
    echo ""
    
    # Démarrer le backend
    if ! start_backend; then
        echo -e "${RED}Échec du démarrage du backend${NC}"
        exit 1
    fi
    
    # Démarrer le frontend
    if ! start_frontend; then
        echo -e "${RED}Échec du démarrage du frontend${NC}"
        stop_process "$BACKEND_PID_FILE" "Backend"
        exit 1
    fi
    
    echo ""
    echo -e "${GREEN}✅ Application démarrée avec succès!${NC}"
    echo -e "${CYAN}🌐 Ouvrez http://localhost:$FRONTEND_PORT dans votre navigateur${NC}"
    echo -e "${CYAN}📊 API disponible sur http://localhost:$BACKEND_PORT${NC}"
    echo ""
    echo -e "${YELLOW}Pour arrêter: $0 stop${NC}"
    echo -e "${YELLOW}Pour voir les logs: $0 logs${NC}"
    echo -e "${YELLOW}Pour voir le statut: $0 status${NC}"
}

# Commande STOP
cmd_stop() {
    echo -e "${PURPLE}🛑 Arrêt de Visual Workflow Builder${NC}"
    
    stop_process "$FRONTEND_PID_FILE" "Frontend"
    stop_process "$BACKEND_PID_FILE" "Backend"
    
    echo -e "${GREEN}✅ Application arrêtée${NC}"
}

# Commande RESTART
cmd_restart() {
    echo -e "${PURPLE}🔄 Redémarrage de Visual Workflow Builder${NC}"
    cmd_stop
    sleep 2
    cmd_start
}

# Commande STATUS
cmd_status() {
    echo -e "${PURPLE}📊 Statut de Visual Workflow Builder${NC}"
    echo ""
    
    # Statut du backend
    if is_running "$BACKEND_PID_FILE"; then
        local backend_pid=$(cat "$BACKEND_PID_FILE")
        echo -e "${GREEN}✅ Backend: En cours (PID: $backend_pid, Port: $BACKEND_PORT)${NC}"
        
        # Test de santé
        if curl -s "http://localhost:$BACKEND_PORT/health" > /dev/null 2>&1; then
            echo -e "${GREEN}   API: Répondant${NC}"
        else
            echo -e "${RED}   API: Non répondant${NC}"
        fi
    else
        echo -e "${RED}❌ Backend: Arrêté${NC}"
    fi
    
    # Statut du frontend
    if is_running "$FRONTEND_PID_FILE"; then
        local frontend_pid=$(cat "$FRONTEND_PID_FILE")
        echo -e "${GREEN}✅ Frontend: En cours (PID: $frontend_pid, Port: $FRONTEND_PORT)${NC}"
        
        # Test de santé
        if curl -s "http://localhost:$FRONTEND_PORT" > /dev/null 2>&1; then
            echo -e "${GREEN}   Interface: Accessible${NC}"
        else
            echo -e "${RED}   Interface: Non accessible${NC}"
        fi
    else
        echo -e "${RED}❌ Frontend: Arrêté${NC}"
    fi
    
    echo ""
    
    # Informations système
    echo -e "${CYAN}💻 Informations système:${NC}"
    echo "   OS: $(uname -s)"
    echo "   Python: $(python3 --version 2>/dev/null || echo 'Non installé')"
    echo "   Node.js: $(node --version 2>/dev/null || echo 'Non installé')"
    echo "   npm: $(npm --version 2>/dev/null || echo 'Non installé')"
}

# Commande LOGS
cmd_logs() {
    echo -e "${PURPLE}📋 Logs de Visual Workflow Builder${NC}"
    echo -e "${YELLOW}Appuyez sur Ctrl+C pour arrêter${NC}"
    echo ""
    
    # Créer les fichiers de log s'ils n'existent pas
    touch backend.log frontend.log
    
    # Suivre les logs en temps réel
    tail -f backend.log frontend.log
}

# Commande TEST
cmd_test() {
    echo -e "${PURPLE}🧪 Tests de Visual Workflow Builder${NC}"
    echo ""
    
    # Vérifier que l'application est démarrée
    if ! is_running "$BACKEND_PID_FILE" || ! is_running "$FRONTEND_PID_FILE"; then
        echo -e "${YELLOW}Démarrage de l'application pour les tests...${NC}"
        cmd_start
        sleep 5
    fi
    
    # Lancer les tests
    echo -e "${BLUE}Test du backend...${NC}"
    if [ -f "backend/test_import_export.py" ]; then
        cd backend && python test_import_export.py && cd ..
    fi
    
    echo -e "${BLUE}Test de l'import/export...${NC}"
    if [ -f "test_import_export.sh" ]; then
        ./test_import_export.sh
    fi
    
    echo -e "${BLUE}Test du zoom et panoramique...${NC}"
    if [ -f "test_zoom_pan.sh" ]; then
        ./test_zoom_pan.sh
    fi
    
    echo -e "${GREEN}✅ Tests terminés${NC}"
}

# Commande SETUP
cmd_setup() {
    echo -e "${PURPLE}⚙️ Configuration initiale de Visual Workflow Builder${NC}"
    echo ""
    
    # Vérifier les prérequis
    echo -e "${BLUE}Vérification des prérequis...${NC}"
    
    if ! command -v python3 &> /dev/null; then
        echo -e "${RED}❌ Python 3 n'est pas installé${NC}"
        exit 1
    fi
    echo -e "${GREEN}✅ Python 3: $(python3 --version)${NC}"
    
    if ! command -v node &> /dev/null; then
        echo -e "${RED}❌ Node.js n'est pas installé${NC}"
        exit 1
    fi
    echo -e "${GREEN}✅ Node.js: $(node --version)${NC}"
    
    if ! command -v npm &> /dev/null; then
        echo -e "${RED}❌ npm n'est pas installé${NC}"
        exit 1
    fi
    echo -e "${GREEN}✅ npm: $(npm --version)${NC}"
    
    # Configuration du backend
    echo -e "${BLUE}Configuration du backend...${NC}"
    cd backend
    
    if [ ! -d "venv" ]; then
        python3 -m venv venv
    fi
    
    source venv/bin/activate
    pip install -r requirements.txt
    touch .deps_installed
    
    cd ..
    
    # Configuration du frontend
    echo -e "${BLUE}Configuration du frontend...${NC}"
    cd frontend
    npm install
    touch node_modules/.package-lock.json
    cd ..
    
    echo -e "${GREEN}✅ Configuration terminée${NC}"
    echo ""
    echo -e "${CYAN}Vous pouvez maintenant démarrer l'application avec:${NC}"
    echo -e "${YELLOW}$0 start${NC}"
}

# Commande CLEAN
cmd_clean() {
    echo -e "${PURPLE}🧹 Nettoyage des fichiers temporaires${NC}"
    
    # Arrêter l'application si elle tourne
    cmd_stop
    
    # Nettoyer les fichiers temporaires
    rm -f backend.log frontend.log
    rm -f .backend.pid .frontend.pid
    
    # Nettoyer les caches
    if [ -d "backend/__pycache__" ]; then
        rm -rf backend/__pycache__
    fi
    
    if [ -d "frontend/node_modules/.cache" ]; then
        rm -rf frontend/node_modules/.cache
    fi
    
    if [ -d "frontend/build" ]; then
        rm -rf frontend/build
    fi
    
    echo -e "${GREEN}✅ Nettoyage terminé${NC}"
}

# Exécuter la commande
case $COMMAND in
    start)
        cmd_start
        ;;
    stop)
        cmd_stop
        ;;
    restart)
        cmd_restart
        ;;
    status)
        cmd_status
        ;;
    logs)
        cmd_logs
        ;;
    test)
        cmd_test
        ;;
    setup)
        cmd_setup
        ;;
    clean)
        cmd_clean
        ;;
    *)
        echo -e "${RED}Commande inconnue: $COMMAND${NC}"
        show_help
        exit 1
        ;;
esac