#!/bin/bash
# ============================================================
#  MP Cloud — Gestionnaire de projets MMPB Cloud's Services
#  Auteur  : MASSE MASSE PAUL-BASTHYLLE
#  Version : 3.0.0
# ============================================================

VERSION="3.0.0"
AUTHOR="MASSE MASSE PAUL-BASTHYLLE"
EMAIL="paolocisse6@gmail.com"
PLATFORM="MMPB Cloud's Services"
DOMAIN="services-ztf.com"

GLOBAL_CONFIG="/etc/mp/config"
TOKEN_FILE="/etc/mp/token"
LOCAL_CONFIG=".mp/config"

R='\033[0;31m'; G='\033[0;32m'; Y='\033[1;33m'
B='\033[0;34m'; C='\033[0;36m'; BOLD='\033[1m'; RST='\033[0m'

if [ ! -f "$GLOBAL_CONFIG" ]; then
    echo -e "${R}[ERREUR] Configuration introuvable. Reinstallez mp-cloud.${RST}"
    exit 1
fi
source "$GLOBAL_CONFIG"
CLIENT_TOKEN=""; [ -f "$TOKEN_FILE" ] && CLIENT_TOKEN=$(cat "$TOKEN_FILE")

ssh_exec() {
    sshpass -p "$VPS_PASS" ssh -p "$VPS_PORT" \
        -o StrictHostKeyChecking=no -o LogLevel=ERROR \
        "$VPS_USER@$VPS_IP" "$@"
}

rsync_push() {
    sshpass -p "$VPS_PASS" rsync -az --progress \
        -e "ssh -p $VPS_PORT -o StrictHostKeyChecking=no -o LogLevel=ERROR" \
        --exclude '.mp/' --exclude 'node_modules/' --exclude '__pycache__/' \
        --exclude '*.pyc' --exclude '*.log' --exclude '.git/' --exclude '.env' \
        "$1" "$VPS_USER@$VPS_IP:$2"
}

rsync_pull() {
    sshpass -p "$VPS_PASS" rsync -az --progress \
        -e "ssh -p $VPS_PORT -o StrictHostKeyChecking=no -o LogLevel=ERROR" \
        --exclude '.mp/' --exclude 'node_modules/' --exclude '__pycache__/' \
        "$VPS_USER@$VPS_IP:$1" "$2"
}

scp_send() {
    sshpass -p "$VPS_PASS" scp -P "$VPS_PORT" \
        -o StrictHostKeyChecking=no -o LogLevel=ERROR "$@"
}

scp_get() {
    sshpass -p "$VPS_PASS" scp -P "$VPS_PORT" \
        -o StrictHostKeyChecking=no -o LogLevel=ERROR \
        "$VPS_USER@$VPS_IP:$1" "$2"
}

load_local_config() {
    if [ ! -f "$LOCAL_CONFIG" ]; then
        echo -e "${R}  [ERR] Pas de projet MP ici. Lancez : mp init${RST}"; exit 1
    fi
    source "$LOCAL_CONFIG"
}

print_header() {
    echo -e "${C}${BOLD}"
    echo "  ╔══════════════════════════════════════════════════╗"
    echo "  ║   MP Cloud v$VERSION — MMPB Cloud's Services      ║"
    echo "  ╚══════════════════════════════════════════════════╝"
    echo -e "${RST}"
}

ok()   { echo -e "${G}  [OK]  $1${RST}"; }
err()  { echo -e "${R}  [ERR] $1${RST}"; exit 1; }
info() { echo -e "${Y}  [-->] $1${RST}"; }
sep()  { echo -e "${B}  ────────────────────────────────────────────────${RST}"; }

cmd_init() {
    print_header
    echo -e "  ${BOLD}Initialisation du projet${RST}"; sep; echo ""

    if [ -f "$LOCAL_CONFIG" ]; then
        source "$LOCAL_CONFIG"
        echo -e "  ${Y}Ce dossier est deja lie au projet : $PROJECT_NAME${RST}"
        read -p "  Reinitialiser ? (o/N) : " REINIT
        [[ "$REINIT" != "o" && "$REINIT" != "O" ]] && exit 0
        rm -rf .mp/
    fi
    mkdir -p .mp

    DEFAULT_NAME=$(basename "$(pwd)")
    read -p "  Nom du projet sur le VPS [$DEFAULT_NAME] : " INPUT_NAME
    PROJECT_NAME="${INPUT_NAME:-$DEFAULT_NAME}"

    echo ""; echo "  Type de projet :"
    echo "    1) Site web     (HTML statique / PHP)"
    echo "    2) Application  (Node.js / Python / PHP service / Docker)"
    echo ""; read -p "  Choix [1] : " TYPE_CHOICE
    TYPE_CHOICE="${TYPE_CHOICE:-1}"
    case "$TYPE_CHOICE" in
        1) PROJECT_TYPE="site" ;; 2) PROJECT_TYPE="app" ;; *) err "Choix invalide." ;;
    esac

    STACK="static"; PM2_NAME=""; STRUCTURE="simple"
    FRONTEND_PATH=""; BACKEND_PATH=""; FRONTEND_PM2=""; BACKEND_PM2=""

    if [ "$PROJECT_TYPE" = "site" ]; then
        echo ""; echo "  Type de site :"
        echo "    1) HTML statique"; echo "    2) PHP"
        echo ""; read -p "  Choix [1] : " SITE_CHOICE
        case "${SITE_CHOICE:-1}" in
            1) STACK="static" ;; 2) STACK="php" ;; *) STACK="static" ;;
        esac
    fi

    if [ "$PROJECT_TYPE" = "app" ]; then
        echo ""; echo "  Stack :"
        echo "    1) Node.js"; echo "    2) Python"
        echo "    3) PHP service"; echo "    4) Docker"
        echo ""; read -p "  Choix [1] : " STACK_CHOICE
        case "${STACK_CHOICE:-1}" in
            1) STACK="nodejs" ;; 2) STACK="python" ;;
            3) STACK="php" ;; 4) STACK="docker" ;; *) err "Choix invalide." ;;
        esac

        echo ""; echo "  Structure :"
        echo "    1) Simple (un seul dossier)"; echo "    2) Full-stack (frontend + backend)"
        echo ""; read -p "  Choix [1] : " STRUCT_CHOICE

        if [ "${STRUCT_CHOICE:-1}" = "2" ]; then
            STRUCTURE="fullstack"
            read -p "  Chemin backend  (ex: server) : " BACKEND_PATH
            read -p "  Chemin frontend (ex: client) : " FRONTEND_PATH
            DEFAULT_PM2=$(echo "$PROJECT_NAME" | tr '[:upper:]' '[:lower:]' | tr ' _' '--')
            read -p "  Nom PM2 backend  [$DEFAULT_PM2-back] : " BACKEND_PM2
            BACKEND_PM2="${BACKEND_PM2:-$DEFAULT_PM2-back}"
            read -p "  Nom PM2 frontend [$DEFAULT_PM2-front] : " FRONTEND_PM2
            FRONTEND_PM2="${FRONTEND_PM2:-$DEFAULT_PM2-front}"
        else
            STRUCTURE="simple"
            if [ "$STACK" != "php" ] && [ "$STACK" != "docker" ]; then
                DEFAULT_PM2=$(echo "$PROJECT_NAME" | tr '[:upper:]' '[:lower:]' | tr ' _' '--')
                read -p "  Nom PM2 [$DEFAULT_PM2] : " PM2_NAME
                PM2_NAME="${PM2_NAME:-$DEFAULT_PM2}"
            fi
        fi
    fi

    echo ""; echo "  Base de donnees :"
    echo "    1) Aucune"; echo "    2) MySQL / MariaDB"
    echo "    3) PostgreSQL"; echo "    4) MySQL + PostgreSQL"
    echo ""; read -p "  Choix [1] : " DB_CHOICE
    case "${DB_CHOICE:-1}" in
        1) DB_TYPE="none" ;; 2) DB_TYPE="mysql" ;;
        3) DB_TYPE="postgres" ;; 4) DB_TYPE="both" ;; *) DB_TYPE="none" ;;
    esac

    # Chemin VPS selon architecture MMPB
    echo ""; info "Calcul du chemin VPS..."
    if [ "$PROJECT_TYPE" = "site" ]; then
        VPS_PROJECT_PATH="/var/www/html/$VPS_USER/$PROJECT_NAME"
    else
        VPS_PROJECT_PATH="/home/$VPS_USER/$PROJECT_NAME"
    fi

    info "Verification du projet sur le VPS..."
    VPS_EXISTS=$(ssh_exec "test -d '$VPS_PROJECT_PATH' && echo yes || echo no" 2>/dev/null)

    if [ "$VPS_EXISTS" = "no" ]; then
        echo ""
        echo -e "  ${Y}Dossier introuvable : $VPS_PROJECT_PATH${RST}"
        echo ""
        echo -e "  ${BOLD}Conseil :${RST} Copiez le chemin depuis l'interface :"
        echo -e "  ${C}https://$DOMAIN${RST} → votre projet → \"Chemin serveur\""
        echo ""
        read -p "  Chemin exact sur le VPS : " CUSTOM_PATH
        [ -z "$CUSTOM_PATH" ] && err "Chemin VPS requis."
        VPS_PROJECT_PATH="$CUSTOM_PATH"
        VPS_EXISTS=$(ssh_exec "test -d '$VPS_PROJECT_PATH' && echo yes || echo no" 2>/dev/null)
        [ "$VPS_EXISTS" = "no" ] && err "Chemin introuvable : $VPS_PROJECT_PATH"
    fi
    ok "Projet trouve : $VPS_PROJECT_PATH"

    PROJECT_URL="https://$PROJECT_NAME.$DOMAIN"

    cat > "$LOCAL_CONFIG" << EOF
# MP Cloud Config — genere le $(date)
PROJECT_NAME="$PROJECT_NAME"
PROJECT_TYPE="$PROJECT_TYPE"
STACK="$STACK"
STRUCTURE="$STRUCTURE"
VPS_PROJECT_PATH="$VPS_PROJECT_PATH"
PROJECT_URL="$PROJECT_URL"
PM2_NAME="$PM2_NAME"
BACKEND_PATH="$BACKEND_PATH"
FRONTEND_PATH="$FRONTEND_PATH"
BACKEND_PM2="$BACKEND_PM2"
FRONTEND_PM2="$FRONTEND_PM2"
DB_TYPE="$DB_TYPE"
EOF

    echo ""; ok "Projet initialise : $PROJECT_NAME"
    info "Config : .mp/config"
    echo ""
    echo -e "  ${BOLD}URL :${RST} $PROJECT_URL"
    echo ""
    echo "    mp push    Synchroniser"; echo "    mp info    Infos du projet"
    echo "    mp guide   Guide complet"; echo ""
}

cmd_push() {
    load_local_config; echo ""
    info "Synchronisation → $VPS_PROJECT_PATH"; sep
    rsync_push "./" "$VPS_PROJECT_PATH/"
    [ $? -ne 0 ] && err "Echec rsync."
    ok "Fichiers synchronises."
    echo ""; info "Redemarrage du service..."
    case "$STACK" in
        nodejs|python)
            if [ "$STRUCTURE" = "fullstack" ]; then
                ssh_exec "bash -lc 'pm2 restart $BACKEND_PM2 --update-env 2>/dev/null && pm2 restart $FRONTEND_PM2 --update-env 2>/dev/null && pm2 save'"
            else
                ssh_exec "bash -lc 'pm2 restart $PM2_NAME --update-env 2>/dev/null && pm2 save'"
            fi
            [ $? -eq 0 ] && ok "PM2 redemarre." || info "Verifiez le service manuellement." ;;
        php|static)
            ssh_exec "echo '$VPS_PASS' | sudo -S -p '' nginx -t 2>/dev/null && echo '$VPS_PASS' | sudo -S -p '' systemctl reload nginx 2>/dev/null"
            ok "Nginx rechargé." ;;
        docker)
            ssh_exec "cd '$VPS_PROJECT_PATH' && docker compose down && docker compose up -d"
            [ $? -eq 0 ] && ok "Docker recompose." || err "Echec docker compose." ;;
    esac
    echo ""; ok "Push termine."; info "Votre site : $PROJECT_URL"; echo ""
}

cmd_pull() {
    load_local_config; echo ""
    info "Recuperation depuis : $VPS_PROJECT_PATH"; sep
    rsync_pull "$VPS_PROJECT_PATH/" "./"
    [ $? -eq 0 ] && ok "Pull termine." || err "Echec rsync pull."
    echo ""
}

cmd_logs() {
    load_local_config
    NGINX_NAME=$(echo "$VPS_PROJECT_PATH" | awk -F'/' '{print $(NF-2)"-"$(NF-1)"-"$NF}')
    echo ""; echo -e "  ${BOLD}Logs — $PROJECT_NAME${RST}"; sep; echo ""
    echo "    1) Logs PM2 temps reel"; echo "    2) 50 dernieres lignes PM2"
    echo "    3) Erreurs PM2"; echo "    4) Logs Nginx access"
    echo "    5) Logs Nginx erreurs"; echo "    6) Logs Docker"
    echo ""; read -p "  Choix : " LOG_CHOICE
    case "$LOG_CHOICE" in
        1) ssh_exec "bash -lc 'pm2 logs ${PM2_NAME:-$BACKEND_PM2}'" ;;
        2) ssh_exec "bash -lc 'pm2 logs ${PM2_NAME:-$BACKEND_PM2} --lines 50 --nostream'" ;;
        3) ssh_exec "bash -lc 'pm2 logs ${PM2_NAME:-$BACKEND_PM2} --err --lines 50 --nostream'" ;;
        4) ssh_exec "tail -50 /var/log/nginx/${NGINX_NAME}-access.log 2>/dev/null || echo 'Log introuvable'" ;;
        5) ssh_exec "tail -50 /var/log/nginx/${NGINX_NAME}-error.log 2>/dev/null || echo 'Log introuvable'" ;;
        6) ssh_exec "cd '$VPS_PROJECT_PATH' && docker compose logs --tail=50 2>/dev/null || echo 'Pas de Docker'" ;;
        *) err "Choix invalide." ;;
    esac
}

cmd_status() {
    load_local_config; echo ""
    echo -e "  ${BOLD}Statut — $PROJECT_NAME${RST}"; sep; echo ""
    info "Type  : $PROJECT_TYPE / $STACK / $STRUCTURE"
    info "VPS   : $VPS_PROJECT_PATH"
    info "URL   : $PROJECT_URL"
    case "$STACK" in
        nodejs|python) ssh_exec "bash -lc 'pm2 show ${PM2_NAME:-$BACKEND_PM2} 2>/dev/null | grep -E \"status|cpu|memory|uptime|restarts\"'" ;;
        docker) ssh_exec "cd '$VPS_PROJECT_PATH' && docker compose ps 2>/dev/null" ;;
        php|static) ssh_exec "systemctl is-active nginx 2>/dev/null && echo 'Nginx actif' || echo 'Nginx inactif'" ;;
    esac
    echo ""
}

cmd_info() {
    load_local_config; print_header
    echo -e "  ${BOLD}Informations du projet${RST}"; sep; echo ""
    echo -e "  ${C}Nom        :${RST} $PROJECT_NAME"
    echo -e "  ${C}Type       :${RST} $PROJECT_TYPE"
    echo -e "  ${C}Stack      :${RST} $STACK"
    echo -e "  ${C}Structure  :${RST} $STRUCTURE"
    echo -e "  ${C}Chemin VPS :${RST} $VPS_PROJECT_PATH"
    echo -e "  ${C}URL        :${RST} $PROJECT_URL"
    echo -e "  ${C}Base data  :${RST} $DB_TYPE"
    [ -n "$PM2_NAME" ] && echo -e "  ${C}PM2        :${RST} $PM2_NAME"
    if [ "$STRUCTURE" = "fullstack" ]; then
        echo -e "  ${C}Backend PM2:${RST} $BACKEND_PM2"
        echo -e "  ${C}Frontend PM2:${RST} $FRONTEND_PM2"
    fi
    echo ""; sep
    echo -e "  ${C}VPS        :${RST} $VPS_IP:$VPS_PORT"
    echo ""
}

cmd_open() {
    load_local_config; echo ""; info "Ouverture de $PROJECT_URL"
    if command -v xdg-open &>/dev/null; then xdg-open "$PROJECT_URL"
    elif command -v open &>/dev/null; then open "$PROJECT_URL"
    else ok "URL : $PROJECT_URL"; fi
    echo ""
}

cmd_db() {
    load_local_config; SUBCMD="$1"; shift
    case "$SUBCMD" in
        push)
            SQL_FILE="$1"
            [ -z "$SQL_FILE" ] && err "Usage : mp db push <fichier.sql>"
            [ ! -f "$SQL_FILE" ] && err "Fichier introuvable : $SQL_FILE"
            echo ""; info "Envoi SQL : $SQL_FILE"
            REMOTE_SQL="/tmp/mp_migration_$(date +%s).sql"
            scp_send "$SQL_FILE" "$VPS_USER@$VPS_IP:$REMOTE_SQL"
            [ $? -ne 0 ] && err "Echec envoi SQL."
            ok "Fichier envoye."; info "Execution..."
            case "$DB_TYPE" in
                mysql)   ssh_exec "bash -lc 'mysql -u \$DB_USER -p\$DB_PASS \$DB_NAME < $REMOTE_SQL && rm -f $REMOTE_SQL'" ;;
                postgres) ssh_exec "bash -lc 'psql -U \$DB_USER \$DB_NAME < $REMOTE_SQL && rm -f $REMOTE_SQL'" ;;
                none) err "Aucune base configuree." ;;
            esac
            [ $? -eq 0 ] && ok "Migration executee." || err "Echec migration."
            echo "" ;;
        backup)
            echo ""; info "Sauvegarde BDD..."
            BACKUP_FILE="backup_${PROJECT_NAME}_$(date +%Y%m%d_%H%M%S).sql.gz"
            REMOTE_BACKUP="/tmp/$BACKUP_FILE"
            case "$DB_TYPE" in
                mysql)   ssh_exec "bash -lc 'mysqldump -u \$DB_USER -p\$DB_PASS \$DB_NAME | gzip > $REMOTE_BACKUP'" ;;
                postgres) ssh_exec "bash -lc 'pg_dump -U \$DB_USER \$DB_NAME | gzip > $REMOTE_BACKUP'" ;;
                none) err "Aucune base configuree." ;;
            esac
            [ $? -ne 0 ] && err "Echec dump."
            ok "Dump cree."; info "Telechargement..."
            scp_get "$REMOTE_BACKUP" "./$BACKUP_FILE"
            ssh_exec "rm -f $REMOTE_BACKUP"
            [ $? -eq 0 ] && ok "Backup : $BACKUP_FILE" || err "Echec telechargement."
            echo "" ;;
        *) echo "  Usage : mp db push <f.sql> | mp db backup" ;;
    esac
}

cmd_deps() {
    load_local_config; echo ""; info "Installation des dependances..."; sep
    case "$STACK" in
        nodejs)
            if [ "$STRUCTURE" = "fullstack" ]; then
                [ -n "$BACKEND_PATH" ]  && ssh_exec "bash -lc 'cd $VPS_PROJECT_PATH/$BACKEND_PATH && npm install'"
                [ -n "$FRONTEND_PATH" ] && ssh_exec "bash -lc 'cd $VPS_PROJECT_PATH/$FRONTEND_PATH && npm install'"
            else
                ssh_exec "bash -lc 'cd $VPS_PROJECT_PATH && npm install'"
            fi ;;
        python)
            REQ_PATH="$VPS_PROJECT_PATH/requirements.txt"
            [ -n "$BACKEND_PATH" ] && REQ_PATH="$VPS_PROJECT_PATH/$BACKEND_PATH/requirements.txt"
            ssh_exec "bash -lc 'pip install -r $REQ_PATH 2>/dev/null || pip3 install -r $REQ_PATH'" ;;
        php) ssh_exec "bash -lc 'cd $VPS_PROJECT_PATH && composer install --no-dev'" ;;
        docker) ssh_exec "cd '$VPS_PROJECT_PATH' && docker compose build" ;;
        static) info "Aucune dependance pour un site statique." ;;
    esac
    [ $? -eq 0 ] && ok "Dependances installees." || err "Echec installation."
    echo ""
}

cmd_fix() {
    load_local_config; SUBCMD="$1"
    case "$SUBCMD" in
        env)
            echo ""; info "Reparation .env..."
            if [ -f ".env" ]; then
                scp_send ".env" "$VPS_USER@$VPS_IP:$VPS_PROJECT_PATH/.env"
                ok ".env copie."
                if [ "$STRUCTURE" = "fullstack" ]; then
                    [ -f "$BACKEND_PATH/.env" ]  && scp_send "$BACKEND_PATH/.env"  "$VPS_USER@$VPS_IP:$VPS_PROJECT_PATH/$BACKEND_PATH/.env"
                    [ -f "$FRONTEND_PATH/.env" ] && scp_send "$FRONTEND_PATH/.env" "$VPS_USER@$VPS_IP:$VPS_PROJECT_PATH/$FRONTEND_PATH/.env"
                fi
            else
                err ".env local introuvable."
            fi
            echo "" ;;
        deps) cmd_deps ;;
        *) echo "  Usage : mp fix env | mp fix deps" ;;
    esac
}

cmd_guide() {
    print_header
    echo -e "  ${BOLD}Guide d'utilisation — MP Cloud v$VERSION${RST}"; sep; echo ""
    echo -e "  ${BOLD}1. Creer un projet sur l'interface${RST}"
    echo "     Allez sur https://$DOMAIN"
    echo "     Creez votre projet (HTML, PHP, Node.js, Python...)"
    echo "     Notez le chemin VPS affiche dans \"Gestion des fichiers\""
    echo ""
    echo -e "  ${BOLD}2. Initialiser mp dans votre dossier local${RST}"
    echo "     cd /chemin/vers/votre-projet"
    echo "     mp init"
    echo "     Suivez les questions. Si le chemin VPS n'est pas trouve"
    echo "     automatiquement, copiez-le depuis l'interface."
    echo ""
    echo -e "  ${BOLD}3. Envoyer vos fichiers${RST}"
    echo "     mp push"
    echo "     Vos fichiers sont synchronises et le service redemarre."
    echo ""
    echo -e "  ${BOLD}4. Commandes du quotidien${RST}"
    echo "     mp push          Envoyer les modifications"
    echo "     mp pull          Recuperer les fichiers du serveur"
    echo "     mp logs          Voir les logs"
    echo "     mp status        Etat du service"
    echo "     mp info          Infos completes du projet"
    echo "     mp open          Ouvrir l'URL dans le navigateur"
    echo ""
    echo -e "  ${BOLD}5. Base de donnees${RST}"
    echo "     mp db push migration.sql   Executer un fichier SQL"
    echo "     mp db backup               Telecharger un dump SQL"
    echo ""
    echo -e "  ${BOLD}6. Maintenance${RST}"
    echo "     mp deps          Installer les dependances sur le VPS"
    echo "     mp fix env       Copier le .env local vers le VPS"
    echo "     mp fix deps      Reinstaller toutes les dependances"
    echo ""
    sep; echo -e "  Support : $EMAIL"; echo ""
}

cmd_help() {
    print_header
    echo -e "  ${BOLD}Commandes disponibles${RST}"; sep; echo ""
    echo -e "  ${C}Projet${RST}"
    echo "    mp init              Lier ce dossier a un projet VPS"
    echo "    mp info              Infos du projet lie"
    echo "    mp status            Etat du service"
    echo "    mp open              Ouvrir l'URL dans le navigateur"
    echo ""
    echo -e "  ${C}Synchronisation${RST}"
    echo "    mp push              Envoyer les fichiers + redemarrer"
    echo "    mp pull              Recuperer depuis le VPS"
    echo ""
    echo -e "  ${C}Logs${RST}"
    echo "    mp logs              Voir les logs (PM2 / Nginx / Docker)"
    echo ""
    echo -e "  ${C}Base de donnees${RST}"
    echo "    mp db push <f.sql>   Executer une migration SQL"
    echo "    mp db backup         Telecharger un dump SQL"
    echo ""
    echo -e "  ${C}Maintenance${RST}"
    echo "    mp deps              Installer les dependances"
    echo "    mp fix env           Copier le .env vers le VPS"
    echo "    mp fix deps          Reinstaller les dependances"
    echo ""
    echo -e "  ${C}Aide${RST}"
    echo "    mp guide             Guide complet"; echo "    mp help              Cette aide"
    echo "    mp version           Version"; echo ""
    sep; echo -e "  Auteur : $AUTHOR — $EMAIL"; echo ""
}

cmd_version() {
    echo ""
    echo -e "  ${C}${BOLD}MP Cloud${RST}  v$VERSION"
    echo -e "  Plateforme : $PLATFORM"
    echo -e "  Auteur     : $AUTHOR"
    echo -e "  Email      : $EMAIL"; echo ""
}

COMMAND="${1:-help}"; shift 2>/dev/null
case "$COMMAND" in
    init)    cmd_init ;;
    push)    cmd_push ;;
    pull)    cmd_pull ;;
    logs)    cmd_logs ;;
    status)  cmd_status ;;
    info)    cmd_info ;;
    open)    cmd_open ;;
    guide)   cmd_guide ;;
    db)      cmd_db "$@" ;;
    deps)    cmd_deps ;;
    fix)     cmd_fix "$@" ;;
    help|--help|-h)       cmd_help ;;
    version|--version|-v) cmd_version ;;
    *)
        echo -e "${R}  [ERR] Commande inconnue : $COMMAND${RST}"
        echo "  Tapez : mp help"; exit 1 ;;
esac
