"""UX-54: the Forecast tab on the two clock-change days.
`python3 test_ux54_dst.py`

The tab walks local hours (`dayplan._hour_slices()` in `dayview` and
`daycurve`, `SolarToday`'s hour keys). On the spring change a loop that steps
on the wall clock never ends (SAFETY-123), and a tab request runs on the
event loop control runs on. Graded here, every call under a hard time limit
that the add-on's own `except Exception` cannot swallow (`Hang` is a
`BaseException`), and a memory limit:

1. The limit itself: a tab build that never returns is stopped and reported,
   through `forecast_payload()`'s `except Exception`.
2. `Controller.forecast_payload()` at every quarter of 27-29 March 2027 and
   30 October-1 November 2027, modes on (Leftover solar and Cheap hours,
   with a forecast and a house profile: the level curve) and modes off, in
   the no-tzdata zone (`tariff._EUTimezone`) and, where the host has tzdata,
   in ZoneInfo Europe/Brussels: it returns, `ok`, each day has 23 / 24 / 25
   hours with the local hour labels of that day, every level inside floor
   and ceiling, every block inside its day.
3. `SolarToday` keeps the two 02:00 hours of the autumn change apart.

Mutating what this file grades? Read MUTATION.md first (stale bytecode).
"""

import logging
import os
import resource
import signal
import sys
from datetime import datetime, timedelta, timezone

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)

import ux54_scenarios as S                                        # noqa: E402
import app.main as M                                              # noqa: E402
from app import arbitrage, dayplan, dayview, homeview, solarfc    # noqa: E402
from app import tariff                                            # noqa: E402
from app.daycurve import SolarToday                               # noqa: E402

UTC = timezone.utc
fails = []
LIMIT_S = 10.0          # one call; a build takes well under a second
try:                    # a loop that appends without end must not take the host
    resource.setrlimit(resource.RLIMIT_AS, (3 << 29, resource.getrlimit(
        resource.RLIMIT_AS)[1]))
except (ValueError, OSError):
    pass


def check(name, cond):
    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
    if not cond:
        fails.append(name)


class Hang(BaseException):
    """A call ran over LIMIT_S. Not an `Exception`: `forecast_payload()`
    catches every `Exception` and would turn it into `{"ok": False}`."""


def _alarm(*_a):
    raise Hang()


def limited(fn, *a, **k):
    """`fn(*a, **k)`, or `Hang` when it takes more than LIMIT_S seconds or
    runs out of memory."""
    signal.signal(signal.SIGALRM, _alarm)
    signal.setitimer(signal.ITIMER_REAL, LIMIT_S)
    try:
        return fn(*a, **k)
    except MemoryError:
        raise Hang() from None
    finally:
        signal.setitimer(signal.ITIMER_REAL, 0)


# --------------------------------------------------------------------------- #
# The clock and the zone
# --------------------------------------------------------------------------- #
NOW = [datetime(2027, 1, 1, tzinfo=UTC)]


class FakeDT(datetime):
    @classmethod
    def now(cls, tz=None):
        return NOW[0].astimezone(tz) if tz else NOW[0].replace(tzinfo=None)


for _mod in (M, homeview, dayview):         # what reads the wall clock
    _mod.datetime = FakeDT

TZ_MODULES = (tariff, dayplan, homeview, solarfc)


class zone:
    """`BILLING_TZ` is `tz` in every module that holds it, in the block."""

    def __init__(self, tz):
        self.tz = tz

    def __enter__(self):
        self.was = [m.BILLING_TZ for m in TZ_MODULES]
        for m in TZ_MODULES:
            m.BILLING_TZ = self.tz

    def __exit__(self, *_a):
        for m, tz in zip(TZ_MODULES, self.was):
            m.BILLING_TZ = tz


ZONES = [("no tzdata (_EUTimezone)", tariff._EUTimezone())]
try:
    from zoneinfo import ZoneInfo
    _bru = ZoneInfo("Europe/Brussels")
    if datetime(2026, 7, 1, tzinfo=UTC).astimezone(_bru).hour == 2:
        ZONES.append(("ZoneInfo Europe/Brussels", _bru))
except Exception:                                   # noqa: BLE001
    pass
if len(ZONES) == 1:
    print("    no tzdata on this host: ZoneInfo is not graded here")

# The local days (UTC midnight-to-midnight instants are not used: the days
# are known by their dates) and their hour labels.
SPRING, AUTUMN = (2027, 3, 28), (2027, 10, 31)
WINDOWS = (((2027, 3, 27), SPRING, (2027, 3, 29)),
           ((2027, 10, 30), AUTUMN, (2027, 11, 1)))


def labels_of(ymd):
    if ymd == SPRING:
        return ["00:00", "01:00"] + [f"{h:02d}:00" for h in range(3, 24)]
    if ymd == AUTUMN:
        return ["00:00", "01:00", "02:00", "02:00"] + [
            f"{h:02d}:00" for h in range(3, 24)]
    return [f"{h:02d}:00" for h in range(24)]


def next_ymd(ymd):
    d = datetime(*ymd) + timedelta(days=1)
    return (d.year, d.month, d.day)


def day_start_utc(ymd):
    """Local midnight of `ymd` in UTC (CET before the change, CEST after it;
    midnight is never inside a change)."""
    summer = (2027, 3, 28) < ymd < (2027, 10, 31) or ymd == (2027, 10, 31)
    if ymd == SPRING:
        summer = False
    return datetime(*ymd, tzinfo=UTC) - timedelta(hours=2 if summer else 1)


# --------------------------------------------------------------------------- #
print("1. the time limit cannot be swallowed")
# --------------------------------------------------------------------------- #
check("`Hang` is a BaseException and not an Exception",
      issubclass(Hang, BaseException) and not issubclass(Hang, Exception))
c0 = limited(S.make, "off",
             datetime(2027, 1, 12, 11, 0, 5, tzinfo=UTC))
_real_build = dayview.build


def _spin(*_a, **_k):
    while True:
        pass


dayview.build = _spin
try:
    NOW[0] = datetime(2027, 1, 12, 11, 0, 5, tzinfo=UTC)
    got = limited(c0.forecast_payload, "en")
except Hang:
    got = "stopped"
finally:
    dayview.build = _real_build
check("a tab build that never returns is stopped by the limit and reported, "
      f"not turned into a page answer by forecast_payload() ({got!r})",
      got == "stopped")

# --------------------------------------------------------------------------- #
print("\n2. the tab at every quarter of the change days")
# --------------------------------------------------------------------------- #
Q = timedelta(minutes=15)
SCENARIOS = (("modes on", "dynamic", (55.0, 40.0)),
             ("modes off", "off", (55.0, 40.0)))


def wrong(out, ymd, floor_, ceil_):
    """What is wrong with one build, or None."""
    if not out.get("ok") or len(out.get("days") or []) != 2:
        return "not ok"
    for k, day in enumerate(out["days"]):
        exp = labels_of((ymd, next_ymd(ymd))[k])
        hrs = day["hours"]
        if day["length_h"] != len(exp):
            return f"day {k}: length {day['length_h']}"
        if [h["label"] for h in hrs] != exp:
            return f"day {k}: labels"
        if any(abs(h["end_h"] - h["start_h"] - 1.0) > 1e-6
               or abs(h["start_h"] - j) > 1e-6 for j, h in enumerate(hrs)):
            return f"day {k}: hour spans"
        for b in day["batteries"]:
            if any(not floor_ - 1e-6 <= v <= ceil_ + 1e-6
                   or not -1e-6 <= h <= len(exp) + 1e-6
                   for h, v in b["levels"]):
                return f"day {k}: level {b['name']}"
            if any(not 0.0 <= r["start_h"] <= r["end_h"] <= len(exp) + 1e-6
                   for r in b["blocks"]):
                return f"day {k}: block {b['name']}"
    return None


def walk(scn, soc):
    """`(builds, with a curve, stopped, wrong)` over every quarter of the
    six local days; the first call stopped by the limit ends the walk."""
    builds, curves, bad = 0, 0, []
    for window in WINDOWS:
        for ymd in window:
            a = day_start_utc(ymd)
            z = day_start_utc(next_ymd(ymd))
            t = a + timedelta(seconds=5)
            try:
                NOW[0] = t
                c = limited(S.make, scn, t, soc=soc)
                floor_, ceil_ = arbitrage.soc_bounds(c.o)
                while t < z:
                    NOW[0] = t
                    c.tariff_at = t
                    if c.modes_on:
                        limited(c._mode_roles, t, None)
                    limited(c.solar_today.add, t, 1500.0)
                    out = limited(c.forecast_payload, "en")
                    builds += 1
                    curves += any(len(b["levels"]) > 1
                                  for d in out.get("days") or []
                                  for b in d["batteries"])
                    why = wrong(out, ymd, floor_, ceil_)
                    if why:
                        bad.append((t.isoformat(), why))
                    t += Q
            except Hang:
                return builds, curves, t.isoformat(), bad
    return builds, curves, None, bad


for zname, tz in ZONES:
    with zone(tz):
        for label, scn, soc in SCENARIOS:
            builds, curves, stopped, bad = walk(scn, soc)
            print(f"    {zname}, {label}: {builds} builds ({curves} with a "
                  f"level curve), stopped at {stopped}, {len(bad)} wrong "
                  f"{bad[:3]}")
            check(f"{zname}, {label}: the tab returns at every quarter of "
                  "27-29 March and 30 October-1 November 2027 (under "
                  f"{LIMIT_S:g} s each), and each day has its 23, 24 or 25 "
                  "hours, labelled, levels inside floor and ceiling, blocks "
                  "inside the day",
                  stopped is None and not bad
                  and builds == (96 + 92 + 96) + (96 + 100 + 96)
                  and (curves == builds if scn == "dynamic" else not curves))

# --------------------------------------------------------------------------- #
print("\n3. measured solar keeps the two autumn 02:00 hours apart")
# --------------------------------------------------------------------------- #
for zname, tz in ZONES:
    with zone(tz):
        s = SolarToday()
        a = day_start_utc(AUTUMN)            # 00:00 CEST = 22:00 UTC
        t = a
        while t <= a + timedelta(hours=4):
            # 1 kW in the first 02:00 hour (00:00-01:00 UTC), 3 kW in the
            # second (01:00-02:00 UTC), nothing else
            w = 1000.0 if a + timedelta(hours=2) <= t < a + timedelta(
                hours=3) else 3000.0 if a + timedelta(hours=3) <= t < a + \
                timedelta(hours=4) else 0.0
            limited(s.add, t, w)
            t += timedelta(minutes=1)
        now = a + timedelta(hours=4, minutes=30)
        sl = [x for x in limited(dayplan._hour_slices, a, now)
              if x[2] == 2]
        got = [None if x is None else round(x, 2) for x in
               (limited(s.kwh, x[0], x[1], now) for x in sl)]
        print(f"    {zname}: the two 02:00 hours {got}")
        check(f"{zname}: two 02:00 slices, about 1 kWh and 3 kWh, each in "
              "its own hour", len(sl) == 2 and got[0] is not None
              and got[1] is not None and abs(got[0] - 1.0) < 0.06
              and abs(got[1] - 3.0) < 0.06)

print()
if fails:
    print(f"{len(fails)} FAILED")
    sys.exit(1)
print("all passed")