#!/bin/sh
# Drop — client minimal destiné à un assistant IA (§17, phase 34).
#
# Volontairement séparé de bin/drop, qui fait dix fois cette taille : un
# assistant doit pouvoir lire ce fichier en entier et savoir s'en servir sans
# documentation. Pas de profils multiples, pas de presse-papiers, pas de SSE —
# un seul cercle, quatre gestes : envoyer un texte, envoyer un fichier, lire
# les derniers éléments, savoir où l'on en est.
#
# Ne dépend que de curl, comme bin/drop (§2, contrainte 4).
#
# Le jeton est écrit dans ~/.config/drop/ia.conf en 600 et n'est affiché nulle
# part, sur aucune sortie : le code d'appairage, lui, peut traverser le
# contexte d'un modèle sans dommage (usage unique, deux minutes), le jeton non
# (§12 bis).

set -eu

VERSION='1.0'

CONFIG_DOSSIER="${XDG_CONFIG_HOME:-$HOME/.config}/drop"

# Un cercle par installation, c'est le cas courant et le plus lisible côté
# « Mes appareils » : un appareil « ia » par cercle, révocable seul. Pour en
# suivre plusieurs depuis la même machine, DROP_IA_CONFIG désigne un autre
# fichier — un jeton par cercle, sans introduire ici la mécanique de profils
# de bin/drop, qui est précisément ce qui rend ce client-là trop volumineux
# pour être lu d'un trait par un assistant.
#
#     DROP_IA_CONFIG=~/.config/drop/ia-jeux.conf drop-ia envoyer "…"
CONFIG="${DROP_IA_CONFIG:-$CONFIG_DOSSIER/ia.conf}"

# ---------------------------------------------------------------- utilitaires

echec() {
    printf 'drop-ia : %s\n' "$1" >&2
    exit 1
}

dire() {
    printf '%s\n' "$1"
}

# Un caractère de contrôle sert de marqueur temporaire pour les guillemets
# échappés : sans lui, une valeur contenant \" couperait l'extraction en deux.
MARQUEUR=$(printf '\001')

# exiger_valeur <option> <nb args restants> — sous `set -eu`, « shift 2 » sur
# une option laissée sans valeur en fin de ligne (« drop-ia lire -n ») ferait
# sortir le script sur un message du shell, en anglais, au lieu du diagnostic
# que tout le reste du fichier soigne.
exiger_valeur() {
    [ "$2" -ge 2 ] || echec "option $1 sans valeur"
}

# json_chaine <champ> <json>
json_chaine() {
    printf '%s' "$2" |
        sed "s/\\\\\"/$MARQUEUR/g" |
        sed -n "s/.*\"$1\":\"\\([^\"]*\\)\".*/\\1/p" |
        sed -e "s/$MARQUEUR/\"/g" -e 's/\\n/\
/g' -e 's/\\t/\t/g' -e 's/\\r//g' -e 's/\\\\/\\/g'
}

# json_entier <champ> <json>
json_entier() {
    printf '%s' "$2" | sed -n "s/.*\"$1\":\\([0-9][0-9]*\\).*/\\1/p" | head -n 1
}

# echapper_json <texte>
echapper_json() {
    printf '%s' "$1" |
        sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/\t/\\t/g' -e 's/\r//g' |
        sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/\\n/g'
}

# proteger_shell <valeur> — le nom du cercle vient du serveur, jamais d'une
# source de confiance : sans cette protection, un nom contenant $(…)
# s'exécuterait au prochain « . "$CONFIG" ».
proteger_shell() {
    printf "'%s'" "$(printf '%s' "$1" | sed "s/'/'\\\\''/g")"
}

# formater_taille <octets>
formater_taille() {
    octets="$1"
    if [ "$octets" -lt 1024 ]; then printf '%s o' "$octets"
    elif [ "$octets" -lt 1048576 ]; then printf '%s ko' "$((octets / 1024))"
    elif [ "$octets" -lt 1073741824 ]; then printf '%s Mo' "$((octets / 1048576))"
    else printf '%s Go' "$((octets / 1073741824))"
    fi
}

# ------------------------------------------------------------- configuration

charger_config() {
    [ -f "$CONFIG" ] || echec "pas encore appairé. Lance : drop-ia appairer <code> --url <URL>"

    # shellcheck disable=SC1090
    . "$CONFIG"

    [ -n "${DROP_URL:-}" ] && [ -n "${DROP_JETON:-}" ] ||
        echec "configuration incomplète dans $CONFIG. Relance : drop-ia appairer <code> --url <URL>"

    DROP_NOM_CERCLE="${DROP_NOM_CERCLE:-$DROP_URL}"
}

ecrire_config() {
    nom_cercle="$1"
    url="$2"
    jeton="$3"

    dossier_config=$(dirname "$CONFIG")
    mkdir -p "$dossier_config"
    chmod 700 "$dossier_config" 2>/dev/null || true

    # Le fichier est créé vide avec ses permissions finales avant d'y écrire
    # quoi que ce soit : le jeton ne doit exister à aucun instant dans un
    # fichier lisible par le reste de la machine.
    : > "$CONFIG"
    chmod 600 "$CONFIG"

    {
        printf '# Drop — configuration du client IA. Ne pas partager : contient un jeton.\n'
        printf 'DROP_NOM_CERCLE=%s\n' "$(proteger_shell "$nom_cercle")"
        printf 'DROP_URL=%s\n' "$(proteger_shell "$url")"
        printf 'DROP_JETON=%s\n' "$(proteger_shell "$jeton")"
    } >> "$CONFIG"
}

# --------------------------------------------------------------- appels API

# api <méthode> <chemin> [corps json]
#
# Le code HTTP est ramené en dernière ligne de la réponse : l'API sérialise
# toujours son JSON sur une seule ligne (les sauts de ligne d'un contenu sont
# échappés en \n), le découpage est donc sans ambiguïté.
# curl_authentifie <jeton> [arguments curl…]
#
# Le jeton ne passe jamais en argument : argv est lisible par tout compte local
# (/proc/<pid>/cmdline), ce qui annulait le mode 600 de ~/.config/drop/ia.conf et
# la promesse du fichier — le jeton n'est « affiché nulle part » (scan sécurité, F7).
curl_authentifie() {
    jeton_appel="$1"
    shift
    printf 'header = "Authorization: Bearer %s"\n' "$jeton_appel" | curl --config - "$@"
}

api() {
    methode="$1"
    chemin="$2"
    corps="${3:-}"

    if [ -n "$corps" ]; then
        brut=$(curl_authentifie "$DROP_JETON" -sS -w '\n%{http_code}' -X "$methode" \
            -H 'Content-Type: application/json' \
            -d "$corps" "$DROP_URL$chemin") || echec 'serveur injoignable'
    else
        brut=$(curl_authentifie "$DROP_JETON" -sS -w '\n%{http_code}' -X "$methode" \
            "$DROP_URL$chemin") || echec 'serveur injoignable'
    fi

    code_http=$(printf '%s' "$brut" | sed -n '$p')
    reponse=$(printf '%s' "$brut" | sed '$d')

    # Un jeton refusé mérite mieux que le message générique du serveur : sans
    # la marche à suivre, un assistant réessaie la même commande en boucle.
    [ "$code_http" != '401' ] ||
        echec "accès refusé : cet appareil a été révoqué, ou son cercle désactivé. Demande un nouveau code, puis : drop-ia appairer <code>"

    message=$(json_chaine 'erreur' "$reponse")
    [ -z "$message" ] || echec "$message"

    printf '%s' "$reponse"
}

# ----------------------------------------------------------------- commandes

# Installation complète en un seul geste, pour une ligne collée telle quelle
# dans un assistant : le script se retélécharge depuis le serveur plutôt que
# de se copier lui-même — lancé via « curl … | sh », il n'existe nulle part
# sur le disque et « $0 » ne désigne aucun fichier à copier.
cmd_installer() {
    code=''
    url=''
    nom_appareil='Assistant IA'

    while [ $# -gt 0 ]; do
        case "$1" in
            --url) exiger_valeur --url $#; url="$2"; shift 2 ;;
            --url=*) url="${1#--url=}"; shift ;;
            --nom) exiger_valeur --nom $#; nom_appareil="$2"; shift 2 ;;
            --nom=*) nom_appareil="${1#--nom=}"; shift ;;
            *) code="$1"; shift ;;
        esac
    done

    [ -n "$code" ] || echec 'code manquant. Usage : drop-ia installer <code> --url <URL>'
    [ -n "$url" ] || echec 'URL manquante. Usage : drop-ia installer <code> --url <URL>'
    url="${url%/}"

    destination_dossier="$HOME/.local/bin"
    destination="$destination_dossier/drop-ia"

    mkdir -p "$destination_dossier"

    temporaire="$destination.telechargement.$$"
    trap 'rm -f "$temporaire"' EXIT INT TERM

    curl -fsSL "$url/bureau.php?telecharger=ia" -o "$temporaire" ||
        echec "téléchargement impossible depuis $url/bureau.php?telecharger=ia"

    # Une page d'erreur HTML servie en 200 passerait le test de curl : mieux
    # vaut refuser tout de suite que d'installer un fichier inexécutable.
    head -n 1 "$temporaire" | grep -q '^#!/bin/sh' ||
        echec "le fichier téléchargé n'est pas le client Drop"

    mv "$temporaire" "$destination"
    chmod 755 "$destination"
    trap - EXIT INT TERM

    dire "Client installé dans $destination."

    # exec plutôt qu'un appel : l'appairage a lieu dans la version qui vient
    # d'être installée, jamais dans celle qui tourne en mémoire.
    DROP_INSTALLATION=1 exec "$destination" appairer "$code" --url "$url" --nom "$nom_appareil"
}

cmd_appairer() {
    code=''
    url=''
    nom_appareil='Assistant IA'

    while [ $# -gt 0 ]; do
        case "$1" in
            --url) exiger_valeur --url $#; url="$2"; shift 2 ;;
            --url=*) url="${1#--url=}"; shift ;;
            --nom) exiger_valeur --nom $#; nom_appareil="$2"; shift 2 ;;
            --nom=*) nom_appareil="${1#--nom=}"; shift ;;
            *) code="$1"; shift ;;
        esac
    done

    [ -n "$code" ] || echec 'code manquant. Usage : drop-ia appairer <code> --url <URL>'

    # L'URL peut déjà être connue d'un appairage précédent ; un code seul ne
    # dit pas à quel serveur il s'adresse.
    if [ -z "$url" ] && [ -f "$CONFIG" ]; then
        # shellcheck disable=SC1090
        . "$CONFIG"
        url="${DROP_URL:-}"
    fi
    [ -n "$url" ] || echec 'URL du serveur inconnue. Ajoute : --url https://drop.exemple.fr'
    url="${url%/}"

    # Le type « ia » rend cet appareil reconnaissable et révocable seul dans
    # « Mes appareils », sans toucher aux autres appareils du cercle.
    reponse=$(curl -sS -X POST -H 'Content-Type: application/json' \
        -d "{\"code\":\"$(echapper_json "$code")\",\"nom\":\"$(echapper_json "$nom_appareil")\",\"type\":\"ia\"}" \
        "$url/api/appairage.php?action=valider") || echec 'serveur injoignable'

    message=$(json_chaine 'erreur' "$reponse")
    [ -z "$message" ] || echec "$message"

    jeton=$(json_chaine 'jeton' "$reponse")
    [ -n "$jeton" ] || echec 'réponse inattendue du serveur'

    # Le nom retenu par le serveur, pas celui demandé (§17, phase 40) : un
    # homonyme actif du cercle le fait suffixer, et le message de confirmation
    # déposé plus bas dans le flux doit porter le nom que le cercle voit.
    nom_retenu=$(json_chaine 'nom' "$reponse")
    [ -n "$nom_retenu" ] && nom_appareil="$nom_retenu"

    # Le nom du cercle vient du serveur, jamais d'une saisie locale.
    reponse_cercle=$(curl_authentifie "$jeton" -sS "$url/api/appareils.php") ||
        echec 'serveur injoignable'
    bloc=$(printf '%s' "$reponse_cercle" | sed -n 's/.*"utilisateur":{\([^}]*\)}.*/\1/p')
    nom_cercle=$(json_chaine 'nom' "$bloc")
    [ -n "$nom_cercle" ] || nom_cercle="$url"

    ecrire_config "$nom_cercle" "$url" "$jeton"

    DROP_NOM_CERCLE="$nom_cercle"
    DROP_URL="$url"
    DROP_JETON="$jeton"

    dire "Appairé au cercle « $nom_cercle » sous le nom « $nom_appareil »."

    # Un premier item confirme la chaîne complète de bout en bout, et se voit
    # aussitôt dans le flux : la preuve que tout fonctionne est à l'écran de
    # la personne qui a fourni le code, pas seulement dans cette sortie.
    if [ "${DROP_INSTALLATION:-0}" = '1' ]; then
        reponse=$(curl_authentifie "$jeton" -sS -X POST \
            -H 'Content-Type: application/json' \
            -d "{\"type\":\"texte\",\"contenu\":\"$(echapper_json "« $nom_appareil » est branché sur ce cercle.")\"}" \
            "$url/api/items.php" 2>/dev/null) || reponse=''
        [ -z "$(json_chaine 'erreur' "$reponse")" ] && [ -n "$reponse" ] &&
            dire 'Message de confirmation envoyé dans le flux.'

        proposer_code "$url" "$jeton" "$nom_cercle"
        avertir_chemin
    fi

    dire 'Prêt. Envoie un texte avec : drop-ia envoyer "…"'
}

# proposer_code <url> <jeton> <cercle> — un code d'appairage pour rejoindre ce
# même cercle depuis un autre appareil, affiché dans la foulée de
# l'installation. Le cercle qu'on vient de brancher n'a souvent qu'un seul
# appareil : sans ce code, y accéder depuis un téléphone ou un navigateur
# demanderait un accès au serveur, alors que tout vient de se jouer ici.
#
# Un échec ne remonte jamais : l'installation, elle, a réussi.
proposer_code() {
    url_code="$1"
    jeton_code="$2"
    cercle_code="$3"

    reponse_code=$(curl_authentifie "$jeton_code" -sS -X POST \
        "$url_code/api/appairage.php" 2>/dev/null) || return 0

    code_appairage=$(json_chaine 'code' "$reponse_code")
    [ -n "$code_appairage" ] || return 0

    duree=$(json_entier 'expire_dans' "$reponse_code")

    dire ''
    dire "Pour ouvrir « $cercle_code » sur un autre appareil — téléphone, navigateur :"
    dire ''
    dire "    $code_appairage"
    dire ''
    dire "  à saisir sur $url_code/?code=$code_appairage"
    dire "  (ou dans Drop : menu ⚙ → Rejoindre un autre cercle)"
    dire ''
    dire "  Valable ${duree:-120} secondes, une seule fois. Pour un autre code plus tard :"
    dire '  depuis Drop, menu ⚙ → Appairer un appareil.'
}

# Le dossier d'installation est absent du PATH sur bien des systèmes : sans
# cet avertissement, la commande suivante échouerait sans que rien n'explique
# pourquoi, alors que l'installation elle-même a réussi.
avertir_chemin() {
    case ":$PATH:" in
        *":$HOME/.local/bin:"*) return 0 ;;
    esac

    dire ''
    dire "Attention : $HOME/.local/bin n'est pas dans ton PATH."
    dire "  · pour cette session   : export PATH=\"\$HOME/.local/bin:\$PATH\""
    dire "  · durablement          : ajoute cette ligne à ~/.profile ou ~/.bashrc"
    dire "  · ou appelle le chemin complet : $HOME/.local/bin/drop-ia envoyer \"…\""
    dire ''
}

cmd_envoyer() {
    charger_config

    if [ $# -gt 0 ]; then
        texte="$1"
    elif [ ! -t 0 ]; then
        texte=$(cat)
    else
        echec 'rien à envoyer. Usage : drop-ia envoyer "texte", ou … | drop-ia envoyer'
    fi

    [ -n "$(printf '%s' "$texte" | tr -d '[:space:]')" ] || echec 'contenu vide'

    reponse=$(api POST '/api/items.php' \
        "{\"type\":\"texte\",\"contenu\":\"$(echapper_json "$texte")\"}")
    dire "Envoyé dans « $DROP_NOM_CERCLE » (item $(json_entier 'id' "$reponse"))."
}

cmd_fichier() {
    charger_config

    chemin="${1:-}"
    legende="${2:-}"

    [ -n "$chemin" ] || echec 'chemin manquant. Usage : drop-ia fichier <chemin> [légende]'
    [ -f "$chemin" ] || echec "fichier introuvable : $chemin"

    if [ -n "$legende" ]; then
        reponse=$(curl_authentifie "$DROP_JETON" -sS -X POST \
            -F "fichier=@$chemin" -F "contenu=$legende" \
            "$DROP_URL/api/items.php") || echec 'serveur injoignable'
    else
        reponse=$(curl_authentifie "$DROP_JETON" -sS -X POST \
            -F "fichier=@$chemin" \
            "$DROP_URL/api/items.php") || echec 'serveur injoignable'
    fi

    message=$(json_chaine 'erreur' "$reponse")
    [ -z "$message" ] || echec "$message"

    dire "Envoyé dans « $DROP_NOM_CERCLE » : $(basename "$chemin") (item $(json_entier 'id' "$reponse"))."
}

cmd_lire() {
    charger_config

    limite=10
    while [ $# -gt 0 ]; do
        case "$1" in
            -n) exiger_valeur -n $#; limite="$2"; shift 2 ;;
            -n*) limite="${1#-n}"; shift ;;
            *) shift ;;
        esac
    done

    reponse=$(api GET "/api/items.php?limite=$limite")

    # Découpe le tableau « items » en un objet par ligne.
    objets=$(printf '%s\n' "$reponse" |
        sed "s/\\\\\"/$MARQUEUR/g" |
        sed -e 's/^.*"items":\[//' \
            -e 's/\],"dernier_id".*$//' -e 's/\]}$//' \
            -e 's/},{/}\
{/g' |
        sed "s/$MARQUEUR/\\\\\"/g")

    [ -n "$objets" ] || { dire "Le flux de « $DROP_NOM_CERCLE » est vide."; return 0; }

    dire "Cercle « $DROP_NOM_CERCLE » — $limite éléments les plus récents au plus :"
    printf '%s\n' "$objets" | while IFS= read -r objet; do
        [ -n "$objet" ] || continue

        identifiant=$(json_entier 'id' "$objet")
        type=$(json_chaine 'type' "$objet")
        appareil=$(json_chaine 'appareil' "$objet")

        if [ "$type" = 'fichier' ]; then
            nom=$(json_chaine 'nom_fichier' "$objet")
            taille=$(json_entier 'taille' "$objet")
            description="$nom ($(formater_taille "${taille:-0}"))"
        elif printf '%s' "$objet" | grep -q '"chiffre":true'; then
            # Coffre (§17, phase 41) : chiffré dans le navigateur qui l'a
            # envoyé, sa clé n'en sort jamais. Rien à afficher ici, et surtout
            # pas l'enveloppe base64.
            description='[élément chiffré — à ouvrir dans le navigateur]'
        else
            description=$(json_chaine 'contenu' "$objet" | tr '\n' ' ' | cut -c1-70)
        fi

        printf '%5s  %-8s  %-18s  %s\n' "$identifiant" "$type" "$appareil" "$description"
    done
}

cmd_etat() {
    if [ ! -f "$CONFIG" ]; then
        dire 'Pas encore appairé.'
        dire 'Demande un code à six chiffres, puis lance :'
        dire '  drop-ia appairer <code> --url https://drop.exemple.fr'
        return 0
    fi

    charger_config

    dire "Appairé au cercle « $DROP_NOM_CERCLE » sur $DROP_URL."

    # Le jeton peut avoir été révoqué depuis l'appareil qui l'a invité : mieux
    # vaut le dire ici que de le découvrir au premier envoi.
    reponse=$(curl_authentifie "$DROP_JETON" -sS -o /dev/null -w '%{http_code}' \
        "$DROP_URL/api/items.php?limite=1" 2>/dev/null) || reponse=''

    case "$reponse" in
        200) dire 'Jeton valide.' ;;
        401) dire 'Jeton refusé : cet appareil a été révoqué. Refais un appairage avec un nouveau code.' ;;
        '')  dire 'Serveur injoignable.' ;;
        *)   dire "Réponse inattendue du serveur (HTTP $reponse)." ;;
    esac
}

cmd_aide() {
    cat <<AIDE
drop-ia $VERSION — dépose et lit des éléments dans un cercle Drop.

  drop-ia envoyer "texte"          envoie un texte
  … | drop-ia envoyer              envoie l'entrée standard
  drop-ia fichier <chemin> [note]  envoie un fichier, avec une légende facultative
  drop-ia lire [-n 10]             affiche les éléments les plus récents
  drop-ia etat                     cercle appairé et validité du jeton
  drop-ia appairer <code> --url <URL> [--nom NOM]
                                   rejoint un cercle avec un code à six chiffres

Un seul cercle par installation. Pour en suivre plusieurs depuis cette machine,
DROP_IA_CONFIG désigne un autre fichier de configuration — un par cercle :

  DROP_IA_CONFIG=~/.config/drop/ia-jeux.conf drop-ia appairer <code> --url <URL>
  DROP_IA_CONFIG=~/.config/drop/ia-jeux.conf drop-ia envoyer "…"

Le jeton est dans (mode 600) :
  $CONFIG
Il ne doit apparaître dans aucune réponse, aucun message, aucun fichier de
travail : le code d'appairage suffit à en refaire un, le jeton ne se recopie
jamais.
AIDE
}

# ------------------------------------------------------------------ dispatch

[ $# -gt 0 ] || { cmd_aide; exit 0; }

commande="$1"
shift

case "$commande" in
    installer) cmd_installer "$@" ;;
    appairer)  cmd_appairer "$@" ;;
    envoyer)   cmd_envoyer "$@" ;;
    fichier)   cmd_fichier "$@" ;;
    lire|liste) cmd_lire "$@" ;;
    etat|état) cmd_etat "$@" ;;
    aide|--aide|-h|--help) cmd_aide ;;
    version|--version) dire "drop-ia $VERSION" ;;
    *) echec "commande inconnue : $commande. Lance « drop-ia aide »." ;;
esac