feat: implement HA-side accumulation for monthly spent sensor

- Replace API-based calculation with Home Assistant state accumulation
- Only track orders with final prices (delivered and closed)
- Use RestoreEntity to persist monthly totals across restarts
- Track processed order IDs to avoid duplicates
- Automatically reset at start of each month
- Add state_class for proper history tracking
- Fixes issue where only 15 days of history were visible due to API limit (50 orders)

This approach eliminates dependency on API order limit and provides
full monthly history regardless of order count.

Author: eMeF1

custom_components/rohlikcz/sensor.py

@@ -9,11 +9,12 @@
 from datetime import timedelta, datetime, time
 from typing import Any
 from zoneinfo import ZoneInfo
-from homeassistant.components.sensor import SensorEntity, SensorDeviceClass
+from homeassistant.components.sensor import SensorEntity, SensorDeviceClass, SensorStateClass
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory, STATE_UNAVAILABLE
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.restore_state import RestoreEntity
 from .const import DOMAIN, ICON_UPDATE, ICON_CREDIT, ICON_NO_LIMIT, ICON_FREE_EXPRESS, ICON_DELIVERY, ICON_BAGS, \
     ICON_CART, ICON_ACCOUNT, ICON_EMAIL, ICON_PHONE, ICON_PREMIUM_DAYS, ICON_LAST_ORDER, ICON_NEXT_ORDER_SINCE, \
     ICON_NEXT_ORDER_TILL, ICON_INFO, ICON_DELIVERY_TIME, ICON_MONTHLY_SPENT
@@ -424,24 +425,158 @@ async def async_will_remove_from_hass(self) -> None:
         self._rohlik_account.remove_callback(self.async_write_ha_state)
 
 
-class MonthlySpent(BaseEntity, SensorEntity):
-    """Sensor for amount spent in current month."""
+class MonthlySpent(BaseEntity, SensorEntity, RestoreEntity):
+    """Sensor for amount spent in current month with HA-side accumulation.
+    
+    Only tracks orders that are delivered and closed (have final price).
+    Orders from the delivered_orders endpoint should all be finalized.
+    Uses Home Assistant's restore state to persist monthly totals across restarts.
+    """
 
     _attr_translation_key = "monthly_spent"
     _attr_should_poll = False
+    _attr_state_class = SensorStateClass.TOTAL
+    _attr_native_unit_of_measurement = "CZK"
+
+    def __init__(self, rohlik_account: RohlikAccount) -> None:
+        super().__init__(rohlik_account)
+        self._monthly_total: float = 0.0
+        self._processed_orders: set[str] = set()  # Store order IDs
+        self._current_month: str = datetime.now().strftime("%Y-%m")
+        self._last_reset: datetime | None = None
+
+    def _is_order_final(self, order: dict) -> bool:
+        """
+        Verify order has a final price.
+        
+        Since orders come from the 'delivered_orders' endpoint, they should be finalized.
+        We verify by checking that priceComposition exists and has a valid amount.
+        """
+        # Check if priceComposition exists
+        price_comp = order.get('priceComposition')
+        if not price_comp:
+            return False
+        
+        # Check if total exists
+        total = price_comp.get('total')
+        if not total:
+            return False
+        
+        # Check if amount exists and is a valid number
+        amount = total.get('amount')
+        if amount is None:
+            return False
+        
+        # Verify it's a valid number
+        try:
+            float(amount)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    async def async_added_to_hass(self) -> None:
+        """Restore state when added to HA."""
+        await super().async_added_to_hass()
+        
+        if (last_state := await self.async_get_last_state()) is not None:
+            self._monthly_total = last_state.attributes.get("monthly_total", 0.0)
+            self._processed_orders = set(last_state.attributes.get("processed_orders", []))
+            self._current_month = last_state.attributes.get("current_month", datetime.now().strftime("%Y-%m"))
+            if last_reset_str := last_state.attributes.get("last_reset"):
+                self._last_reset = datetime.fromisoformat(last_reset_str)
+        
+        self._check_and_reset_month()
+        self._process_new_orders()
+        
+        self._rohlik_account.register_callback(self.async_write_ha_state)
+
+    def _check_and_reset_month(self) -> None:
+        """Reset total if month changed."""
+        current_month = datetime.now().strftime("%Y-%m")
+        if current_month != self._current_month:
+            _LOGGER.info(f"Month changed from {self._current_month} to {current_month}, resetting monthly total")
+            self._monthly_total = 0.0
+            self._processed_orders = set()
+            self._current_month = current_month
+            self._last_reset = datetime.now(ZoneInfo("Europe/Prague"))
+
+    def _process_new_orders(self) -> None:
+        """Process new orders and add to total.
+        
+        Only processes orders that are delivered and closed (have final price).
+        Uses order ID for unique identification.
+        """
+        orders = self._rohlik_account.data.get('delivered_orders', [])
+        if not orders:
+            return
+        
+        current_month_pattern = datetime.now().strftime("%Y-%m-")
+        new_orders_count = 0
+        
+        for order in orders:
+            try:
+                order_time = order.get('orderTime', '')
+                
+                # Only process orders from current month
+                if current_month_pattern not in order_time:
+                    continue
+                
+                # Verify order has final price (delivered and closed)
+                if not self._is_order_final(order):
+                    _LOGGER.debug(f"Order {order.get('id')} does not have final price, skipping")
+                    continue
+                
+                # Get order ID (unique identifier)
+                order_id = order.get('id')
+                if not order_id:
+                    _LOGGER.warning(f"Order missing ID, skipping: {order.get('orderTime')}")
+                    continue
+                
+                order_key = str(order_id)
+                
+                # Skip if already processed
+                if order_key in self._processed_orders:
+                    continue
+                
+                # Get the final price
+                amount = float(order['priceComposition']['total']['amount'])
+                
+                # Add to total and mark as processed
+                self._monthly_total += amount
+                self._processed_orders.add(order_key)
+                new_orders_count += 1
+                
+                _LOGGER.debug(f"Added order {order_id} with amount {amount} CZK. New total: {self._monthly_total} CZK")
+                
+            except (KeyError, ValueError, TypeError) as e:
+                _LOGGER.warning(f"Skipping order due to error: {e}, order ID: {order.get('id')}")
+                continue
+        
+        if new_orders_count > 0:
+            _LOGGER.info(f"Processed {new_orders_count} new order(s). Monthly total: {self._monthly_total} CZK")
 
     @property
     def native_value(self) -> float | None:
-        """Returns amount spend within last month."""
-        return calculate_current_month_orders_total(self._rohlik_account.data.get('delivered_orders', []))
+        """Returns amount spent in current month."""
+        self._check_and_reset_month()
+        self._process_new_orders()
+        return self._monthly_total if self._monthly_total > 0 else 0.0
+
+    @property
+    def extra_state_attributes(self) -> Mapping[str, Any] | None:
+        """Store state for restoration."""
+        return {
+            "monthly_total": self._monthly_total,
+            "processed_orders": list(self._processed_orders),
+            "current_month": self._current_month,
+            "last_reset": self._last_reset.isoformat() if self._last_reset else None,
+            "processed_count": len(self._processed_orders)
+        }
 
     @property
     def icon(self) -> str:
         return ICON_MONTHLY_SPENT
 
-    async def async_added_to_hass(self) -> None:
-        self._rohlik_account.register_callback(self.async_write_ha_state)
-
     async def async_will_remove_from_hass(self) -> None:
         self._rohlik_account.remove_callback(self.async_write_ha_state)