from core.controllers.ProfileController import ProfileController from core.services.profiles.attribute_filters import protocol_matches_profile_type, app_or_display_matches_profile_type from core.controllers.profile_state.data_filters import protocol_is_supported_for_location from gui.v2.presenters.data.location_data import get_location_display_data from gui.v2.presenters.data.app_data import get_app_display_data from gui.v2.presenters.data.protocol_data import get_protocol_button_data from gui.v2.presenters.data.resolution_data import get_resolution_data, validate_selected_resolution from gui.v2.presenters.data.type_data import get_profile_type_data from gui.v2.presenters.image_tools.button_factory import create_button_image, create_resolution_button_image, blank_button from core.errors.logger import logger from pathlib import Path from typing import Optional class RegistrationState: def __init__(self, btn_path, profile_id: Optional[int] = None): self.btn_path = btn_path self.all_options = {} self.selections = {} self.order_map = {} self.pixmap_cache = {} self.profile_id = profile_id # Maps a category to the function that validates its current selection. self._filter_map = { "protocol": self.is_protocol_valid, "browser": self.is_app_valid, "resolution": self.is_resolution_valid, } # Maps a "Trigger" category to the categories it affects. self._dependency_map = { "type": ["protocol", "browser", "resolution"], "location": ["protocol"], } # Callbacks to notify the UI. Store functions here: { "Category": callback_func } self.listeners = {} # Gets this profile's available data: if self.profile_id is not None: logger.info(f"RegistrationState got a profile id of {self.profile_id}") default_data = ProfileController.get_default_state_dict(profile_id) else: default_data = None # Gets ALL available data: self._load_all_data(default_data) def register_listener(self, category, callback): """UI elements call this to be notified when their category changes.""" self.listeners[category] = callback def _no_premade_choices(self, category: str, default_data: Optional[dict]): """For categories without premade choices, we see if default data is available. If not, then it's None""" if default_data: self.selections[category] = default_data.get(category) else: self.selections[category] = None def _load_all_data(self, default_data: Optional[dict] = None): """Load the data for a given category, and then register that data""" load_config = { "type": (get_profile_type_data, 0), "protocol": (get_protocol_button_data, 0), "resolution": (get_resolution_data, 0), "location": (get_location_display_data, 0), "browser": (get_app_display_data, 0), "name": (None, None) } for category, (loader_func, default_idx) in load_config.items(): if loader_func is None: self._no_premade_choices(category=category, default_data=default_data) continue data = loader_func(self.btn_path) self._register_category(category=category, data=data, default_data=default_data, default_idx=default_idx) def _register_category(self, category: str, data: dict, default_data: Optional[dict], default_idx: int = 0): """Setup a category with a given data set and default index""" if isinstance(data, list): data = {item: item for item in data} self.all_options[category] = data self.order_map[category] = list(data.keys()) # Default selection logic if default_data is not None: # If default_data is provided, we use it exclusively. # .get() returns None if the category key is missing. self.selections[category] = default_data.get(category) else: # Fall back to index-based selection only if default_data was not provided. ids = self.order_map[category] self.selections[category] = ids[default_idx] if ids and default_idx < len(ids) else (ids[0] if ids else None) def _ensure_valid(self, category): """Generic validator: resets selection to first valid option, or None if none exist.""" filter_func = self._filter_map.get(category) if not filter_func: return current_val = self.selections.get(category) # If current selection is invalid (or None), try to find a replacement if current_val is None or not filter_func(current_val): found_valid = False for candidate_id in self.order_map.get(category, []): if filter_func(candidate_id): self.selections[category] = candidate_id found_valid = True break # If no valid option is found, set to None to trigger blank image if not found_valid: self.selections[category] = None def cycle_selection(self, category, direction): ids = self.order_map.get(category, []) if not ids: self.selections[category] = None self._notify(category) return None current_id = self.selections.get(category) current_index = ids.index(current_id) if current_id in ids else 0 filter_func = self._filter_map.get(category) found_valid = False for i in range(1, len(ids) + 1): next_index = (current_index + (i * direction)) % len(ids) candidate_id = ids[next_index] if filter_func is None or filter_func(candidate_id): self.selections[category] = candidate_id found_valid = True break # If we cycled through everything and found nothing valid, set to None if not found_valid: self.selections[category] = None # Reactive Updates dependents = self._dependency_map.get(category, []) # 1. Notify the category that was just cycled self._notify(category) # 2. Check and notify all dependents (e.g., Type -> Browser) for dep in dependents: self._ensure_valid(dep) self._notify(dep) return self.get_current_image(category) def _notify(self, category): """Triggers the UI callback for a specific category.""" if category in self.listeners: self.listeners[category]() def get_current_image(self, category): """Returns an image or a path to one depending on the category and data format""" current_id = self.selections.get(category) if current_id is None: return blank_button(self.btn_path) # Cache check cache_key = f"{category}_{current_id}" if cache_key in self.pixmap_cache: return self.pixmap_cache[cache_key] # 1. HANDLE DYNAMIC CATEGORIES FIRST # These categories build images from the ID itself and don't need a lookup table if category == "resolution": res_img = create_resolution_button_image( btn_path=f"{self.btn_path}/resolution_template.png", resolution_text=str(current_id) ) self.pixmap_cache[cache_key] = res_img return res_img # 2. HANDLE DATA-DRIVEN CATEGORIES # Only perform the lookup for categories that actually use the all_options dictionary try: data = self.all_options[category][current_id] except KeyError: print(f"Error: {current_id} not found in {category} options. Returning blank.") return blank_button(self.btn_path) if data is None: return blank_button(self.btn_path) if isinstance(data, Path): return data if isinstance(data, dict): pixmap = create_button_image( first_line=data.get('name', ''), fallback_image_path=data.get('path'), second_line=data.get('second_line'), existing_icon_path=data.get('existing_icon') ) self.pixmap_cache[cache_key] = pixmap return pixmap else: return blank_button(self.btn_path) # Validation logic, used by the generic _ensure_valid def is_app_valid(self, app_choice): current_type = self.selections.get("type") return app_or_display_matches_profile_type(app_choice=app_choice, profile_type=current_type) def is_protocol_valid(self, protocol_id): """Checks if a protocol is valid by the other choices of type and location.""" current_type = self.selections.get("type") current_location = self.selections.get("location") if not protocol_matches_profile_type(protocol=protocol_id, profile_type=current_type): return False return protocol_is_supported_for_location(location_id=current_location, protocol_choice=protocol_id) def is_resolution_valid(self, resolution_choice): current_type = self.selections.get("type") # same criteria as app: if not app_or_display_matches_profile_type(app_choice=resolution_choice, profile_type=current_type): return False # plus size filter: return validate_selected_resolution(resolution_choice) def get_final_choices(self): return self.selections def set_selection(self, category, value): """Manually set a selection, validate it, and notify listeners.""" # 1. Validate the choice using the existing filter map filter_func = self._filter_map.get(category) if filter_func and not filter_func(value): print(f"Invalid selection for {category}: {value}") return False # 2. Update the selection self.selections[category] = value # 3. Trigger reactive updates for dependents (e.g., if Type changed) dependents = self._dependency_map.get(category, []) for dep in dependents: self._ensure_valid(dep) self._notify(dep) # 4. Notify the UI for this category self._notify(category) return True