#!/usr/bin/env python3
"""
band-provider — BAND Provider Switch Tool
Toggle Claude Code endpoint between providers (manual or auto BAND tier mode).

Protocol: just 2 env vars in ~/.claude/settings.json
  ANTHROPIC_BASE_URL   → endpoint
  ANTHROPIC_API_KEY    → key (for OpenClaude, LiteLLM)
  ANTHROPIC_AUTH_TOKEN → key (for Claudible)

Usage:
  band-provider status                 # Show current provider + mode
  band-provider list                   # List all providers
  band-provider use <provider>         # Switch to provider (manual mode)
  band-provider off                    # Back to native Anthropic
  band-provider auto                   # Enable auto mode (BAND tier based)
  band-provider manual                 # Disable auto mode
  band-provider tier <T0|T1|T2|T3|T4> # Force specific tier (manual override)
  band-provider add <name> <url> <key> # Add new provider
"""

import json
import os
import sys
import shutil
from pathlib import Path
from datetime import datetime

# Paths
CLAUDE_DIR = Path.home() / ".claude"
SETTINGS = CLAUDE_DIR / "settings.json"
REGISTRY = CLAUDE_DIR / "providers.json"

# ANSI colors
R = "\033[0;31m"; G = "\033[0;32m"; Y = "\033[1;33m"
B = "\033[0;34m"; C = "\033[0;36m"; W = "\033[1;37m"; N = "\033[0m"

BAND_TIERS = {
    "T0": {"label": "T0 — Local micro (phi3/gemma2)",     "default": "local"},
    "T1": {"label": "T1 — Local standard (llama3.1/qwen)", "default": "local"},
    "T2": {"label": "T2 — Free cloud (Groq/Cerebras)",    "default": "local"},
    "T3": {"label": "T3 — Premium free (Gemini Pro)",     "default": "local"},
    "T4": {"label": "T4 — Premium paid (Claude Sonnet)",  "default": "claudible"},
}

def load_registry():
    if not REGISTRY.exists():
        print(f"{R}Error: {REGISTRY} not found.{N}")
        sys.exit(1)
    with open(REGISTRY) as f:
        return json.load(f)

def save_registry(reg):
    with open(REGISTRY, "w") as f:
        json.dump(reg, f, indent=2)

def load_settings():
    if not SETTINGS.exists():
        return {}
    with open(SETTINGS) as f:
        try:
            return json.load(f)
        except:
            return {}

def save_settings(s):
    CLAUDE_DIR.mkdir(exist_ok=True)
    # Backup
    if SETTINGS.exists():
        shutil.copy(SETTINGS, SETTINGS.with_suffix(".json.bak"))
    with open(SETTINGS, "w") as f:
        json.dump(s, f, indent=2)

def apply_provider(name, reg):
    """Write provider credentials into ~/.claude/settings.json"""
    providers = reg.get("providers", {})
    if name not in providers and name != "native":
        print(f"{R}Unknown provider: {name}{N}")
        print(f"Available: {', '.join(providers.keys())}")
        sys.exit(1)

    p = providers.get(name, {}) if name != "native" else {}
    s = load_settings()
    s.setdefault("env", {})

    # Clear all provider env vars first
    for k in ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN",
              "ANTHROPIC_DEFAULT_HAIKU_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL",
              "ANTHROPIC_DEFAULT_OPUS_MODEL"]:
        s["env"].pop(k, None)

    # Apply new provider
    if name == "native" or not p.get("base_url"):
        # Native: just remove custom settings, Claude Code uses default
        pass
    else:
        s["env"]["ANTHROPIC_BASE_URL"] = p["base_url"]
        if p.get("auth_token"):
            s["env"]["ANTHROPIC_AUTH_TOKEN"] = p["auth_token"]
        elif p.get("api_key"):
            s["env"]["ANTHROPIC_API_KEY"] = p["api_key"]

    # Preserve other settings (permissions, etc.)
    save_settings(s)

    # Update registry state
    reg["active"] = name
    save_registry(reg)

def cmd_status(reg):
    active = reg.get("active", "native")
    mode   = reg.get("mode", "manual")
    p      = reg["providers"].get(active, {})

    print(f"\n{W}BAND Provider Status{N}")
    print(f"  Mode:     {C}{'AUTO' if mode == 'auto' else 'MANUAL'}{N}")
    print(f"  Active:   {G}{p.get('label', active)}{N}")
    if p.get("base_url"):
        print(f"  Endpoint: {B}{p['base_url']}{N}")
    else:
        print(f"  Endpoint: {B}(Anthropic default){N}")
    if mode == "auto":
        tm = reg.get("band_tier_auto", {})
        print(f"\n  BAND Tier → Provider map:")
        for tier, prov in tm.items():
            if tier.startswith("_"):
                continue
            tp = reg["providers"].get(prov, {})
            print(f"    {Y}{tier}{N} → {tp.get('label', prov)}")
    print()

def cmd_list(reg):
    active = reg.get("active", "native")
    print(f"\n{W}BAND Providers{N}")
    for name, p in reg["providers"].items():
        indicator = f"{G}● ON {N}" if name == active else f"  OFF"
        print(f"  {indicator}  {W}{name:<12}{N} {p.get('label','')}")
        if p.get("base_url"):
            print(f"              {B}{p['base_url']}{N}")
        print(f"              {p.get('description','')}")
        print()

def cmd_use(reg, name):
    apply_provider(name, reg)
    p = reg["providers"].get(name, {})
    reg["mode"] = "manual"
    save_registry(reg)
    print(f"{G}✓ Switched to: {p.get('label', name)}{N}")
    if p.get("base_url"):
        print(f"  Endpoint: {B}{p['base_url']}{N}")
    print(f"  {Y}Restart claude for changes to take effect.{N}")

def cmd_off(reg):
    apply_provider("native", reg)
    reg["mode"] = "manual"
    save_registry(reg)
    print(f"{G}✓ Switched to native Anthropic (default){N}")
    print(f"  {Y}Restart claude for changes to take effect.{N}")

def cmd_auto(reg):
    reg["mode"] = "auto"
    save_registry(reg)
    print(f"{G}✓ Auto mode enabled{N}")
    print(f"  Tier routing:")
    tm = reg.get("band_tier_auto", {})
    for tier, prov in tm.items():
        if tier.startswith("_"):
            continue
        tp = reg["providers"].get(prov, {})
        info = BAND_TIERS.get(tier, {})
        print(f"    {Y}{tier}{N}  {info.get('label',''):<40} → {G}{tp.get('label', prov)}{N}")
    print()
    # Apply current default (T1/T2 = local)
    default_prov = tm.get("T2", "local")
    apply_provider(default_prov, reg)
    print(f"  Applied default provider: {G}{default_prov}{N}")

def cmd_manual(reg):
    reg["mode"] = "manual"
    save_registry(reg)
    print(f"{G}✓ Manual mode enabled{N}")
    print(f"  Use: band-provider use <provider>")

def cmd_tier(reg, tier):
    tier = tier.upper()
    if tier not in BAND_TIERS:
        print(f"{R}Unknown tier: {tier}. Valid: T0 T1 T2 T3 T4{N}")
        sys.exit(1)
    tm = reg.get("band_tier_auto", {})
    prov = tm.get(tier, "local")
    apply_provider(prov, reg)
    p = reg["providers"].get(prov, {})
    print(f"{G}✓ Tier {tier} → {p.get('label', prov)}{N}")
    print(f"  {Y}Restart claude for changes to take effect.{N}")

def cmd_add(reg, name, url, key):
    reg["providers"][name] = {
        "label": name,
        "base_url": url,
        "api_key": key if not key.startswith("sk-") else None,
        "auth_token": key if key.startswith("sk-") else None,
        "description": f"Added {datetime.now().strftime('%Y-%m-%d')}"
    }
    save_registry(reg)
    print(f"{G}✓ Provider '{name}' added{N}")
    print(f"  Use: band-provider use {name}")

def cmd_help():
    print(f"""
{W}band-provider{N} — BAND Provider Switch

{Y}Commands:{N}
  {G}band-provider status{N}                 Show current provider + mode
  {G}band-provider list{N}                   List all providers (ON/OFF)
  {G}band-provider use{N} <provider>         Switch provider (manual mode)
  {G}band-provider off{N}                    Back to native Anthropic
  {G}band-provider auto{N}                   Enable auto mode (BAND tier)
  {G}band-provider manual{N}                 Disable auto mode
  {G}band-provider tier{N} <T0-T4>           Force tier for this session
  {G}band-provider add{N} <n> <url> <key>    Register new provider

{Y}Providers:{N}
  native          Direct Anthropic API (default, login/subscription)
  native-anthropic  Direct Anthropic API (API key mode)
  claudible       Claudible.io — Claude proxy
  openclaude      OpenClaude.com — Claude proxy
  local           LiteLLM local — all BAND members, soul.md enforced

{Y}Auto mode — BAND tier routing:{N}
  T0/T1/T2/T3  → local  (free: Groq/Cerebras/HF Spaces)
  T4           → claudible (paid-quality, alternative billing)

{Y}Protocol:{N}
  All switching = 2 env vars in ~/.claude/settings.json
    ANTHROPIC_BASE_URL   → endpoint URL
    ANTHROPIC_API_KEY    → API key (LiteLLM/OpenClaude/native-anthropic)
    ANTHROPIC_AUTH_TOKEN → auth token (Claudible)
""")

def main():
    args = sys.argv[1:]
    reg  = load_registry()

    if not args or args[0] in ("-h", "--help", "help"):
        cmd_help()
    elif args[0] == "status":
        cmd_status(reg)
    elif args[0] == "list":
        cmd_list(reg)
    elif args[0] == "use" and len(args) >= 2:
        cmd_use(reg, args[1])
    elif args[0] == "off":
        cmd_off(reg)
    elif args[0] == "auto":
        cmd_auto(reg)
    elif args[0] == "manual":
        cmd_manual(reg)
    elif args[0] == "tier" and len(args) >= 2:
        cmd_tier(reg, args[1])
    elif args[0] == "add" and len(args) >= 4:
        cmd_add(reg, args[1], args[2], args[3])
    else:
        print(f"{R}Unknown command: {' '.join(args)}{N}")
        cmd_help()
        sys.exit(1)

if __name__ == "__main__":
    main()