ccm

#!/usr/bin/env bash

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-${(%):-%x}}")" && pwd)"
API_KEYS_FILE="$SCRIPT_DIR/apikeys.json"

UNSET_VARS=(
    "ANTHROPIC_AUTH_TOKEN"
    "ANTHROPIC_API_KEY"
    "ANTHROPIC_BASE_URL"
    "API_TIMEOUT_MS"
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"
    "ANTHROPIC_MODEL"
    "ANTHROPIC_SMALL_FAST_MODEL"
    "ANTHROPIC_DEFAULT_HAIKU_MODEL"
    "ANTHROPIC_DEFAULT_SONNET_MODEL"
    "ANTHROPIC_DEFAULT_OPUS_MODEL"
)

load_api_key() {
    local provider="$1"
    if [ ! -f "$API_KEYS_FILE" ]; then
        echo "Error: API keys file not found: $API_KEYS_FILE" >&2
        exit 1
    fi

    local key
    key=$(node -e "
        const fs = require('fs');
        const data = JSON.parse(fs.readFileSync('$API_KEYS_FILE', 'utf8'));
        const key = data['$provider'];
        if (!key) {
            console.error('Provider not found: $provider');
            process.exit(1);
        }
        console.log(key);
    " 2>&1) || {
        echo "Error: $key" >&2
        exit 1
    }

    echo "$key"
}

clear_vars() {
    for var in "${UNSET_VARS[@]}"; do
        unset "$var" 2>/dev/null || true
    done
}

set_glm_vars() {
    export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
    export API_TIMEOUT_MS="3000000"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="glm-4.5-air"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="glm-4.7"
    export ANTHROPIC_DEFAULT_OPUS_MODEL="glm-4.7"
}

set_mmx_vars() {
    export ANTHROPIC_BASE_URL="https://api.minimax.io/anthropic"
    export API_TIMEOUT_MS="3000000"
    export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"
    export ANTHROPIC_MODEL="MiniMax-M2.1"
    export ANTHROPIC_SMALL_FAST_MODEL="MiniMax-M2.1"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="MiniMax-M2.1"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="MiniMax-M2.1"
    export ANTHROPIC_DEFAULT_OPUS_MODEL="MiniMax-M2.1"
}

set_dflt_vars() {
    export ANTHROPIC_BASE_URL="https://api.anthropic.com"
    export API_TIMEOUT_MS="3000000"
}

set_optr_vars() {
    export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
    export API_TIMEOUT_MS="3000000"
}

fetch_optr_models() {
    local api_key="$1"
    local response
    response=$(curl -s "https://openrouter.ai/api/v1/models?supported_parameters=tools" \
        -H "Authorization: Bearer $api_key") || return 1

    echo "$response" | jq -r '.data[] | "\(.canonical_slug) | \(.name)"' 2>/dev/null || return 1
}

select_optr_model() {
    local api_key="$1"
    local models
    models=$(fetch_optr_models "$api_key") || {
        echo "Error: Failed to fetch models from OpenRouter" >&2
        return 1
    }

    if [ -z "$models" ]; then
        echo "Error: No models available from OpenRouter" >&2
        return 1
    fi

    local selected

    # Use fzf if available, otherwise fall back to select
    if command -v fzf &>/dev/null; then
        selected=$(echo "$models" | fzf --prompt="Select OpenRouter model: " \
            --height=50% \
            --layout=reverse \
            --delimiter="|" \
            --nth=1,2 \
            --header="Filter models, press Enter to select, Ctrl+C to cancel" \
            --preview-window=hidden) || return 1
        [ -n "$selected" ] && echo "$selected" | cut -d'|' -f1 | xargs
    else
        # Fall back to numbered select
        echo ""
        echo "Available OpenRouter models (tool-use compatible):"
        echo "------------------------------------------------"
        
        # Create arrays for model slugs and names
        local model_slugs=()
        local model_names=()
        
        while IFS='|' read -r slug name; do
            model_slugs+=("$(echo "$slug" | xargs)")
            model_names+=("$(echo "$name" | xargs)")
        done <<< "$models"
        
        # Display numbered list
        local i=1
        for slug in "${model_slugs[@]}"; do
            local name="${model_names[$((i-1))]}"
            printf "%3d) %s (%s)\n" "$i" "$name" "$slug"
            ((i++))
        done
        
        echo ""
        echo "------------------------------------------------"
        
        # Select model
        local choice
        while true; do
            read -p "Select model number (1-${#model_slugs[@]}): " choice
            if [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -ge 1 ] && [ "$choice" -le "${#model_slugs[@]}" ]; then
                selected="${model_slugs[$((choice-1))]}"
                echo ""
                echo "Selected: ${model_names[$((choice-1))]} ($selected)"
                break
            else
                echo "Invalid selection. Please enter a number between 1 and ${#model_slugs[@]}"
            fi
        done
        
        echo "$selected"
    fi
}

print_vars() {
    echo ""
    echo "Current ANTHROPIC_* variables:"
    env | grep "^ANTHROPIC_" | cut -d= -f1 | sort | sed 's/^/  /'
    echo ""
}

run_claude() {
    local flags="${1:-}"
    if command -v claude &>/dev/null; then
        if [ -n "$flags" ]; then
            # Use set -- to safely parse flags into positional parameters
            eval "set -- $flags"
            exec claude "$@"
        else
            exec claude
        fi
    else
        echo "Run 'claude' to start Claude Code."
    fi
}

provider_glm() {
    local no_run="${1:-}"
    local claude_flags="${2:-}"
    clear_vars
    local api_key
    api_key=$(load_api_key "glm")
    export ANTHROPIC_AUTH_TOKEN="$api_key"
    set_glm_vars
    echo "✓ Switched to GLM"
    print_vars
    if [ "$no_run" != "--no-run" ] && [ "$no_run" != "-nr" ]; then
        clear
        run_claude "$claude_flags"
    else
        echo "Variables set without running claude (use 'claude' to launch)"
    fi
}

provider_mmx() {
    local no_run="${1:-}"
    local claude_flags="${2:-}"
    clear_vars
    local api_key
    api_key=$(load_api_key "minimax")
    export ANTHROPIC_AUTH_TOKEN="$api_key"
    set_mmx_vars
    echo "✓ Switched to MiniMax"
    print_vars
    if [ "$no_run" != "--no-run" ] && [ "$no_run" != "-nr" ]; then
        clear
        run_claude "$claude_flags"
    else
        echo "Variables set without running claude (use 'claude' to launch)"
    fi
}

provider_dflt() {
    local no_run="${1:-}"
    local claude_flags="${2:-}"
    clear_vars
    local api_key
    api_key=$(load_api_key "anthropic")
    export ANTHROPIC_API_KEY="$api_key"
    set_dflt_vars
    echo "✓ Switched to Anthropic (default)"
    print_vars
    if [ "$no_run" != "--no-run" ] && [ "$no_run" != "-nr" ]; then
        clear
        run_claude "$claude_flags"
    else
        echo "Variables set without running claude (use 'claude' to launch)"
    fi
}

provider_optr() {
    local model_slug="${1:-}"
    local no_run="${2:-}"
    local claude_flags="${3:-}"

    clear_vars
    local api_key
    api_key=$(load_api_key "openrouter")
    export ANTHROPIC_AUTH_TOKEN="$api_key"
    export ANTHROPIC_API_KEY=""

    local selected_model
    if [ -n "$model_slug" ]; then
        selected_model="$model_slug"
    else
        selected_model=$(select_optr_model "$api_key") || return 1
    fi

    export ANTHROPIC_DEFAULT_SONNET_MODEL="$selected_model"
    set_optr_vars
    echo "✓ Switched to OpenRouter (model: $selected_model)"
    print_vars

    if [ "$no_run" != "--no-run" ] && [ "$no_run" != "-nr" ]; then
        clear
        run_claude "$claude_flags"
    else
        echo "Variables set without running claude (use 'claude' to launch)"
    fi
}

provider_clr() {
    clear_vars
    echo "✓ Cleared all provider variables"
}

provider_chk() {
    # Check if ANTHROPIC_BASE_URL is set
    if [ -z "${ANTHROPIC_BASE_URL:-}" ]; then
        echo "No provider active"
        return
    fi

    # Detect provider based on BASE_URL
    case "$ANTHROPIC_BASE_URL" in
        "https://api.anthropic.com")
            echo "Active Provider: Anthropic (default)"
            ;;
        "https://api.z.ai/api/anthropic")
            echo "Active Provider: GLM (Z.ai)"
            ;;
        "https://api.minimax.io/anthropic")
            echo "Active Provider: MiniMax"
            ;;
        "https://openrouter.ai/api")
            echo "Active Provider: OpenRouter"
            ;;
        *)
            echo "Active Provider: Unknown (custom BASE_URL)"
            ;;
    esac

    # Show relevant environment variables
    print_vars
}

usage() {
    echo "Usage: cc <command> [options] [claude-flags]"
    echo ""
    echo "Commands:"
    echo "  dflt    - Switch to Anthropic (default) provider"
    echo "  glm     - Switch to GLM provider"
    echo "  mmx     - Switch to MiniMax provider"
    echo "  optr    - Switch to OpenRouter provider (interactive model selection)"
    echo "  clr     - Clear all provider variables"
    echo "  chk     - Check current provider status"
    echo ""
    echo "Options:"
    echo "  -nr, --no-run - Don't launch claude after switching"
    echo "  -m, --model <slug> - Select specific model (for optr command)"
    echo ""
    echo "Claude Flags (passed to claude command):"
    echo "  -c, --continue      Continue the most recent conversation"
    echo "  -r, --resume [val]  Resume a conversation by session ID"
    echo ""
    echo "Examples:"
    echo "  cc dflt              # Switch to Anthropic and run claude"
    echo "  cc dflt -c           # Switch to Anthropic, run with --continue"
    echo "  cc glm -r session-123 # Switch to GLM, resume specific session"
    echo "  cc dflt --no-run     # Switch to Anthropic without running"
    echo "  cc mmx               # Switch to MiniMax and run claude"
    echo "  cc optr              # Switch to OpenRouter, select model interactively"
    echo "  cc optr -m anthropic/claude-3.5-sonnet  # Switch to OpenRouter with specific model"
    echo "  cc optr -m anthropic/claude-3.5-sonnet --no-run  # Select without launching"
    echo "  cc clr               # Clear all ANTHROPIC_* variables"
    echo "  cc chk               # Check current provider status"
}

main() {
    if [ $# -eq 0 ]; then
        usage
        exit 0
    fi

    local cmd="$1"
    shift
    local no_run=""
    local claude_flags=""
    local model_slug=""

    # Parse arguments
    while [[ $# -gt 0 ]]; do
        case "$1" in
            -nr|--no-run)
                no_run="$1"
                shift
                break  # Stop parsing, ignore everything after --no-run
                ;;
            -m|--model)
                shift
                if [[ $# -gt 0 ]]; then
                    model_slug="$1"
                    shift
                else
                    echo "Error: --model flag requires a value" >&2
                    usage >&2
                    exit 1
                fi
                ;;
            -c|--continue|-r|--resume)
                claude_flags="$claude_flags $1"
                shift
                # Handle -r and --resume with optional value
                if [[ $# -gt 0 && "$1" != -* ]]; then
                    claude_flags="$claude_flags $1"
                    shift
                fi
                ;;
            *)
                claude_flags="$claude_flags $1"
                shift
                ;;
        esac
    done

    claude_flags="${claude_flags#"${claude_flags%%[![:space:]]*}"}"  # Trim leading space

    case "$cmd" in
        glm|mmx|clr|dflt|chk)
            "provider_$cmd" "$no_run" "$claude_flags"
            ;;
        optr)
            "provider_optr" "$model_slug" "$no_run" "$claude_flags"
            ;;
        -h|--help|help)
            usage
            ;;
        *)
            echo "Unknown command: $cmd" >&2
            usage >&2
            exit 1
            ;;
    esac
}

# Only run main if script is executed directly (not sourced)
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi