nato.py

Author: lexorius

custom_components/alternative_time/calendars/nato.py

@@ -1,12 +1,11 @@
-"""NATO Time formats implementation - Version 2.5 DEBUG."""
+"""NATO Time formats implementation - Version 2.5."""
 from __future__ import annotations
 
 from datetime import datetime
 import logging
 from typing import Dict, Any
 
 from homeassistant.core import HomeAssistant
-from homeassistant.config_entries import ConfigEntry
 
 # WICHTIG: Import der Basis-Klasse direkt aus sensor.py
 import sys
@@ -15,11 +14,9 @@
 
 try:
     from ..sensor import AlternativeTimeSensorBase
-    from ..const import DOMAIN
 except ImportError:
     # Fallback für direkten Import
     from sensor import AlternativeTimeSensorBase
-    from const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -162,61 +159,66 @@ def __init__(self, base_name: str, hass: HomeAssistant) -> None:
         # Get translated name from metadata
         calendar_name = self._translate('name', 'NATO Time')
 
-        # Try to get config_entry from hass.data
-        config_entry = None
-        try:
-            # Look for our integration's data in hass
-            for entry in hass.config_entries.async_entries(DOMAIN):
-                if base_name in entry.data.get("name", ""):
-                    config_entry = entry
-                    break
-        except Exception as e:
-            _LOGGER.debug(f"Could not find config_entry: {e}")
-        
-        # DEBUG: Log all received parameters
-        _LOGGER.warning(f"NATO DEBUG - Initialization started")
-        _LOGGER.warning(f"NATO DEBUG - base_name: {base_name}")
-        _LOGGER.warning(f"NATO DEBUG - config_entry found: {config_entry is not None}")
-        
-        # Load configuration options
-        options = {}
-        
-        if config_entry and config_entry.data:
-            all_plugin_options = config_entry.data.get("plugin_options", {})
-            _LOGGER.warning(f"NATO DEBUG - All plugin_options from config: {all_plugin_options}")
-            options = all_plugin_options.get("nato", {})
-            _LOGGER.warning(f"NATO DEBUG - NATO specific options: {options}")
-        
-        # Configuration options with defaults
-        self._format_type = options.get("format_type", "basic")
-        self._show_zone_name = options.get("show_zone_name", False)
-        self._use_local_zone = options.get("use_local_zone", True)
-        
-        _LOGGER.warning(f"NATO DEBUG - Final settings: format_type={self._format_type}, show_zone={self._show_zone_name}, local_zone={self._use_local_zone}")
-        
-        # Adjust name based on format type
-        format_suffix = {
-            "basic": "",
-            "zone": " with Zone",
-            "rescue": " (Rescue Service)"
-        }.get(self._format_type, "")
-        
-        # Set sensor attributes
-        self._attr_name = f"{base_name} {calendar_name}{format_suffix}"
-        self._attr_unique_id = f"{base_name}_nato_time_{self._format_type}"
-        
-        # Set icon based on format type
-        icon_map = {
-            "basic": "mdi:clock-time-eight",
-            "zone": "mdi:earth",
-            "rescue": "mdi:ambulance"
-        }
-        self._attr_icon = icon_map.get(self._format_type, CALENDAR_INFO.get("icon", "mdi:clock-time-eight"))
+        # Set basic attributes first
+        self._attr_name = f"{base_name} {calendar_name}"
+        self._attr_unique_id = f"{base_name}_nato_time"
+        self._attr_icon = CALENDAR_INFO.get("icon", "mdi:clock-time-eight")
+        
+        # Initialize configuration with defaults
+        self._format_type = "basic"
+        self._show_zone_name = False
+        self._use_local_zone = True
 
         # NATO data
         self._nato_data = CALENDAR_INFO["nato_data"]
 
-        _LOGGER.warning(f"NATO DEBUG - Sensor initialized: name={self._attr_name}, format={self._format_type}")
+        # Flag to track if we need to update attributes after config is loaded
+        self._needs_config_update = True
+        
+        _LOGGER.debug(f"NATO sensor initialized with defaults")
+    
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass, load config and set up updates."""
+        # Load plugin options if available
+        if self._needs_config_update:
+            options = self.get_plugin_options()
+            
+            if options:
+                _LOGGER.info(f"NATO: Loading plugin options: {options}")
+                
+                # Update configuration
+                old_format = self._format_type
+                self._format_type = options.get("format_type", "basic")
+                self._show_zone_name = options.get("show_zone_name", False)
+                self._use_local_zone = options.get("use_local_zone", True)
+                
+                # Update name and icon if format changed
+                if old_format != self._format_type:
+                    calendar_name = self._translate('name', 'NATO Time')
+                    format_suffix = {
+                        "basic": "",
+                        "zone": " with Zone",
+                        "rescue": " (Rescue Service)"
+                    }.get(self._format_type, "")
+                    
+                    self._attr_name = f"{self._base_name} {calendar_name}{format_suffix}"
+                    self._attr_unique_id = f"{self._base_name}_nato_time_{self._format_type}"
+                    
+                    icon_map = {
+                        "basic": "mdi:clock-time-eight",
+                        "zone": "mdi:earth",
+                        "rescue": "mdi:ambulance"
+                    }
+                    self._attr_icon = icon_map.get(self._format_type, CALENDAR_INFO.get("icon", "mdi:clock-time-eight"))
+                    
+                    _LOGGER.info(f"NATO: Updated to format={self._format_type}, name={self._attr_name}")
+                
+                self._needs_config_update = False
+            else:
+                _LOGGER.debug(f"NATO: No plugin options found, using defaults")
+        
+        # Call parent implementation for scheduling updates
+        await super().async_added_to_hass()
 
     @property
     def state(self):
@@ -248,7 +250,7 @@ def extra_state_attributes(self) -> Dict[str, Any]:
                 attrs["format_description"] = "German rescue service: DD HHMM MONAT YY"
 
             # Add reference
-            attrs["reference"] = CALENDAR_INFO.get('reference_url', '')
+            attrs["reference"] = "https://en.wikipedia.org/wiki/Date-time_group"
 
             # Add current configuration
             attrs["format_type"] = self._format_type
@@ -284,16 +286,14 @@ def _get_timezone_info(self, earth_time: datetime) -> tuple:
     def _calculate_nato_time(self, earth_time: datetime) -> Dict[str, Any]:
         """Calculate NATO Time based on selected format."""
 
-        _LOGGER.debug(f"NATO DEBUG - Calculating time with format: {self._format_type}")
-        
         if self._format_type == "basic":
             return self._calculate_basic_format(earth_time)
         elif self._format_type == "zone":
             return self._calculate_zone_format(earth_time)
         elif self._format_type == "rescue":
             return self._calculate_rescue_format(earth_time)
         else:
-            _LOGGER.warning(f"NATO DEBUG - Unknown format type: {self._format_type}, using basic")
+            _LOGGER.warning(f"NATO: Unknown format type: {self._format_type}, using basic")
             return self._calculate_basic_format(earth_time)
 
     def _calculate_basic_format(self, earth_time: datetime) -> Dict[str, Any]:
@@ -359,8 +359,6 @@ def _calculate_zone_format(self, earth_time: datetime) -> Dict[str, Any]:
     def _calculate_rescue_format(self, earth_time: datetime) -> Dict[str, Any]:
         """Calculate German rescue service format (DD HHMM MONAT YY)."""
 
-        _LOGGER.debug(f"NATO DEBUG - Calculating rescue format")
-        
         # Get German month abbreviation
         month = self._nato_data["german_months"][earth_time.month]
 
@@ -391,8 +389,6 @@ def _calculate_rescue_format(self, earth_time: datetime) -> Dict[str, Any]:
             "full_display": display
         }
 
-        _LOGGER.debug(f"NATO DEBUG - Rescue format result: {display}")
-        
         return result
 
     def update(self) -> None:
@@ -403,4 +399,4 @@ def update(self) -> None:
         # Set state to formatted NATO time
         self._state = self._nato_time["full_display"]
 
-        _LOGGER.debug(f"NATO DEBUG - Updated to: {self._state} (format: {self._format_type})")
+        _LOGGER.debug(f"NATO: Updated to {self._state} (format: {self._format_type})")