"""UX-13 P1: serve the real page and routes over a fixture controller, for a
headless browser check.  `python3 tools/ux13_demo.py STATE PORT`

STATE is running, shadow or alarm. The controller is the shipped `Controller`
with its readings set by hand (two batteries, solar, today's prices in the
mockup's shape, trading on). Nothing here talks to Home Assistant or to an
inverter: `/action` changes only this fixture. Used for the P1 render check
(no JS errors, tooltips, phone width, dark mode) described in the PR.
"""

import asyncio
import os
import sys
from datetime import datetime, timedelta, timezone

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from aiohttp import web as aioweb                                # noqa: E402

from app import homeview, web                                    # noqa: E402
from app.main import Controller                                  # noqa: E402
from app.peakguard import PeakDecision                           # noqa: E402
from app.price import PricePoint, PriceProduct, PriceRead        # noqa: E402
from app.static_tariff import TariffPlan                         # noqa: E402

PRICES = [.24, .22, .21, .20, .21, .22, .24, .27, .26, .22, .18, .16, .15,
          .14, .16, .19, .23, .28, .33, .36, .34, .29, .26, .24]


class Store(dict):
    def set(self, k, v):
        self[k] = v

    def set_time(self, k, v):
        self[k] = v.isoformat()

    def get_time(self, k):
        v = self.get(k)
        return None if v is None else datetime.fromisoformat(v)

    @property
    def data(self):
        return self


class Pub:
    enabled = False

    def publish(self, _v):
        pass

    def close(self):
        pass


class Hass:
    session = None
    token = ""

    async def limits(self, _e):
        return (-5000.0, 5000.0, 1.0)

    async def number(self, _e, invert=False):
        return None

    async def state(self, _e):
        return None

    async def set_number(self, _e, _v):
        return True

    async def call(self, *_a):
        return True

    async def states(self):
        return []


class Supervisor:
    async def info(self):
        return {"options": {}, "schema": [], "translations": {}}


OPTS = {"meter_entity": "sensor.grid", "meter_source": "off",
        "pv_entity": "sensor.pv", "maintenance_enabled": True,
        "maintenance_start_hour": 18, "arbitrage_enabled": True,
        "cycle_cost_threshold_eur": 0.05,
        "inverters": [
            {"name": "Battery A", "setpoint_entity": "number.a",
             "soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
             "max_w": 2500, "capacity_kwh": 9.6},
            {"name": "Battery B", "setpoint_entity": "number.b",
             "soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
             "max_w": 2500, "capacity_kwh": 5.4}]}


def controller(state):
    opts = dict(OPTS, shadow_mode="on" if state == "shadow" else "off")
    c = Controller(opts, Hass(), Store(), Pub(), stop=asyncio.Event())
    c.auto = True
    now = datetime.now(timezone.utc)
    day0, _day1 = homeview.local_day(now)
    pts = tuple(PricePoint(day0 + timedelta(days=d, hours=k), p, False)
                for d in range(2) for k, p in enumerate(PRICES))
    c.tariff_plan = TariffPlan(PriceRead.series(
        pts, PriceProduct.DAY_AHEAD, "generic_dayahead", now), None,
        "provider")
    c.tariff_at = now
    c.peak_guard = PeakDecision(engaged=False, floor_w=None,
                                ceiling_w=3500.0, ceiling_from="cap",
                                projected_w=1240.0)
    for inv, soc, batt in zip(c.inverters, (62.0, 35.0), (-2500.0, -300.0)):
        inv.soc, inv.batt = soc, (0.0 if state == "shadow" else batt)
        inv.dev_min, inv.dev_max = -5000.0, 5000.0
    c.grid = -10.0 if state != "shadow" else -2810.0
    c.pv_w = 3900.0
    if state == "alarm":
        c.inverters[0].sign_wd.tripped = True
    return c


async def main(state, port):
    runner = aioweb.AppRunner(web.build_app(controller(state), Supervisor()))
    await runner.setup()
    await aioweb.TCPSite(runner, "127.0.0.1", port).start()
    print(f"serving {state} on http://127.0.0.1:{port}/", flush=True)
    await asyncio.Event().wait()


if __name__ == "__main__":
    asyncio.run(main(sys.argv[1], int(sys.argv[2])))