cli.py

#!/usr/bin/env python3
"""
Balboa Spa CLI - Command-line interface for controlling your spa.

Usage:
    python cli.py status
    python cli.py set-temp 102
    python cli.py pump 0 toggle
    python cli.py light toggle
"""

import asyncio
import os
import sys

import click
from dotenv import load_dotenv
from rich.console import Console
from rich.table import Table
from rich.panel import Panel

from spa_control import BalboaSpa

# Load environment variables
load_dotenv()

console = Console()


def get_spa_host() -> str:
    """Get spa host from environment or fail."""
    host = os.getenv("SPA_HOST")
    if not host:
        console.print(
            "[red]Error:[/red] SPA_HOST not set. "
            "Set it in .env file or as environment variable."
        )
        sys.exit(1)
    return host


async def async_status(host: str):
    """Get and display spa status."""
    async with BalboaSpa(host) as spa:
        status = await spa.get_status()
        return status


async def async_set_temp(host: str, temp: float):
    """Set spa temperature."""
    async with BalboaSpa(host) as spa:
        await spa.set_temperature(temp)
        return await spa.get_status()


async def async_toggle_pump(host: str, pump_index: int):
    """Toggle pump."""
    async with BalboaSpa(host) as spa:
        await spa.toggle_pump(pump_index)
        return await spa.get_status()


async def async_set_pump(host: str, pump_index: int, state: int):
    """Set pump state."""
    async with BalboaSpa(host) as spa:
        await spa.set_pump(pump_index, state)
        return await spa.get_status()


async def async_toggle_light(host: str, light_index: int):
    """Toggle light."""
    async with BalboaSpa(host) as spa:
        await spa.toggle_light(light_index)
        return await spa.get_status()


async def async_toggle_blower(host: str):
    """Toggle blower."""
    async with BalboaSpa(host) as spa:
        await spa.toggle_blower()
        return await spa.get_status()


async def async_set_heat_mode(host: str, mode: str):
    """Set heat mode."""
    async with BalboaSpa(host) as spa:
        await spa.set_heat_mode(mode)
        return await spa.get_status()


async def async_set_temp_range(host: str, temp_range: str):
    """Set temperature range."""
    async with BalboaSpa(host) as spa:
        await spa.set_temp_range(temp_range)
        return await spa.get_status()


def display_status(status):
    """Display spa status in a nice table format."""
    # Main status panel
    temp_display = f"{status.current_temp}°{status.temp_unit}" if status.current_temp else "---"
    target_display = f"{status.target_temp}°{status.temp_unit}"
    
    heating_indicator = "🔥 " if status.heating else ""
    
    main_info = f"""
[bold]Temperature:[/bold] {temp_display} → {target_display} {heating_indicator}
[bold]Heat Mode:[/bold] {status.heat_mode}
[bold]Temp Range:[/bold] {status.temp_range}
[bold]Heat State:[/bold] {status.heat_state}
[bold]Connected:[/bold] {"✓ Yes" if status.connected else "✗ No"}
"""
    
    console.print(Panel(main_info.strip(), title="🛁 Spa Status", border_style="blue"))
    
    # Pumps table
    if status.pumps:
        pump_table = Table(title="Pumps")
        pump_table.add_column("Name", style="cyan")
        pump_table.add_column("State", style="green")
        pump_table.add_column("Speeds", style="yellow")
        
        for pump in status.pumps:
            state_names = ["Off", "Low", "High"]
            state_str = state_names[pump["state"]] if pump["state"] < len(state_names) else str(pump["state"])
            pump_table.add_row(
                pump["name"],
                state_str,
                str(pump["speeds"])
            )
        
        console.print(pump_table)
    
    # Lights table
    if status.lights:
        light_table = Table(title="Lights")
        light_table.add_column("Name", style="cyan")
        light_table.add_column("State", style="green")
        
        for light in status.lights:
            light_table.add_row(
                light["name"],
                "💡 On" if light["on"] else "Off"
            )
        
        console.print(light_table)
    
    # Blower
    if status.blower:
        state_names = ["Off", "Low", "Medium", "High"]
        blower_state = status.blower["state"]
        state_str = state_names[blower_state] if blower_state < len(state_names) else str(blower_state)
        console.print(f"[bold]Blower:[/bold] {state_str}")
    
    # Circ pump
    if status.circ_pump:
        console.print(f"[bold]Circulation Pump:[/bold] {'Running' if status.circ_pump['running'] else 'Off'}")


@click.group()
@click.option("--host", envvar="SPA_HOST", help="Spa IP address (or set SPA_HOST env var)")
@click.pass_context
def cli(ctx, host):
    """Balboa Spa Control CLI - Control your hot tub from the command line."""
    ctx.ensure_object(dict)
    ctx.obj["host"] = host or get_spa_host()


@cli.command()
@click.pass_context
def status(ctx):
    """Get current spa status."""
    host = ctx.obj["host"]
    console.print(f"[dim]Connecting to spa at {host}...[/dim]")
    
    try:
        spa_status = asyncio.run(async_status(host))
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command("set-temp")
@click.argument("temperature", type=float)
@click.pass_context
def set_temp(ctx, temperature):
    """Set target temperature."""
    host = ctx.obj["host"]
    console.print(f"[dim]Setting temperature to {temperature}...[/dim]")
    
    try:
        spa_status = asyncio.run(async_set_temp(host, temperature))
        console.print(f"[green]✓[/green] Temperature set to {temperature}")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command()
@click.argument("pump_index", type=int)
@click.argument("action", type=click.Choice(["toggle", "off", "low", "high"]))
@click.pass_context
def pump(ctx, pump_index, action):
    """Control pumps. PUMP_INDEX is 0-based (0 = Pump 1)."""
    host = ctx.obj["host"]
    console.print(f"[dim]Controlling pump {pump_index + 1}...[/dim]")
    
    try:
        if action == "toggle":
            spa_status = asyncio.run(async_toggle_pump(host, pump_index))
        else:
            state_map = {"off": 0, "low": 1, "high": 2}
            spa_status = asyncio.run(async_set_pump(host, pump_index, state_map[action]))
        
        console.print(f"[green]✓[/green] Pump {pump_index + 1} {action}")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command()
@click.option("--index", "-i", default=0, help="Light index (0-based)")
@click.pass_context
def light(ctx, index):
    """Toggle lights."""
    host = ctx.obj["host"]
    console.print(f"[dim]Toggling light {index + 1}...[/dim]")
    
    try:
        spa_status = asyncio.run(async_toggle_light(host, index))
        console.print(f"[green]✓[/green] Light {index + 1} toggled")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command()
@click.pass_context
def blower(ctx):
    """Toggle blower."""
    host = ctx.obj["host"]
    console.print("[dim]Toggling blower...[/dim]")
    
    try:
        spa_status = asyncio.run(async_toggle_blower(host))
        console.print("[green]✓[/green] Blower toggled")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command("heat-mode")
@click.argument("mode", type=click.Choice(["ready", "rest"]))
@click.pass_context
def heat_mode(ctx, mode):
    """Set heat mode (ready or rest)."""
    host = ctx.obj["host"]
    console.print(f"[dim]Setting heat mode to {mode}...[/dim]")
    
    try:
        spa_status = asyncio.run(async_set_heat_mode(host, mode))
        console.print(f"[green]✓[/green] Heat mode set to {mode}")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


@cli.command("temp-range")
@click.argument("range_setting", type=click.Choice(["high", "low"]))
@click.pass_context
def temp_range(ctx, range_setting):
    """Set temperature range (high or low)."""
    host = ctx.obj["host"]
    console.print(f"[dim]Setting temp range to {range_setting}...[/dim]")
    
    try:
        spa_status = asyncio.run(async_set_temp_range(host, range_setting))
        console.print(f"[green]✓[/green] Temp range set to {range_setting}")
        display_status(spa_status)
    except Exception as e:
        console.print(f"[red]Error:[/red] {e}")
        sys.exit(1)


if __name__ == "__main__":
    cli()