"""MILP dispatch: dvouúrovňové SoC a záporná nákupní cena (bez DB)."""

from __future__ import annotations

import unittest
from datetime import datetime, timezone
from types import SimpleNamespace

from services.planning_engine import (
    PlanningSlot,
    _dynamic_arb_floor_wh_series,
    solve_dispatch,
)


def _slot(
    *,
    load: int = 2000,
    buy: float = 3.0,
    sell: float = 3.0,
    pv_a: int = 0,
    pv_b: int = 0,
) -> PlanningSlot:
    return PlanningSlot(
        interval_start=datetime(2026, 4, 3, 12, 0, tzinfo=timezone.utc),
        buy_price=buy,
        sell_price=sell,
        pv_a_forecast_w=pv_a,
        pv_b_forecast_w=pv_b,
        load_baseline_w=load,
        ev1_connected=False,
        ev2_connected=False,
        is_predicted_price=False,
    )


def _battery(
    *,
    uc_wh: float = 100_000.0,
    min_pct: float = 10.0,
    arb_pct: float = 20.0,
    max_pct: float = 95.0,
) -> SimpleNamespace:
    uc = uc_wh
    min_wh = min_pct / 100.0 * uc
    arb_wh = arb_pct / 100.0 * uc
    return SimpleNamespace(
        usable_capacity_wh=uc,
        min_soc_wh=min_wh,
        arb_floor_wh=arb_wh,
        reserve_soc_wh=arb_wh,
        soc_max_wh=max_pct / 100.0 * uc,
        charge_efficiency=0.95,
        discharge_efficiency=0.95,
        degradation_cost_czk_kwh=0.15,
        max_charge_power_w=10_000,
        max_discharge_power_w=10_000,
    )


class DynamicArbFloorTests(unittest.TestCase):
    def test_more_pv_ahead_lowers_floor(self) -> None:
        """Čím víc FVE ve lookahead, tím nižší ekonomická podlaha v prvním slotu."""
        min_w = 1_000.0
        base_w = 2_000.0
        uc = 10_000.0
        s0 = _slot()
        s_low_pv = replace_slot(s0, pv_a=100, pv_b=0)
        s_high_pv = replace_slot(s0, pv_a=50_000, pv_b=0)
        ser_low = _dynamic_arb_floor_wh_series([s_low_pv] * 40, min_w, base_w, uc)
        ser_high = _dynamic_arb_floor_wh_series([s_high_pv] * 40, min_w, base_w, uc)
        self.assertLess(ser_high[0], ser_low[0])
        self.assertGreaterEqual(ser_low[0], min_w)
        self.assertLessEqual(ser_low[0], base_w)


def replace_slot(
    s: PlanningSlot,
    *,
    pv_a: int | None = None,
    pv_b: int | None = None,
    load: int | None = None,
) -> PlanningSlot:
    return PlanningSlot(
        interval_start=s.interval_start,
        buy_price=s.buy_price,
        sell_price=s.sell_price,
        pv_a_forecast_w=pv_a if pv_a is not None else s.pv_a_forecast_w,
        pv_b_forecast_w=pv_b if pv_b is not None else s.pv_b_forecast_w,
        load_baseline_w=load if load is not None else s.load_baseline_w,
        ev1_connected=s.ev1_connected,
        ev2_connected=s.ev2_connected,
        is_predicted_price=s.is_predicted_price,
    )


class PlanningDispatchMilpTests(unittest.TestCase):
    def test_two_tier_soc_solves_optimal(self) -> None:
        slots = [_slot()]
        battery = _battery()
        hp = SimpleNamespace(
            rated_heating_power_w=0,
            tuv_min_temp_c=45.0,
            tuv_target_temp_c=55.0,
        )
        grid = SimpleNamespace(max_import_power_w=15_000, max_export_power_w=15_000)
        vehicles = [
            SimpleNamespace(
                max_charge_power_w=0,
                battery_capacity_kwh=1.0,
                default_target_soc_pct=80.0,
            ),
            SimpleNamespace(
                max_charge_power_w=0,
                battery_capacity_kwh=1.0,
                default_target_soc_pct=80.0,
            ),
        ]
        soc0 = 0.15 * battery.usable_capacity_wh
        results, ms = solve_dispatch(
            slots,
            battery,
            hp,
            grid,
            [None, None],
            vehicles,
            soc0,
            50.0,
            tuv_delta_stats=None,
            operating_mode="AUTO",
            price_failsafe_active=False,
        )
        self.assertGreaterEqual(ms, 0)
        self.assertEqual(len(results), 1)

    def test_deep_discharge_allows_covering_load_only(self) -> None:
        slots = [
            _slot(load=3000, buy=1.0, sell=6.0, pv_a=0, pv_b=0),
            _slot(load=3000, buy=1.0, sell=6.0, pv_a=0, pv_b=0),
        ]
        battery = _battery(uc_wh=50_000.0)
        hp = SimpleNamespace(
            rated_heating_power_w=0,
            tuv_min_temp_c=45.0,
            tuv_target_temp_c=55.0,
        )
        grid = SimpleNamespace(max_import_power_w=20_000, max_export_power_w=20_000)
        vehicles = [
            SimpleNamespace(
                max_charge_power_w=11_000,
                battery_capacity_kwh=50.0,
                default_target_soc_pct=80.0,
            ),
            SimpleNamespace(
                max_charge_power_w=11_000,
                battery_capacity_kwh=50.0,
                default_target_soc_pct=80.0,
            ),
        ]
        soc0 = 0.12 * battery.usable_capacity_wh
        results, _ms = solve_dispatch(
            slots,
            battery,
            hp,
            grid,
            [None, None],
            vehicles,
            soc0,
            50.0,
            tuv_delta_stats=None,
            operating_mode="AUTO",
            price_failsafe_active=False,
        )
        self.assertEqual(len(results), 2)

    def test_negative_buy_price_allows_import_for_baseline(self) -> None:
        slots = [_slot(load=6000, buy=-0.5, sell=2.0)]
        battery = _battery()
        hp = SimpleNamespace(
            rated_heating_power_w=8000,
            tuv_min_temp_c=45.0,
            tuv_target_temp_c=55.0,
        )
        grid = SimpleNamespace(max_import_power_w=25_000, max_export_power_w=15_000)
        vehicles = [
            SimpleNamespace(
                max_charge_power_w=11_000,
                battery_capacity_kwh=50.0,
                default_target_soc_pct=80.0,
            ),
            SimpleNamespace(
                max_charge_power_w=11_000,
                battery_capacity_kwh=50.0,
                default_target_soc_pct=80.0,
            ),
        ]
        soc0 = 0.5 * battery.usable_capacity_wh
        results, _ms = solve_dispatch(
            slots,
            battery,
            hp,
            grid,
            [None, None],
            vehicles,
            soc0,
            50.0,
            tuv_delta_stats=None,
            operating_mode="AUTO",
            price_failsafe_active=False,
        )
        self.assertGreaterEqual(results[0].grid_setpoint_w, 0)


if __name__ == "__main__":
    unittest.main()