hydraveil-gui/gui/v2/presenters/state/fast_registration_state.py

303 lines
No EOL
12 KiB
Python

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
self.original_choices = {}
# 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)
self.original_choices = default_data
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 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
def get_final_choices(self):
return self.selections
def whats_different(self):
"""Creates a dictionary of the difference between the current selections and the original choices."""
different = {}
if not self.original_choices:
return self.selections
for category, value in self.selections.items():
# wasn't in the original, but it's in the new selections:
try:
if not self.original_choices[category]:
different[category] = value
continue
except KeyError:
different[category] = value
continue
# not in the new choices, but it is in the original:
if not self.selections[category] and self.original_choices[category]:
different[category] = None
continue
# actually different:
if self.original_choices[category] != self.selections[category]:
different[category] = value
return different
def is_anything_different(self) -> bool:
different = self.whats_different()
if different:
return True
else:
return False