import asyncio
from pylxpweb import LuxpowerClient
from pylxpweb.devices.station import Station

async def main():
    # Create client with credentials
    # Default base_url is https://monitor.eg4electronics.com
    async with LuxpowerClient(
        username="your_username",
        password="your_password",
        base_url="https://monitor.eg4electronics.com"  # or us.luxpowertek.com, eu.luxpowertek.com
    ) as client:
        # Load all stations with device hierarchy
        stations = await Station.load_all(client)
        print(f"Found {len(stations)} stations")

        # Work with first station
        station = stations[0]
        print(f"\nStation: {station.name}")

        # Access inverters - all have properly-scaled properties
        for inverter in station.all_inverters:
            await inverter.refresh()  # Fetch latest data

            print(f"\n{inverter.model} {inverter.serial_number}:")

            # All properties return properly-scaled values
            print(f"  PV Power: {inverter.pv_total_power}W")
            print(f"  Battery: {inverter.battery_soc}% @ {inverter.battery_voltage}V")
            print(f"  Grid: {inverter.grid_voltage_r}V @ {inverter.grid_frequency}Hz")
            print(f"  Inverter Power: {inverter.inverter_power}W")
            print(f"  To Grid: {inverter.power_to_grid}W")
            print(f"  To User: {inverter.power_to_user}W")
            print(f"  Temperature: {inverter.inverter_temperature}°C")
            print(f"  Today: {inverter.total_energy_today}kWh")
            print(f"  Lifetime: {inverter.total_energy_lifetime}kWh")

            # Access battery bank if available
            if inverter.battery_bank:
                bank = inverter.battery_bank
                print(f"\n  Battery Bank:")
                print(f"    Voltage: {bank.voltage}V")
                print(f"    SOC: {bank.soc}%")
                print(f"    Charge Power: {bank.charge_power}W")
                print(f"    Discharge Power: {bank.discharge_power}W")
                print(f"    Capacity: {bank.current_capacity}/{bank.max_capacity} Ah")

                # Individual battery modules
                for battery in bank.batteries:
                    print(f"    Battery {battery.battery_index + 1}:")
                    print(f"      Voltage: {battery.voltage}V")
                    print(f"      Current: {battery.current}A")
                    print(f"      SOC: {battery.soc}%")
                    print(f"      Temp: {battery.max_cell_temp}°C")

        # Access GridBOSS (MID) devices if present
        for group in station.parallel_groups:
            if group.mid_device:
                mid = group.mid_device
                await mid.refresh()

                print(f"\nGridBOSS {mid.serial_number}:")
                print(f"  Grid: {mid.grid_voltage}V @ {mid.grid_frequency}Hz")
                print(f"  Grid Power: {mid.grid_power}W")
                print(f"  UPS Power: {mid.ups_power}W")
                print(f"  Load L1: {mid.load_l1_power}W @ {mid.load_l1_current}A")
                print(f"  Load L2: {mid.load_l2_power}W @ {mid.load_l2_current}A")

asyncio.run(main())

async with LuxpowerClient(username, password) as client:
    # Get stations
    plants = await client.api.plants.get_plants()
    plant_id = plants.rows[0].plantId

    # Get devices
    devices = await client.api.devices.get_devices(str(plant_id))

    # Get runtime data for first inverter
    inverter = devices.rows[0]
    serial = inverter.serialNum

    # Fetch data (returns Pydantic models)
    runtime = await client.api.devices.get_inverter_runtime(serial)
    energy = await client.api.devices.get_inverter_energy(serial)

    # NOTE: Raw API returns scaled integers - you must scale manually
    print(f"AC Power: {runtime.pac}W")  # No scaling needed for power
    print(f"Grid Voltage: {runtime.vacr / 10}V")  # Must divide by 10
    print(f"Grid Frequency: {runtime.fac / 100}Hz")  # Must divide by 100
    print(f"Battery Voltage: {runtime.vBat / 10}V")  # Must divide by 10

from aiohttp import ClientSession

async with ClientSession() as session:
    # Choose the appropriate regional endpoint
    # US (Luxpower): https://us.luxpowertek.com
    # EU (Luxpower): https://eu.luxpowertek.com
    # US (EG4): https://monitor.eg4electronics.com

    client = LuxpowerClient(
        username="user",
        password="pass",
        base_url="https://eu.luxpowertek.com",  # EU endpoint example
        verify_ssl=True,
        timeout=30,
        session=session  # Inject external session
    )

    await client.login()
    plants = await client.get_plants()
    await client.close()  # Only closes if we created the session

async with LuxpowerClient(username, password) as client:
    serial = "1234567890"

    # Enable quick charge
    await client.set_quick_charge(serial, enabled=True)

    # Set battery charge limit to 90%
    await client.set_charge_soc_limit(serial, limit=90)

    # Set operating mode to standby
    await client.set_operating_mode(serial, mode="standby")

    # Read current parameters
    params = await client.read_parameters(serial, [21, 22, 23])
    print(f"SOC Limit: {params[0]['value']}%")

from pylxpweb import (
    LuxpowerClient,
    AuthenticationError,
    ConnectionError,
    APIError
)

try:
    async with LuxpowerClient(username, password) as client:
        runtime = await client.get_inverter_runtime(serial)

except AuthenticationError as e:
    print(f"Login failed: {e}")

except ConnectionError as e:
    print(f"Network error: {e}")

except APIError as e:
    print(f"API error: {e}")

# ✅ RECOMMENDED: Use device properties (automatically scaled)
await inverter.refresh()
voltage = inverter.grid_voltage_r  # Returns 241.8 (already scaled)
frequency = inverter.grid_frequency  # Returns 59.98 (already scaled)
power = inverter.pv_total_power  # Returns 1500 (already scaled)