#!/usr/bin/env bash
# ccs — Claude Code account Switcher
# Gère plusieurs comptes Claude Code sur ce PC et bascule de l'un à l'autre.
#
# Principe : chaque profil stocke le token OAuth (claudeAiOauth) et les infos
# du compte (oauthAccount). Basculer = réinjecter ces données dans
# ~/.claude/.credentials.json et ~/.claude.json. Settings, historique, plugins,
# MCP, projets restent partagés entre tous les comptes.

set -euo pipefail

CONFIG_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
CREDS="$CONFIG_DIR/.credentials.json"
if [[ -n "${CLAUDE_CONFIG_DIR:-}" ]]; then
  GLOBAL="$CLAUDE_CONFIG_DIR/.claude.json"
else
  GLOBAL="$HOME/.claude.json"
fi
STORE="${CCS_HOME:-$HOME/.claude-accounts}"
CA="$(dirname "$(readlink -f "$0")")/claude-accounts"

c_green=$'\e[32m'; c_dim=$'\e[2m'; c_bold=$'\e[1m'; c_red=$'\e[31m'; c_off=$'\e[0m'
[[ -t 1 ]] || { c_green=; c_dim=; c_bold=; c_red=; c_off=; }

# Option --notifier (commandes des raccourcis clavier) : le résultat de la bascule part
# aussi en notification bureau.
NOTIFY=""
# Origine de la bascule pour le journal (switch-origin.json, lu par le service) : « ccs »
# à la main, « raccourci » avec --notifier ; CCS_VIA vide (appel par l'application, le
# service, l'icône…) : rien n'est noté, l'appelant s'en charge.
ORIGIN_VIA="${CCS_VIA-ccs}"
ORIGIN_KEEP_S=60  # origine notée par l'appelant juste avant pour le même compte : gardée

die() {
  echo "${c_red}ccs: $*${c_off}" >&2
  notify_desktop "Bascule impossible" "$*"
  exit 1
}

# Notification bureau (seulement avec --notifier) : par claude-accounts (D-Bus), sinon
# notify-send. Ne fait jamais échouer la commande.
notify_desktop() {
  [[ -n "$NOTIFY" ]] || return 0
  if [[ -x "$CA" ]] && "$CA" notify -- "$1" "${2:-}" >/dev/null 2>&1; then
    return 0
  fi
  if command -v notify-send >/dev/null 2>&1; then
    notify-send -a "CCS" -i io.ccs.ClaudeAccounts -h boolean:transient:true \
      -- "$1" "${2:-}" >/dev/null 2>&1 || true
  fi
  return 0
}

# Retire --notifier des arguments (reste dans ARGS) ; avec lui, résultat notifié et
# bascule notée « raccourci » (sauf origine imposée par CCS_VIA).
take_notifier() {
  ARGS=()
  local a
  for a in "$@"; do
    if [[ "$a" == --notifier ]]; then
      NOTIFY=1
      [[ -n "${CCS_VIA+x}" ]] || ORIGIN_VIA=raccourci
    else
      ARGS+=("$a")
    fi
  done
}
need() { command -v "$1" >/dev/null || die "commande requise introuvable : $1"; }
need jq
need flock

umask 077
mkdir -p "$STORE"

# Écrit stdin dans $1 de façon atomique en conservant des droits 600.
atomic_write() {
  local dest="$1" tmp
  tmp="$(mktemp "$dest.ccs.XXXXXX")"
  cat >"$tmp"
  jq empty "$tmp" 2>/dev/null || { rm -f "$tmp"; die "JSON invalide généré pour $dest"; }
  chmod 600 "$tmp"
  mv -f "$tmp" "$dest"
}

# Même verrou que la partie Python (renouvellement des jetons) : une bascule ne
# peut pas croiser un renouvellement en cours et installer un jeton périmé.
lock_store() { exec 9>"$STORE/.lock"; flock 9; }
unlock_store() { flock -u 9; exec 9>&-; }

valid_name() { [[ "$1" =~ ^[A-Za-z0-9._-]+$ ]] || die "nom de profil invalide : '$1' (lettres, chiffres, . _ -)"; }

profiles() { find "$STORE" -mindepth 1 -maxdepth 1 -type d -printf '%f\n' 2>/dev/null | sort; }

# Vrai si le fichier $1 contient un jeton de renouvellement non vide. Une
# connexion perdue laisse "" à sa place : jq tiendrait "" pour une valeur
# valide avec `// empty`, d'où ce test explicite.
has_token() {
  [[ -f "$1" ]] && jq -e '.claudeAiOauth.refreshToken | type == "string" and length > 0' "$1" >/dev/null 2>&1
}

live_logged_in() { has_token "$CREDS"; }

# Identifiant "compte+org" du compte actuellement connecté.
live_key() {
  [[ -f "$GLOBAL" ]] || return 0
  jq -r '.oauthAccount | if . then "\(.accountUuid)|\(.organizationUuid)" else empty end' "$GLOBAL"
}

profile_key() {
  jq -r '"\(.accountUuid)|\(.organizationUuid)"' "$STORE/$1/account.json" 2>/dev/null
}

# Nom du profil correspondant au compte connecté (vide si aucun).
active_profile() {
  local key p
  key="$(live_key)"
  [[ -n "$key" ]] || return 0
  for p in $(profiles); do
    [[ "$(profile_key "$p")" == "$key" ]] && { echo "$p"; return 0; }
  done
  return 0
}

# Copie l'état de connexion actuel dans le profil $1.
save_live_to() {
  local name="$1" dir="$STORE/$1"
  live_logged_in || die "aucun compte Claude connecté (lance 'claude auth login' ou 'ccs add <nom>')"
  jq -e '.oauthAccount' "$GLOBAL" >/dev/null 2>&1 || die "oauthAccount absent de $GLOBAL"
  mkdir -p "$dir"
  jq '{claudeAiOauth, organizationUuid}' "$CREDS" | atomic_write "$dir/oauth.json"
  jq '.oauthAccount' "$GLOBAL" | atomic_write "$dir/account.json"
}

# Avant de basculer : les tokens sont renouvelés en continu par Claude Code,
# donc on resynchronise le profil actif pour ne jamais garder un token périmé.
sync_active() {
  local cur
  cur="$(active_profile)"
  if [[ -n "$cur" ]] && live_logged_in; then
    save_live_to "$cur"
  fi
}

install_profile() {
  local name="$1" dir="$STORE/$1"
  [[ -f "$dir/oauth.json" && -f "$dir/account.json" ]] || die "profil inconnu : $name (voir 'ccs list')"
  has_token "$dir/oauth.json" || die "'$name' : connexion perdue, reconnecte ce compte avec 'ccs rm $name' puis 'ccs add $name'"
  mkdir -p "$CONFIG_DIR"
  [[ -f "$CREDS" ]] || echo '{}' | atomic_write "$CREDS"
  [[ -f "$GLOBAL" ]] || echo '{}' | atomic_write "$GLOBAL"
  # On ne remplace que la partie compte : les tokens MCP (mcpOAuth) etc. restent.
  jq --slurpfile p "$dir/oauth.json" '. + $p[0]' "$CREDS" | atomic_write "$CREDS"
  jq --slurpfile a "$dir/account.json" '.oauthAccount = $a[0]' "$GLOBAL" | atomic_write "$GLOBAL"
}

describe() {
  jq -r --arg d "$c_dim" --arg o "$c_off" '"\(.emailAddress // "?")  \($d)\(.organizationName // "")\($o)"' "$STORE/$1/account.json" 2>/dev/null
}

plan_of() {
  jq -r '.claudeAiOauth.subscriptionType // "?"' "$STORE/$1/oauth.json" 2>/dev/null
}

open_sessions() {
  local n
  n="$(pgrep -u "$(id -u)" -xc claude 2>/dev/null || true)"
  echo "${n:-0}"
}

running_warning() {
  local n="$1"
  if [[ "${n:-0}" -gt 0 ]]; then
    echo "${c_dim}↻ $n session(s) Claude Code ouverte(s) : elles passeront sur ce compte à leur prochaine requête.${c_off}"
  fi
}

# Texte de la notification d'une bascule : adresse, organisation, sessions ouvertes.
switch_notice() {
  local name="$1" n="$2" text
  text="$(jq -r '[.emailAddress // empty, .organizationName // empty] | join(" · ")' \
    "$STORE/$name/account.json" 2>/dev/null || true)"
  if [[ "${n:-0}" -gt 0 ]]; then
    text+="${text:+. }$n session(s) Claude Code ouverte(s) passeront sur ce compte à leur prochaine requête."
  fi
  printf '%s' "$text"
}

# Note l'origine de la bascule vers $1 pour le journal des bascules, au format de
# switch_log.note_origin : {"profile", "via", "ts"} dans switch-origin.json (600). Jamais
# bloquant : la moindre erreur laisse la bascule se faire sans note.
note_origin() {
  local name="$1" file="$STORE/switch-origin.json" now tmp
  case "$ORIGIN_VIA" in
    application|icone|notification|ccs|nouvelle-session|projet|raccourci) ;;
    *) return 0 ;;
  esac
  # Bascule refusée plus loin (install_profile) : pas de note.
  [[ -f "$STORE/$name/account.json" ]] && has_token "$STORE/$name/oauth.json" || return 0
  now="$(date +%s.%N 2>/dev/null)" || return 0
  [[ "$now" =~ ^[0-9]+\.[0-9]+$ ]] || return 0
  if [[ -f "$file" ]] && jq -e --arg p "$name" --argjson now "$now" --argjson keep "$ORIGIN_KEEP_S" \
      '.profile == $p and (.ts | type == "number") and ($now - .ts) >= 0 and ($now - .ts) < $keep' \
      "$file" >/dev/null 2>&1; then
    return 0  # notée juste avant par l'application, l'icône… : la plus précise, on la garde
  fi
  tmp="$(mktemp "$file.XXXXXX" 2>/dev/null)" || return 0
  if jq -n --arg p "$name" --arg v "$ORIGIN_VIA" --argjson ts "$now" \
      '{profile: $p, via: $v, ts: $ts}' >"$tmp" 2>/dev/null && chmod 600 "$tmp" 2>/dev/null \
      && mv -f "$tmp" "$file" 2>/dev/null; then
    return 0
  fi
  rm -f "$tmp" 2>/dev/null
  return 0
}

cmd_list() {
  local cur p mark
  cur="$(active_profile)"
  if [[ -z "$(profiles)" ]]; then
    echo "Aucun profil. Enregistre le compte actuel avec : ccs save <nom>"
    return
  fi
  for p in $(profiles); do
    if [[ "$p" == "$cur" ]]; then mark="${c_green}●${c_off}"; else mark=" "; fi
    printf '%s %s%-14s%s %-6s %s\n' "$mark" "$c_bold" "$p" "$c_off" "$(plan_of "$p")" "$(describe "$p")"
  done
  if [[ -z "$cur" ]] && live_logged_in; then
    echo "${c_dim}(le compte connecté n'est enregistré dans aucun profil : ccs save <nom>)${c_off}"
  fi
}

cmd_save() {
  local name="${1:-}"; [[ -n "$name" ]] || die "usage : ccs save <nom>"
  valid_name "$name"
  local cur; cur="$(active_profile)"
  if [[ -n "$cur" && "$cur" != "$name" ]]; then
    die "ce compte est déjà enregistré sous '$cur' (ccs rename $cur $name pour le renommer)"
  fi
  lock_store
  save_live_to "$name"
  unlock_store
  echo "${c_green}✔${c_off} profil '$name' enregistré : $(describe "$name")"
}

cmd_add() {
  local name="${1:-}"; [[ -n "$name" ]] || die "usage : ccs add <nom> [--email adresse] [--console]"
  shift
  valid_name "$name"
  [[ ! -d "$STORE/$name" ]] || die "le profil '$name' existe déjà"
  if live_logged_in && [[ -z "$(active_profile)" ]]; then
    die "le compte actuellement connecté n'est pas enregistré ; fais d'abord 'ccs save <nom>' pour ne pas le perdre"
  fi
  lock_store
  sync_active
  unlock_store
  local before; before="$(live_key)"
  echo "Connexion du nouveau compte '$name' (choisis bien un AUTRE compte dans le navigateur)…"
  # Pas de 'claude auth logout' : il révoquerait le token du profil précédent.
  claude auth login "$@"
  local after; after="$(live_key)"
  if [[ -n "$before" && "$before" == "$after" ]]; then
    die "c'est le même compte que celui déjà connecté ; rien n'a été ajouté"
  fi
  local dup
  dup="$(active_profile)"
  [[ -z "$dup" ]] || die "ce compte est déjà enregistré sous '$dup'"
  lock_store
  save_live_to "$name"
  unlock_store
  echo "${c_green}✔${c_off} profil '$name' ajouté et actif : $(describe "$name")"
}

cmd_use() {
  take_notifier "$@"
  [[ ${#ARGS[@]} -le 1 ]] || die "usage : ccs use <nom> [--notifier]"
  local name="${ARGS[0]:-}"; [[ -n "$name" ]] || die "usage : ccs use <nom> [--notifier]"
  [[ -d "$STORE/$name" ]] || die "profil inconnu : $name (voir 'ccs list')"
  local cur; cur="$(active_profile)"
  if [[ "$cur" == "$name" ]]; then
    echo "Déjà sur '$name' : $(describe "$name")"
    notify_desktop "Déjà sur $name" "$(switch_notice "$name" 0)"
    return
  fi
  if live_logged_in && [[ -z "$cur" ]]; then
    die "le compte connecté n'est enregistré dans aucun profil ; 'ccs save <nom>' d'abord"
  fi
  note_origin "$name" || true
  lock_store
  sync_active
  install_profile "$name"
  unlock_store
  echo "${c_green}✔${c_off} basculé sur '$name' : $(describe "$name")"
  local n; n="$(open_sessions)"
  running_warning "$n"
  notify_desktop "Bascule sur $name" "$(switch_notice "$name" "$n")"
}

# Profil suivant (ordre alphabétique, retour au début), en sautant ceux dont la
# connexion est perdue.
cmd_next() {
  take_notifier "$@"
  [[ ${#ARGS[@]} -eq 0 ]] || die "usage : ccs next [--notifier]"
  local all cur i k n first=0 count cand names="" cmds=""
  local -a lost=()
  mapfile -t all < <(profiles)
  n="${#all[@]}"
  [[ "$n" -gt 0 ]] || die "aucun profil"
  cur="$(active_profile)"
  count="$n"
  for ((i = 0; i < n; i++)); do
    if [[ "${all[$i]}" == "$cur" ]]; then
      first=$((i + 1)); count=$((n - 1))
      break
    fi
  done
  if [[ "$count" -eq 0 ]]; then
    cmd_use "$cur"  # profil unique : « Déjà sur … »
    return
  fi
  for ((k = 0; k < count; k++)); do
    cand="${all[$(((first + k) % n))]}"
    if has_token "$STORE/$cand/oauth.json"; then
      cmd_use "$cand"
      return
    fi
    lost+=("$cand")
  done
  for cand in "${lost[@]}"; do
    names+="${names:+, }$cand"
    cmds+="${cmds:+ ; }'ccs rm $cand' puis 'ccs add $cand'"
  done
  die "aucun autre profil utilisable, connexion perdue pour : $names (reconnecte avec $cmds)"
}

cmd_rm() {
  local name="${1:-}"; [[ -n "$name" ]] || die "usage : ccs rm <nom>"
  [[ -d "$STORE/$name" ]] || die "profil inconnu : $name"
  [[ "$(active_profile)" != "$name" ]] || die "'$name' est le compte actif ; bascule d'abord sur un autre"
  rm -rf -- "${STORE:?}/$name"
  echo "profil '$name' supprimé (le compte reste valide côté Anthropic)"
}

cmd_rename() {
  local old="${1:-}" new="${2:-}"
  [[ -n "$old" && -n "$new" ]] || die "usage : ccs rename <ancien> <nouveau>"
  valid_name "$new"
  [[ -d "$STORE/$old" ]] || die "profil inconnu : $old"
  [[ ! -e "$STORE/$new" ]] || die "'$new' existe déjà"
  mv -- "$STORE/$old" "$STORE/$new"
  echo "'$old' → '$new'"
}

cmd_current() {
  local cur; cur="$(active_profile)"
  if [[ -n "$cur" ]]; then echo "$cur"; else echo "(aucun profil)"; return 1; fi
}

usage() {
  cat <<EOF
${c_bold}ccs${c_off} — bascule entre plusieurs comptes Claude Code

  ccs                      liste les profils (● = actif)
  ccs <nom>                bascule sur le profil <nom> (ou : ccs use <nom>)
  ccs next                 bascule sur le profil suivant utilisable (pratique en cas de limite atteinte)
  ccs save <nom>           enregistre le compte actuellement connecté sous <nom>
  ccs add <nom> [opts]     connecte un nouveau compte (claude auth login) et l'enregistre
                           opts : --email <adresse>  --console  --sso
  ccs best                 bascule sur le meilleur compte maintenant
  ccs status               compte actif, prévision, meilleur compte, capacité restante
  ccs usage                affiche l'usage (session / semaine) de TOUS les comptes
  ccs auto on|off          active / désactive la bascule automatique (98 %)
  ccs pause [durée]        suspend la bascule automatique et l'orchestrateur :
                           1h, 4h, demain, manuel ; off pour reprendre ; status (défaut) : état
  ccs silence [durée]      ne pas déranger : retient les notifications (résumées à la fin) :
                           1h, 4h, demain ; off ou reprendre pour lever ; status (défaut) : état
                           (alias : quiet)
  ccs orch on|off          orchestrateur : enchaîne et décale les fenêtres de 5 h des comptes
  ccs plan                 planning des fenêtres et des recharges à venir
  ccs sessions             sessions Claude Code ouvertes : projet, état, consommation, mémoire (RAM)
                           et badge « contexte lourd »
  ccs tache [ajouter "<message>" [-C dossier] [--modele m] [--droits lecture|modifications|tout]
            [--quand quota|nuit|HH:MM] | voir <id> | annuler <id> | supprimer <id>]
                           file de tâches lancées par le service, sans fenêtre (alias : taches, tasks)
  ccs budget [<dossier> <montant>|aucun]
                           budget hebdomadaire par projet (équivalent dollars) : état, fixer, retirer
  ccs fiche <id>           fiche « où j'en étais » d'une conversation (marche aussi sur une archivée)
  ccs sauvegarde [fichier] sauvegarde chiffrée (gpg) des profils, réglages, budgets, raccourcis
                           (alias : backup)
  ccs restaurer <fichier> [--oui]
                           restaure une sauvegarde, avec confirmation avant d'écraser (alias : restore)
  ccs telephone [essai]    notifications sur le téléphone (ntfy) : état et lien d'abonnement ;
                           « essai » envoie un message d'essai (alias : phone)
  ccs conv [mots] [opts]   historique des conversations Claude Code du PC (recherche)
                           opts : -p <projet>  --vscode  --terminal  --all  --json
  ccs resume <id> [opts]   reprend une conversation ici (ou --vscode, --new-terminal, --print) ;
                           une conversation archivée est d'abord restaurée
                           --dir <dossier> : depuis un projet déplacé
  ccs title <id> <titre>   renomme une conversation (comme /rename dans Claude Code)
  ccs preview <id>         affiche une conversation en Markdown, avec son coût (alias : apercu)
  ccs export <id> [fichier.md]
                           exporte une conversation en Markdown (défaut : <titre>.md ici)
  ccs integrate on|off     ligne d'état dans Claude Code + bascule après blocage (hook)
  ccs analyze [--days N]   où part ton usage : projets, modèles, heures, conseils
  ccs formule              la formule qu'il te faut (Pro, Max, Ultra) d'après ton usage réel
                           (alias : conseil)
  ccs semaine [--precedente N]
                           bilan de la semaine écoulée (ou de N semaines plus tôt)
  ccs mois [--precedent N]
                           rapport du mois écoulé (ou de N mois plus tôt)
  ccs moment [--duree 3h] [--sur 24h]
                           meilleur moment pour lancer une grosse tâche (quota d'affilée)
  ccs mise-a-jour [--verifier]
                           installe la dernière version de CCS (.deb de GitHub, vérifié) ;
                           --verifier : dit seulement s'il y en a une (alias : maj)
  ccs journal [--jours N | --tout]
                           journal des bascules avec leur raison (7 derniers jours par défaut)
  ccs projet [<dossier>] [<compte>|aucun]
                           compte par projet : liste, compte d'un dossier, association
  ccs raccourcis [status|on|off [action…]|set <action> <raccourci>]
                           raccourcis clavier globaux du bureau GNOME (alias : shortcuts)
  ccs tui [--serveur NOM]  CCS en plein écran dans le terminal (ici, ou sur un serveur appairé)
  ccs distant machines [--vite]
                           machines du réseau Ricochet : en ligne ou non, charge, outils
  ccs distant lancer [--machine M] [--outil O] [--rapatrier chemin] -- <commande>
                           lance une commande du projet sur une autre machine (tunnel SSH, rsync)
  ccs serveur ajouter|liste|retirer
                           serveurs CCS distants : appairage (mot de passe Ubuntu + code), liste
  ccs doctor               bilan de santé : service, version, bureau, comptes, Claude Code
                           (code de sortie 1 au moindre problème)
  ccs gui                  ouvre l'application graphique
  ccs current              affiche le profil actif
  ccs rename <a> <b>       renomme un profil
  ccs rm <nom>             supprime un profil

  --notifier (next, use, best, pause, silence) : résultat aussi en notification bureau ; c'est
  l'option des raccourcis clavier (bascule notée « raccourci » dans le journal)

Profils stockés dans : $STORE
EOF
}

main() {
  local cmd="${1:-list}"
  [[ $# -gt 0 ]] && shift
  case "$cmd" in
    list|ls) cmd_list ;;
    save) cmd_save "$@" ;;
    add|login) cmd_add "$@" ;;
    use|switch|sw) cmd_use "$@" ;;
    next|n) cmd_next "$@" ;;
    current|whoami) cmd_current ;;
    rm|remove|delete) cmd_rm "$@" ;;
    rename|mv) cmd_rename "$@" ;;
    usage|u) exec "$CA" print ;;
    gui|app) setsid -f "$CA" gui >/dev/null 2>&1 ;;
    best|b) exec "$CA" best --switch "$@" ;;
    status|st) exec "$CA" status ;;
    auto) exec "$CA" auto "$@" ;;
    pause) exec "$CA" pause "$@" ;;
    doctor|bilan) exec "$CA" doctor ;;
    formule|conseil) exec "$CA" formule "$@" ;;
    semaine) exec "$CA" semaine "$@" ;;
    mois) exec "$CA" mois "$@" ;;
    moment) exec "$CA" moment "$@" ;;
    silence|quiet) exec "$CA" silence "$@" ;;
    mise-a-jour|maj) exec "$CA" mise-a-jour "$@" ;;
    journal) exec "$CA" journal "$@" ;;
    tui) exec "$CA" tui "$@" ;;
    serveur|server) exec "$CA" serveur "$@" ;;
    totp) exec "$CA" totp "$@" ;;
    bridge|web-serve|auth-serve|shell-distant) exec "$CA" "$cmd" "$@" ;;
    projet) exec "$CA" projet "$@" ;;
    raccourcis|shortcuts) exec "$CA" raccourcis "$@" ;;
    orch|orchestrateur) exec "$CA" orch "$@" ;;
    plan|planning) exec "$CA" plan ;;
    sessions|ps) exec "$CA" sessions ;;
    tache|taches|tasks) exec "$CA" tache "$@" ;;
    distant) exec "$CA" distant "$@" ;;
    budget) exec "$CA" budget "$@" ;;
    fiche) exec "$CA" fiche "$@" ;;
    sauvegarde|backup) exec "$CA" sauvegarde "$@" ;;
    restaurer|restore) exec "$CA" restaurer "$@" ;;
    telephone|phone) exec "$CA" telephone "$@" ;;
    conv|conversations|historique) exec "$CA" conversations "$@" ;;
    resume|reprendre) exec "$CA" resume "$@" ;;
    title|titre) exec "$CA" title "$@" ;;
    preview|apercu|aperçu) exec "$CA" preview "$@" ;;
    export|exporter) exec "$CA" export "$@" ;;
    integrate|integration) exec "$CA" integrate "${1:-status}" ;;
    analyze|stats) exec "$CA" analyze "$@" ;;
    version|--version|-v) exec "$CA" --version ;;
    -h|--help|help) usage ;;
    *)
      if [[ -d "$STORE/$cmd" ]]; then cmd_use "$cmd" "$@"
      else echo "${c_red}commande ou profil inconnu : $cmd${c_off}" >&2; usage; exit 1
      fi ;;
  esac
}

main "$@"
