setup.sh

#!/usr/bin/env bash
# setup.sh - Unified installer for c2switcher and Cinnamon applet
#
# Usage:
#   curl -fsSL https://raw.githubusercontent.com/incompletebiped/c2switcher-mint/master/setup.sh | bash
#   curl -fsSL ... | bash -s -- --all
#   ./setup.sh              # Interactive mode (asks what to install)
#   ./setup.sh --all        # Install everything (CLI + applet + status line)
#   ./setup.sh --cli        # Install CLI only
#   ./setup.sh --applet     # Install Cinnamon applet only (requires CLI)
#   ./setup.sh --statusline # Install Claude Code status line only (requires CLI)
#   ./setup.sh --uninstall  # Uninstall everything

set -e

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

REPO_URL="https://github.com/incompletebiped/c2switcher-mint.git"

# Determine source directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd)" || SCRIPT_DIR=""
CLONED_DIR=""

if [[ -z "$SCRIPT_DIR" || ! -f "$SCRIPT_DIR/pyproject.toml" ]]; then
    # Running via curl pipe or from wrong directory — need to clone the repo
    if ! command -v git &> /dev/null; then
        echo -e "${RED}Error: git is required. Install it with: sudo apt install git${NC}"
        exit 1
    fi

    CLONED_DIR="$(mktemp -d)"
    trap 'rm -rf "$CLONED_DIR"' EXIT

    echo -e "${BLUE}Cloning c2switcher-mint...${NC}"
    git clone --depth 1 "$REPO_URL" "$CLONED_DIR/c2switcher-mint" 2>&1 | tail -1
    SCRIPT_DIR="$CLONED_DIR/c2switcher-mint"
    echo -e "${GREEN}✓ Repository cloned${NC}"
    echo
fi

APPLET_SRC="$SCRIPT_DIR/applet"
APPLET_UUID="c2switcher@c2switcher-mint"
APPLET_DEST="$HOME/.local/share/cinnamon/applets/$APPLET_UUID"

# Ensure pipx is available (required for PEP 668 / externally-managed Python)
ensure_pipx() {
    if command -v pipx &> /dev/null; then
        return 0
    fi
    echo -e "${BLUE}Installing pipx (required for Python CLI tools on this system)...${NC}"
    if command -v apt &> /dev/null; then
        sudo apt update -qq && sudo apt install -y pipx
    else
        python3 -m pip install --user pipx 2>/dev/null || {
            echo -e "${RED}Error: Could not install pipx. Please install it manually:${NC}"
            echo "  sudo apt install pipx"
            exit 1
        }
    fi
    pipx ensurepath &> /dev/null || true
    # Re-check
    if ! command -v pipx &> /dev/null; then
        # pipx may have been installed to ~/.local/bin which isn't on PATH yet
        export PATH="$HOME/.local/bin:$PATH"
    fi
    if ! command -v pipx &> /dev/null; then
        echo -e "${RED}Error: pipx installed but not found on PATH.${NC}"
        echo "  Try restarting your terminal, then run this script again."
        exit 1
    fi
    echo -e "${GREEN}✓ pipx installed${NC}"
}

# Parse arguments
INSTALL_CLI=false
INSTALL_APPLET=false
INSTALL_STATUSLINE=false
UNINSTALL=false
INTERACTIVE=true

for arg in "$@"; do
    case "$arg" in
        --all)
            INSTALL_CLI=true
            INSTALL_APPLET=true
            INSTALL_STATUSLINE=true
            INTERACTIVE=false
            ;;
        --cli)
            INSTALL_CLI=true
            INTERACTIVE=false
            ;;
        --applet)
            INSTALL_APPLET=true
            INTERACTIVE=false
            ;;
        --statusline)
            INSTALL_STATUSLINE=true
            INTERACTIVE=false
            ;;
        --uninstall)
            UNINSTALL=true
            INTERACTIVE=false
            ;;
        *)
            echo -e "${RED}Unknown option: $arg${NC}"
            echo "Usage: $0 [--all|--cli|--applet|--statusline|--uninstall]"
            exit 1
            ;;
    esac
done

# Header
echo -e "${CYAN}════════════════════════════════════════════════════════════${NC}"
echo -e "${CYAN}  C2Switcher Setup (Mint Cinnamon Edition)${NC}"
echo -e "${CYAN}════════════════════════════════════════════════════════════${NC}"
echo

# Uninstall mode
if [[ "$UNINSTALL" == true ]]; then
    echo -e "${YELLOW}Uninstalling c2switcher...${NC}"
    echo

    echo -e "${BLUE}Removing CLI package...${NC}"
    if command -v pipx &> /dev/null && pipx list 2>/dev/null | grep -q c2switcher; then
        pipx uninstall c2switcher
        echo -e "${GREEN}✓ CLI package removed (pipx)${NC}"
    elif python3 -m pip show c2switcher &> /dev/null 2>&1; then
        sudo python3 -m pip uninstall -y c2switcher
        echo -e "${GREEN}✓ CLI package removed (pip)${NC}"
    else
        echo -e "${YELLOW}c2switcher package not found${NC}"
    fi

    # Remove c2claude wrapper
    if [[ -f "$HOME/.local/bin/c2claude" ]]; then
        rm "$HOME/.local/bin/c2claude"
        echo -e "${GREEN}✓ c2claude removed from ~/.local/bin${NC}"
    fi
    if [[ -f "/usr/local/bin/c2claude" ]]; then
        sudo rm /usr/local/bin/c2claude
        echo -e "${GREEN}✓ c2claude removed from /usr/local/bin${NC}"
    fi

    # Remove Cinnamon applet
    if [[ -d "$APPLET_DEST" ]]; then
        echo -e "${BLUE}Removing Cinnamon applet...${NC}"
        rm -rf "$APPLET_DEST"
        echo -e "${GREEN}✓ Cinnamon applet removed${NC}"
    fi

    # Remove status line script and settings entry
    if [[ -f "$HOME/.claude/statusline-command.sh" ]]; then
        rm "$HOME/.claude/statusline-command.sh"
        echo -e "${GREEN}✓ Status line script removed${NC}"
    fi
    if [[ -f "$HOME/.claude/settings.json" ]]; then
        python3 -c "
import json, os
p = os.path.expanduser('~/.claude/settings.json')
with open(p) as f:
    try:
        s = json.load(f)
    except Exception:
        s = {}
s.pop('statusLine', None)
with open(p, 'w') as f:
    json.dump(s, f, indent=2)
    f.write('\n')
" && echo -e "${GREEN}✓ statusLine removed from ~/.claude/settings.json${NC}"
    fi

    echo
    echo -e "${GREEN}Uninstall complete!${NC}"
    echo -e "${YELLOW}Note: Database at ~/.c2switcher.db was NOT removed${NC}"
    echo "      Remove it manually if desired: rm ~/.c2switcher.db"
    echo
    exit 0
fi

# Interactive mode — only possible when running from a local checkout (stdin is a terminal)
if [[ "$INTERACTIVE" == true ]]; then
    if [[ -n "$CLONED_DIR" ]]; then
        # Piped install — can't prompt, default to --all
        echo -e "${YELLOW}Piped install detected, installing everything (CLI + applet)${NC}"
        echo
        INSTALL_CLI=true
        INSTALL_APPLET=true
    else
        echo "What would you like to install?"
        echo "  1) CLI tools only"
        echo "  2) CLI tools + Cinnamon applet"
        echo "  3) CLI tools + Cinnamon applet + Claude Code status line"
        echo "  4) Cinnamon applet only (requires CLI already installed)"
        echo "  5) Claude Code status line only (requires CLI already installed)"
        echo "  6) Uninstall everything"
        echo
        read -p "Enter choice [1-6]: " choice

        case "$choice" in
            1)
                INSTALL_CLI=true
                ;;
            2)
                INSTALL_CLI=true
                INSTALL_APPLET=true
                ;;
            3)
                INSTALL_CLI=true
                INSTALL_APPLET=true
                INSTALL_STATUSLINE=true
                ;;
            4)
                INSTALL_APPLET=true
                ;;
            5)
                INSTALL_STATUSLINE=true
                ;;
            6)
                exec "$0" --uninstall
                ;;
            *)
                echo -e "${RED}Invalid choice${NC}"
                exit 1
                ;;
        esac
        echo
    fi
fi

# Install Claude Code status line
install_statusline() {
    echo -e "${GREEN}Installing Claude Code status line...${NC}"
    echo

    mkdir -p "$HOME/.claude"

    cat > "$HOME/.claude/statusline-command.sh" << 'STATUSLINE_EOF'
#!/usr/bin/env bash
cat > /dev/null  # consume Claude Code's JSON input

# Use $'...' for actual escape bytes so printf '%s' is safe with % in paths/values
RESET=$'\033[00m'
PURPLE=$'\033[38;5;141m'
GREEN=$'\033[38;5;82m'
YELLOW=$'\033[38;5;226m'
RED=$'\033[38;5;196m'

usage_color() {
    local pct="${1%%%*}"; pct="${pct%.*}"
    if   [ "$pct" -ge 90 ] 2>/dev/null; then printf '%s' "$RED"
    elif [ "$pct" -ge 70 ] 2>/dev/null; then printf '%s' "$YELLOW"
    else                                      printf '%s' "$GREEN"
    fi
}

account=""
usage_str=""

if command -v c2switcher &>/dev/null; then
    account=$(c2switcher current --format=prompt 2>/dev/null)

    if [ -n "$account" ]; then
        idx=$(c2switcher current --json 2>/dev/null | python3 -c \
            "import sys,json; print(json.load(sys.stdin).get('index',''))" 2>/dev/null)

        if [ -n "$idx" ]; then
            usage_json=$(c2switcher usage --json 2>/dev/null)
            if [ -n "$usage_json" ]; then
                read -r five_h seven_d <<< "$(echo "$usage_json" | python3 -c "
import sys, json
data = json.load(sys.stdin)
idx = int('$idx')
for acc in data:
    if acc.get('index') == idx:
        u = acc.get('usage', {})
        fh = u.get('five_hour', {}).get('utilization')
        sd = u.get('seven_day', {}).get('utilization')
        print(
            (str(round(fh)) + '%') if fh is not None else '',
            (str(round(sd)) + '%') if sd is not None else ''
        )
        break
" 2>/dev/null)"

                if [ -n "$five_h" ] || [ -n "$seven_d" ]; then
                    [ -n "$five_h"  ] && usage_str+="$(usage_color "$five_h")5h:${five_h}${RESET}"
                    [ -n "$five_h"  ] && [ -n "$seven_d" ] && usage_str+=" "
                    [ -n "$seven_d" ] && usage_str+="$(usage_color "$seven_d")7d:${seven_d}${RESET}"
                fi
            fi
        fi
    fi
fi

if [ -n "$account" ]; then
    line="${PURPLE}${account}${RESET}"
    [ -n "$usage_str" ] && line+=" ${usage_str}"
    printf '%s' "$line"
fi
STATUSLINE_EOF

    chmod +x "$HOME/.claude/statusline-command.sh"
    echo -e "${GREEN}✓ Status line script written to ~/.claude/statusline-command.sh${NC}"

    # Merge statusLine key into ~/.claude/settings.json (preserves existing keys)
    python3 -c "
import json, os, sys
p = os.path.expanduser('~/.claude/settings.json')
s = {}
if os.path.exists(p):
    with open(p) as f:
        try:
            s = json.load(f)
        except Exception:
            pass
s['statusLine'] = {'type': 'command', 'command': sys.argv[1]}
with open(p, 'w') as f:
    json.dump(s, f, indent=2)
    f.write('\n')
" "bash $HOME/.claude/statusline-command.sh"

    echo -e "${GREEN}✓ ~/.claude/settings.json updated with statusLine config${NC}"
    echo
    echo -e "${YELLOW}Status line will show:${NC}"
    echo "  /your/working/dir [0] user@example.com"
    echo
}

# Install CLI
if [[ "$INSTALL_CLI" == true ]]; then
    echo -e "${GREEN}Installing CLI tools...${NC}"
    echo

    ensure_pipx

    if [[ -n "$CLONED_DIR" ]]; then
        # Remote install: standard install (temp dir cleaned up after)
        echo -e "${BLUE}Installing c2switcher package...${NC}"
        pipx install "$SCRIPT_DIR" --force
        echo -e "${GREEN}✓ c2switcher installed${NC}"
    else
        # Local checkout: editable install so source changes apply immediately
        echo -e "${BLUE}Installing c2switcher package (editable)...${NC}"
        pipx install --editable "$SCRIPT_DIR" --force
        echo -e "${GREEN}✓ c2switcher installed (editable - source changes apply immediately)${NC}"
    fi

    echo

    # Install c2claude wrapper
    echo -e "${BLUE}Installing c2claude wrapper...${NC}"
    mkdir -p "$HOME/.local/bin"
    if [[ -n "$CLONED_DIR" ]]; then
        # Remote install: copy the wrapper (source dir is temporary)
        cp -f "$SCRIPT_DIR/c2claude" "$HOME/.local/bin/c2claude"
        chmod +x "$HOME/.local/bin/c2claude"
        echo -e "${GREEN}✓ c2claude copied to ~/.local/bin/c2claude${NC}"
    else
        # Local checkout: symlink so updates propagate
        ln -sf "$SCRIPT_DIR/c2claude" "$HOME/.local/bin/c2claude"
        echo -e "${GREEN}✓ c2claude symlinked to ~/.local/bin/c2claude${NC}"
    fi

    echo

    # Ensure ~/.local/bin is on PATH
    export PATH="$HOME/.local/bin:$PATH"

    # Verify command visibility
    if ! command -v c2switcher &> /dev/null; then
        echo -e "${YELLOW}Warning: 'c2switcher' is not currently on your PATH${NC}"
        echo "You may need to add ~/.local/bin to your PATH:"
        echo "  echo 'export PATH=\"\$HOME/.local/bin:\$PATH\"' >> ~/.bashrc"
        echo
    else
        echo -e "${GREEN}✓ c2switcher command available at $(command -v c2switcher)${NC}"
    fi

    if ! command -v c2claude &> /dev/null; then
        echo -e "${YELLOW}Warning: 'c2claude' is not currently on your PATH${NC}"
        echo "You may need to add ~/.local/bin to your PATH:"
        echo "  echo 'export PATH=\"\$HOME/.local/bin:\$PATH\"' >> ~/.bashrc"
        echo
    else
        echo -e "${GREEN}✓ c2claude command available at $(command -v c2claude)${NC}"
    fi

    # Auto-import existing Claude credentials if present
    if [[ -f "$HOME/.claude/.credentials.json" ]]; then
        echo
        echo -e "${BLUE}Found existing Claude credentials, importing...${NC}"
        if c2switcher add 2>/dev/null; then
            echo -e "${GREEN}✓ Existing Claude account imported${NC}"
        else
            echo -e "${YELLOW}Could not auto-import (account may already be added)${NC}"
        fi
    fi
fi

# Install Cinnamon applet
if [[ "$INSTALL_APPLET" == true ]]; then
    echo -e "${GREEN}Installing Cinnamon applet...${NC}"
    echo

    # Check if c2switcher is installed
    if ! command -v c2switcher &> /dev/null; then
        echo -e "${YELLOW}⚠ Warning: c2switcher command not found${NC}"
        echo "  The applet requires c2switcher to be installed first."
        if [[ -z "$CLONED_DIR" ]]; then
            echo
            read -p "Continue anyway? (y/N) " -n 1 -r
            echo
            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
                exit 1
            fi
        else
            echo "  Continuing anyway (install CLI first if needed)."
            echo
        fi
    fi

    # Check that we're running Cinnamon
    if ! command -v cinnamon &> /dev/null; then
        echo -e "${YELLOW}⚠ Warning: Cinnamon desktop not detected${NC}"
        echo "  This applet is designed for the Cinnamon desktop environment."
        if [[ -z "$CLONED_DIR" ]]; then
            echo
            read -p "Continue anyway? (y/N) " -n 1 -r
            echo
            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
                exit 1
            fi
        else
            echo "  Continuing anyway."
            echo
        fi
    fi

    # Install applet
    mkdir -p "$APPLET_DEST"

    if [[ -d "$APPLET_DEST" && -f "$APPLET_DEST/metadata.json" ]]; then
        echo -e "${BLUE}Applet already installed, upgrading...${NC}"
    else
        echo -e "${BLUE}Installing applet to $APPLET_DEST...${NC}"
    fi

    cp -f "$APPLET_SRC/metadata.json" "$APPLET_DEST/"
    cp -f "$APPLET_SRC/applet.js" "$APPLET_DEST/"
    cp -f "$APPLET_SRC/stylesheet.css" "$APPLET_DEST/"

    echo -e "${GREEN}✓ Cinnamon applet installed${NC}"
    echo
    echo -e "${YELLOW}To activate the applet:${NC}"
    echo "  1. Right-click on your panel"
    echo "  2. Click 'Applets'"
    echo "  3. Find 'Claude Code Usage' and enable it"
    echo
    echo -e "${YELLOW}If upgrading, you may need to restart Cinnamon:${NC}"
    echo "  Press Alt+F2, type 'r', and press Enter"
    echo
fi

# Install status line
if [[ "$INSTALL_STATUSLINE" == true ]]; then
    install_statusline
fi

# Final message
echo -e "${CYAN}════════════════════════════════════════════════════════════${NC}"
echo -e "${GREEN}✅ Installation complete!${NC}"
echo -e "${CYAN}════════════════════════════════════════════════════════════${NC}"
echo

if [[ "$INSTALL_CLI" == true ]]; then
    echo -e "${BLUE}CLI Tools:${NC}"
    echo "  c2switcher - Manage Claude Code accounts"
    echo "  c2claude   - Run Claude with account switching"
    echo
    echo -e "${BLUE}Quick Start:${NC}"
    echo "  1. Add your first account:"
    echo "     $ c2switcher add"
    echo
    echo "  2. Check usage across accounts:"
    echo "     $ c2switcher usage"
    echo
    echo "  3. Run Claude with optimal account:"
    echo "     $ c2claude"
    echo
fi

if [[ "$INSTALL_APPLET" == true ]]; then
    echo -e "${BLUE}Cinnamon Applet:${NC}"
    echo "  1. Right-click your panel → 'Applets'"
    echo "  2. Find 'Claude Code Usage' and enable it"
    echo "  3. The applet shows average Sonnet usage on the panel"
    echo "  4. Click it for detailed usage and account switching"
    echo
fi

if [[ "$INSTALL_STATUSLINE" == true ]]; then
    echo -e "${BLUE}Claude Code Status Line:${NC}"
    echo "  Active account and usage appear in the Claude Code status line:"
    echo "  [0] work  5h:42%  7d:18%"
    echo "  Usage is color-coded (green/yellow/red) and refreshes with the 5-min cache."
    echo
fi

echo -e "${CYAN}Documentation: ${NC}https://github.com/incompletebiped/c2switcher-mint"
echo