#!/bin/bash

# Wrapper pour exécuter le script MD_to_Print dans Docker
# Usage: ./docker_run.sh fichier.md [options...]
#        ./docker_run.sh fichier1.md fichier2.md [options...]

set -euo pipefail

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

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

# Fonction d'aide
show_help() {
    cat << EOF
Wrapper Docker pour MD_to_Print

Usage: $0 fichier.md [options...]
       $0 fichier1.md fichier2.md [options...]

Ce script simplifie l'exécution de MD_to_Print dans Docker en gérant:
- Les chemins absolus des fichiers
- Le montage des volumes
- Le passage des arguments
- La gestion des erreurs Docker
- Le traitement de plusieurs fichiers en boucle

EXEMPLES:
    $0 documents/rapport.md --preview
    $0 documents/rapport.md --printer HP_LaserJet --copies 2
    $0 documents/*.md --keep-pdf --verbose
    $0 documents/fichier1.md documents/fichier2.md --keep-pdf

OPTIONS:
    Toutes les options de md_to_print.sh sont supportées.
    Utilisez: docker run --rm md-to-print:latest --help
    pour voir toutes les options disponibles.
EOF
}

# Collecter les fichiers markdown et les options
MD_FILES=()
OPTIONS=()
PROCESSING_FILES=true

for arg in "$@"; do
    if [ "$PROCESSING_FILES" = true ]; then
        # Vérifier si c'est une option (commence par -)
        if [[ "$arg" =~ ^- ]]; then
            PROCESSING_FILES=false
            OPTIONS+=("$arg")
        # Vérifier si c'est un fichier markdown
        elif [[ "$arg" =~ \.(md|markdown)$ ]] || [ -f "$arg" ]; then
            MD_FILES+=("$arg")
        else
            # Argument ambigu, arrêter la collecte de fichiers
            PROCESSING_FILES=false
            OPTIONS+=("$arg")
        fi
    else
        OPTIONS+=("$arg")
    fi
done

# Vérification des arguments
if [ ${#MD_FILES[@]} -eq 0 ]; then
    if [ "${1:-}" = "-h" ] || [ "${1:-}" = "--help" ] || [ -z "${1:-}" ]; then
        show_help
        exit 0
    else
        echo -e "${RED}Erreur: Aucun fichier markdown spécifié${NC}"
        show_help
        exit 1
    fi
fi

# Vérifier que Docker est disponible
if ! command -v docker &> /dev/null; then
    echo -e "${RED}Erreur: Docker n'est pas installé ou non disponible dans le PATH${NC}"
    exit 1
fi

# Vérifier que tous les fichiers existent
for MD_FILE in "${MD_FILES[@]}"; do
    if [ ! -f "$MD_FILE" ]; then
        echo -e "${RED}Erreur: Le fichier '$MD_FILE' n'existe pas${NC}"
        exit 2
    fi
done

# Créer les répertoires nécessaires
mkdir -p "$SCRIPT_DIR/documents" "$SCRIPT_DIR/output" "$SCRIPT_DIR/logs"

# Vérifier si l'image Docker existe
if ! docker images md-to-print:latest --format "{{.Repository}}:{{.Tag}}" | grep -q "md-to-print:latest"; then
    echo -e "${YELLOW}Image Docker non trouvée. Construction de l'image...${NC}"
    cd "$SCRIPT_DIR"
    docker build -t md-to-print:latest .
fi

# Fonction pour traiter un fichier
process_file() {
    local MD_FILE="$1"
    shift
    local FILE_OPTIONS=("$@")
    
    echo -e "${GREEN}=== Traitement de: $MD_FILE ===${NC}"
    
    # Obtenir le chemin absolu du fichier
    MD_FILE_ABS="$(realpath "$MD_FILE")"
    MD_DIR="$(dirname "$MD_FILE_ABS")"
    MD_NAME="$(basename "$MD_FILE_ABS")"
    
    # Vérifier que le fichier est dans le répertoire documents ou un sous-répertoire
    if [[ ! "$MD_DIR" =~ ^"$SCRIPT_DIR"/documents ]]; then
        echo -e "${YELLOW}Attention: Le fichier n'est pas dans le répertoire documents/${NC}"
        echo -e "${BLUE}Le fichier sera accessible via le montage du répertoire parent${NC}"
        MD_REL_PATH="$(realpath --relative-to="$SCRIPT_DIR" "$MD_FILE_ABS")"
        MD_DIR="$SCRIPT_DIR"
        MD_NAME="$MD_REL_PATH"
    fi
    
    # Déterminer si on a besoin d'un TTY interactif (prévisualisation ou un seul fichier)
    NEED_TTY=false
    for opt in "${FILE_OPTIONS[@]}"; do
        if [ "$opt" = "--preview" ] || [ "$opt" = "-p" ]; then
            NEED_TTY=true
            break
        fi
    done
    
    # Si un seul fichier et TTY disponible, utiliser mode interactif
    if [ ${#MD_FILES[@]} -eq 1 ] && [ -t 0 ] && [ "$NEED_TTY" = true ]; then
        DOCKER_TTY_FLAGS="-it"
    elif [ -t 0 ]; then
        DOCKER_TTY_FLAGS="-i"
    else
        DOCKER_TTY_FLAGS=""
    fi
    
    # Construire la commande Docker
    DOCKER_CMD=(
        docker run
        --rm
    )
    
    # Ajouter les flags TTY si nécessaire
    if [ -n "$DOCKER_TTY_FLAGS" ]; then
        DOCKER_CMD+=($DOCKER_TTY_FLAGS)
    fi
    
    DOCKER_CMD+=(
        -v "$SCRIPT_DIR/documents:/workspace/documents:ro"
        -v "$SCRIPT_DIR/output:/workspace/output"
        -v "$SCRIPT_DIR/logs:/workspace/logs"
        --network host
    )
    
    # Ajouter le support X11 si DISPLAY est défini (pour prévisualisation)
    if [ -n "${DISPLAY:-}" ]; then
        DOCKER_CMD+=(
            -e DISPLAY="$DISPLAY"
            -v /tmp/.X11-unix:/tmp/.X11-unix:ro
        )
    fi
    
    # Ajouter l'accès CUPS si disponible
    if [ -d "/var/run/cups" ]; then
        DOCKER_CMD+=(-v /var/run/cups:/var/run/cups:ro)
    fi
    
    DOCKER_CMD+=(md-to-print:latest)
    
    # Ajouter le fichier markdown
    if [[ "$MD_DIR" == "$SCRIPT_DIR" ]]; then
        DOCKER_CMD+=("/workspace/$MD_NAME")
    else
        DOCKER_CMD+=("/workspace/documents/$MD_NAME")
    fi
    
    # Ajouter les options
    for opt in "${FILE_OPTIONS[@]}"; do
        DOCKER_CMD+=("$opt")
    done
    
    # Exécuter
    echo -e "${BLUE}Commande: ${DOCKER_CMD[*]}${NC}"
    echo ""
    
    if ! "${DOCKER_CMD[@]}"; then
        echo -e "${RED}Erreur lors du traitement de $MD_FILE${NC}"
        return 1
    fi
    
    return 0
}

# Traiter tous les fichiers
EXIT_CODE=0
for MD_FILE in "${MD_FILES[@]}"; do
    if ! process_file "$MD_FILE" "${OPTIONS[@]}"; then
        EXIT_CODE=1
    fi
    echo ""
done

if [ $EXIT_CODE -eq 0 ]; then
    echo -e "${GREEN}=== Tous les fichiers ont été traités avec succès ===${NC}"
else
    echo -e "${YELLOW}=== Certains fichiers ont échoué ===${NC}"
fi

exit $EXIT_CODE