centralized configuration system for lsfg-vk params

6 files changed, 270 insertions, 99 deletions

diff --git a/py_modules/lsfg_vk/config_schema.py b/py_modules/lsfg_vk/config_schema.py
new file mode 100644
index 0000000..0f1bdae
--- /dev/null
+++ b/py_modules/lsfg_vk/config_schema.py
@@ -0,0 +1,228 @@
+"""
+Centralized configuration schema for lsfg-vk.
+
+This module defines the complete configuration structure, including:
+- Field definitions with types, defaults, and metadata
+- Script generation logic
+- Validation rules
+- Type definitions
+"""
+
+from typing import TypedDict, Dict, Any, Union, Callable, cast
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ConfigFieldType(Enum):
+    """Supported configuration field types"""
+    BOOLEAN = "boolean"
+    INTEGER = "integer"
+    FLOAT = "float"
+
+
+@dataclass
+class ConfigField:
+    """Configuration field definition"""
+    name: str
+    field_type: ConfigFieldType
+    default: Union[bool, int, float]
+    description: str
+    script_template: str  # Template for script generation
+    script_comment: str = ""  # Comment to add when disabled
+    
+    def get_script_line(self, value: Union[bool, int, float]) -> str:
+        """Generate script line for this field"""
+        if self.field_type == ConfigFieldType.BOOLEAN:
+            if value:
+                return self.script_template.format(value=1)
+            else:
+                return f"# {self.script_template.format(value=1)}"
+        else:
+            return self.script_template.format(value=value)
+
+
+# Configuration schema definition
+CONFIG_SCHEMA: Dict[str, ConfigField] = {
+    "enable_lsfg": ConfigField(
+        name="enable_lsfg",
+        field_type=ConfigFieldType.BOOLEAN,
+        default=True,
+        description="Enables the frame generation layer",
+        script_template="export ENABLE_LSFG={value}",
+        script_comment="# export ENABLE_LSFG=1"
+    ),
+    
+    "multiplier": ConfigField(
+        name="multiplier",
+        field_type=ConfigFieldType.INTEGER,
+        default=2,
+        description="Traditional FPS multiplier value",
+        script_template="export LSFG_MULTIPLIER={value}"
+    ),
+    
+    "flow_scale": ConfigField(
+        name="flow_scale",
+        field_type=ConfigFieldType.FLOAT,
+        default=0.8,
+        description="Lowers the internal motion estimation resolution",
+        script_template="export LSFG_FLOW_SCALE={value}"
+    ),
+    
+    "hdr": ConfigField(
+        name="hdr",
+        field_type=ConfigFieldType.BOOLEAN,
+        default=False,
+        description="Enable HDR mode (only if Game supports HDR)",
+        script_template="export LSFG_HDR={value}",
+        script_comment="# export LSFG_HDR=1"
+    ),
+    
+    "perf_mode": ConfigField(
+        name="perf_mode",
+        field_type=ConfigFieldType.BOOLEAN,
+        default=True,
+        description="Use lighter model for FG",
+        script_template="export LSFG_PERF_MODE={value}",
+        script_comment="# export LSFG_PERF_MODE=1"
+    ),
+    
+    "immediate_mode": ConfigField(
+        name="immediate_mode",
+        field_type=ConfigFieldType.BOOLEAN,
+        default=False,
+        description="Reduce input lag (Experimental, will cause issues in many games)",
+        script_template="export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync",
+        script_comment="# export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync"
+    ),
+    
+    "disable_vkbasalt": ConfigField(
+        name="disable_vkbasalt",
+        field_type=ConfigFieldType.BOOLEAN,
+        default=True,
+        description="Some plugins add vkbasalt layer, which can break lsfg. Toggling on fixes this",
+        script_template="export DISABLE_VKBASALT={value}",
+        script_comment="# export DISABLE_VKBASALT=1"
+    ),
+    
+    "frame_cap": ConfigField(
+        name="frame_cap",
+        field_type=ConfigFieldType.INTEGER,
+        default=0,
+        description="Limit base game FPS (0 = disabled)",
+        script_template="export DXVK_FRAME_RATE={value}",
+        script_comment="# export DXVK_FRAME_RATE=60"
+    )
+}
+
+
+class ConfigurationData(TypedDict):
+    """Type-safe configuration data structure"""
+    enable_lsfg: bool
+    multiplier: int
+    flow_scale: float
+    hdr: bool
+    perf_mode: bool
+    immediate_mode: bool
+    disable_vkbasalt: bool
+    frame_cap: int
+
+
+class ConfigurationManager:
+    """Centralized configuration management"""
+    
+    @staticmethod
+    def get_defaults() -> ConfigurationData:
+        """Get default configuration values"""
+        return cast(ConfigurationData, {
+            field.name: field.default 
+            for field in CONFIG_SCHEMA.values()
+        })
+    
+    @staticmethod
+    def get_field_names() -> list[str]:
+        """Get ordered list of configuration field names"""
+        return list(CONFIG_SCHEMA.keys())
+    
+    @staticmethod
+    def get_field_types() -> Dict[str, ConfigFieldType]:
+        """Get field type mapping"""
+        return {
+            field.name: field.field_type 
+            for field in CONFIG_SCHEMA.values()
+        }
+    
+    @staticmethod
+    def validate_config(config: Dict[str, Any]) -> ConfigurationData:
+        """Validate and convert configuration data"""
+        validated = {}
+        
+        for field_name, field_def in CONFIG_SCHEMA.items():
+            value = config.get(field_name, field_def.default)
+            
+            # Type validation and conversion
+            if field_def.field_type == ConfigFieldType.BOOLEAN:
+                validated[field_name] = bool(value)
+            elif field_def.field_type == ConfigFieldType.INTEGER:
+                validated[field_name] = int(value)
+            elif field_def.field_type == ConfigFieldType.FLOAT:
+                validated[field_name] = float(value)
+            else:
+                validated[field_name] = value
+        
+        return cast(ConfigurationData, validated)
+    
+    @staticmethod
+    def generate_script_content(config: ConfigurationData) -> str:
+        """Generate lsfg script content from configuration"""
+        script_lines = ["#!/bin/bash", ""]
+        
+        # Generate script lines for each field
+        for field_name in CONFIG_SCHEMA.keys():
+            field_def = CONFIG_SCHEMA[field_name]
+            value = config[field_name]
+            
+            if field_def.field_type == ConfigFieldType.BOOLEAN:
+                if value:
+                    script_lines.append(field_def.script_template.format(value=1))
+                else:
+                    script_lines.append(field_def.script_comment)
+            else:
+                # For frame_cap, special handling for 0 value
+                if field_name == "frame_cap" and value == 0:
+                    script_lines.append(field_def.script_comment)
+                else:
+                    script_lines.append(field_def.script_template.format(value=value))
+        
+        # Add script footer
+        script_lines.extend([
+            "",
+            "# Execute the passed command with the environment variables set",
+            'exec "$@"'
+        ])
+        
+        return "\n".join(script_lines)
+    
+    @staticmethod
+    def get_update_signature() -> list[tuple[str, type]]:
+        """Get the function signature for update_config method"""
+        signature = []
+        for field_name, field_def in CONFIG_SCHEMA.items():
+            if field_def.field_type == ConfigFieldType.BOOLEAN:
+                signature.append((field_name, bool))
+            elif field_def.field_type == ConfigFieldType.INTEGER:
+                signature.append((field_name, int))
+            elif field_def.field_type == ConfigFieldType.FLOAT:
+                signature.append((field_name, float))
+        return signature
+    
+    @staticmethod
+    def create_config_from_args(*args) -> ConfigurationData:
+        """Create configuration from ordered arguments"""
+        field_names = ConfigurationManager.get_field_names()
+        if len(args) != len(field_names):
+            raise ValueError(f"Expected {len(field_names)} arguments, got {len(args)}")
+        
+        return cast(ConfigurationData, {
+            field_name: args[i] 
+            for i, field_name in enumerate(field_names)
+        })
diff --git a/py_modules/lsfg_vk/configuration.py b/py_modules/lsfg_vk/configuration.py
index 5dc0629..8be7b47 100644
--- a/py_modules/lsfg_vk/configuration.py
+++ b/py_modules/lsfg_vk/configuration.py
@@ -7,8 +7,8 @@ from pathlib import Path
 from typing import Dict, Any
 
 from .base_service import BaseService
-from .constants import LSFG_SCRIPT_TEMPLATE
-from .types import ConfigurationResponse, ConfigurationData
+from .config_schema import ConfigurationManager, ConfigurationData, CONFIG_SCHEMA
+from .types import ConfigurationResponse
 
 
 class ConfigurationService(BaseService):
@@ -32,8 +32,6 @@ class ConfigurationService(BaseService):
             content = self.lsfg_script_path.read_text()
             config = self._parse_script_content(content)
             
-            self.log.info(f"Parsed lsfg config: {config}")
-            
             return {
                 "success": True,
                 "config": config,
@@ -60,16 +58,8 @@ class ConfigurationService(BaseService):
         Returns:
             ConfigurationData with parsed values
         """
-        config: ConfigurationData = {
-            "enable_lsfg": False,
-            "multiplier": 2,
-            "flow_scale": 1.0,
-            "hdr": False,
-            "perf_mode": False,
-            "immediate_mode": False,
-            "disable_vkbasalt": False,
-            "frame_cap": 0
-        }
+        # Start with defaults
+        config = ConfigurationManager.get_defaults()
         
         lines = content.split('\n')
         for line in lines:
@@ -140,15 +130,18 @@ class ConfigurationService(BaseService):
             ConfigurationResponse with success status
         """
         try:
-            # Generate script content using template
-            script_content = self._generate_script_content(
+            # Create configuration from individual arguments
+            config = ConfigurationManager.create_config_from_args(
                 enable_lsfg, multiplier, flow_scale, hdr, perf_mode, immediate_mode, disable_vkbasalt, frame_cap
             )
             
+            # Generate script content using centralized manager
+            script_content = ConfigurationManager.generate_script_content(config)
+            
             # Write the updated script atomically
             self._atomic_write(self.lsfg_script_path, script_content, 0o755)
             
-            self.log.info(f"Updated lsfg script configuration: enable={enable_lsfg}, "
+            self.log.info(f"Updated lsfg script configuration: enable_lsfg={enable_lsfg}, "
                          f"multiplier={multiplier}, flow_scale={flow_scale}, hdr={hdr}, "
                          f"perf_mode={perf_mode}, immediate_mode={immediate_mode}, "
                          f"disable_vkbasalt={disable_vkbasalt}, frame_cap={frame_cap}")
@@ -169,31 +162,12 @@ class ConfigurationService(BaseService):
                 "message": None,
                 "error": str(e)
             }
-    
-    def _generate_script_content(self, enable_lsfg: bool, multiplier: int, flow_scale: float,
-                               hdr: bool, perf_mode: bool, immediate_mode: bool, disable_vkbasalt: bool, frame_cap: int) -> str:
-        """Generate script content from configuration parameters
-        
-        Args:
-            enable_lsfg: Whether to enable LSFG
-            multiplier: LSFG multiplier value
-            flow_scale: LSFG flow scale value
-            hdr: Whether to enable HDR
-            perf_mode: Whether to enable performance mode
-            immediate_mode: Whether to enable immediate present mode
-            disable_vkbasalt: Whether to disable vkbasalt layer
-            frame_cap: Frame rate cap value (0-60, 0 = disabled)
-            
-        Returns:
-            Generated script content
-        """
-        return LSFG_SCRIPT_TEMPLATE.format(
-            enable_lsfg="export ENABLE_LSFG=1" if enable_lsfg else "# export ENABLE_LSFG=1",
-            multiplier=multiplier,
-            flow_scale=flow_scale,
-            hdr="export LSFG_HDR=1" if hdr else "# export LSFG_HDR=1",
-            perf_mode="export LSFG_PERF_MODE=1" if perf_mode else "# export LSFG_PERF_MODE=1",
-            immediate_mode="export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync" if immediate_mode else "# export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync",
-            disable_vkbasalt="export DISABLE_VKBASALT=1" if disable_vkbasalt else "# export DISABLE_VKBASALT=1",
-            frame_cap=f"export DXVK_FRAME_RATE={frame_cap}" if frame_cap > 0 else "# export DXVK_FRAME_RATE=60"
-        )
+        except ValueError as e:
+            error_msg = f"Invalid configuration arguments: {str(e)}"
+            self.log.error(error_msg)
+            return {
+                "success": False,
+                "config": None,
+                "message": None,
+                "error": str(e)
+            }
diff --git a/py_modules/lsfg_vk/constants.py b/py_modules/lsfg_vk/constants.py
index 878ac2f..5f1e5a2 100644
--- a/py_modules/lsfg_vk/constants.py
+++ b/py_modules/lsfg_vk/constants.py
@@ -26,33 +26,7 @@ BIN_DIR = "bin"
 STEAM_COMMON_PATH = Path("steamapps/common/Lossless Scaling")
 LOSSLESS_DLL_NAME = "Lossless.dll"
 
-# Script template
-LSFG_SCRIPT_TEMPLATE = """#!/bin/bash
-
-{enable_lsfg}
-export LSFG_MULTIPLIER={multiplier}
-export LSFG_FLOW_SCALE={flow_scale}
-{hdr}
-{perf_mode}
-{immediate_mode}
-{disable_vkbasalt}
-{frame_cap}
-
-# Execute the passed command with the environment variables set
-exec "$@"
-"""
-
 # Environment variable names
 ENV_LSFG_DLL_PATH = "LSFG_DLL_PATH"
 ENV_XDG_DATA_HOME = "XDG_DATA_HOME"
 ENV_HOME = "HOME"
-
-# Default configuration values
-DEFAULT_MULTIPLIER = 2
-DEFAULT_FLOW_SCALE = 0.8
-DEFAULT_ENABLE_LSFG = True
-DEFAULT_HDR = False
-DEFAULT_PERF_MODE = True
-DEFAULT_IMMEDIATE_MODE = False
-DEFAULT_DISABLE_VKBASALT = True
-DEFAULT_FRAME_CAP = 0
diff --git a/py_modules/lsfg_vk/installation.py b/py_modules/lsfg_vk/installation.py
index 7fb97db..767a97a 100644
--- a/py_modules/lsfg_vk/installation.py
+++ b/py_modules/lsfg_vk/installation.py
@@ -12,11 +12,9 @@ from typing import Dict, Any
 from .base_service import BaseService
 from .constants import (
     LIB_FILENAME, JSON_FILENAME, ZIP_FILENAME, BIN_DIR,
-    SO_EXT, JSON_EXT, LSFG_SCRIPT_TEMPLATE,
-    DEFAULT_MULTIPLIER, DEFAULT_FLOW_SCALE, DEFAULT_ENABLE_LSFG,
-    DEFAULT_HDR, DEFAULT_PERF_MODE, DEFAULT_IMMEDIATE_MODE, DEFAULT_DISABLE_VKBASALT,
-    DEFAULT_FRAME_CAP
+    SO_EXT, JSON_EXT
 )
+from .config_schema import ConfigurationManager
 from .types import InstallationResponse, UninstallationResponse, InstallationCheckResponse
 
 
@@ -106,16 +104,11 @@ class InstallationService(BaseService):
     
     def _create_lsfg_script(self) -> None:
         """Create the lsfg script in home directory with default configuration"""
-        script_content = LSFG_SCRIPT_TEMPLATE.format(
-            enable_lsfg="export ENABLE_LSFG=1" if DEFAULT_ENABLE_LSFG else "# export ENABLE_LSFG=1",
-            multiplier=DEFAULT_MULTIPLIER,
-            flow_scale=DEFAULT_FLOW_SCALE,
-            hdr="export LSFG_HDR=1" if DEFAULT_HDR else "# export LSFG_HDR=1",
-            perf_mode="export LSFG_PERF_MODE=1" if DEFAULT_PERF_MODE else "# export LSFG_PERF_MODE=1",
-            immediate_mode="export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync" if DEFAULT_IMMEDIATE_MODE else "# export MESA_VK_WSI_PRESENT_MODE=immediate # - disable vsync",
-            disable_vkbasalt="export DISABLE_VKBASALT=1" if DEFAULT_DISABLE_VKBASALT else "# export DISABLE_VKBASALT=1",
-            frame_cap=f"export DXVK_FRAME_RATE={DEFAULT_FRAME_CAP}" if DEFAULT_FRAME_CAP > 0 else "# export DXVK_FRAME_RATE=60"
-        )
+        # Get default configuration
+        defaults = ConfigurationManager.get_defaults()
+        
+        # Generate script content using centralized manager
+        script_content = ConfigurationManager.generate_script_content(defaults)
         
         # Use atomic write to prevent corruption
         self._atomic_write(self.lsfg_script_path, script_content, 0o755)
diff --git a/py_modules/lsfg_vk/plugin.py b/py_modules/lsfg_vk/plugin.py
index 7dcda4e..b357ee6 100644
--- a/py_modules/lsfg_vk/plugin.py
+++ b/py_modules/lsfg_vk/plugin.py
@@ -11,6 +11,7 @@ from typing import Dict, Any
 from .installation import InstallationService
 from .dll_detection import DllDetectionService
 from .configuration import ConfigurationService
+from .config_schema import ConfigurationManager
 
 
 class Plugin:
@@ -72,14 +73,26 @@ class Plugin:
         """
         return self.configuration_service.get_config()
 
+    async def get_config_schema(self) -> Dict[str, Any]:
+        """Get configuration schema information for frontend
+        
+        Returns:
+            Dict with field names, types, and defaults
+        """
+        return {
+            "field_names": ConfigurationManager.get_field_names(),
+            "field_types": {name: field_type.value for name, field_type in ConfigurationManager.get_field_types().items()},
+            "defaults": ConfigurationManager.get_defaults()
+        }
+
     async def update_lsfg_config(self, enable_lsfg: bool, multiplier: int, flow_scale: float, 
                           hdr: bool, perf_mode: bool, immediate_mode: bool, disable_vkbasalt: bool, frame_cap: int) -> Dict[str, Any]:
         """Update lsfg script configuration
         
         Args:
             enable_lsfg: Whether to enable LSFG
-            multiplier: LSFG multiplier value (typically 2-4)
-            flow_scale: LSFG flow scale value (typically 0.5-2.0)
+            multiplier: LSFG multiplier value
+            flow_scale: LSFG flow scale value
             hdr: Whether to enable HDR
             perf_mode: Whether to enable performance mode
             immediate_mode: Whether to enable immediate present mode (disable vsync)
diff --git a/py_modules/lsfg_vk/types.py b/py_modules/lsfg_vk/types.py
index 9f44cf1..3d555e1 100644
--- a/py_modules/lsfg_vk/types.py
+++ b/py_modules/lsfg_vk/types.py
@@ -3,6 +3,7 @@ Type definitions for the lsfg-vk plugin responses.
 """
 
 from typing import TypedDict, Optional, List
+from .config_schema import ConfigurationData
 
 
 class BaseResponse(TypedDict):
@@ -54,18 +55,6 @@ class DllDetectionResponse(TypedDict):
     error: Optional[str]
 
 
-class ConfigurationData(TypedDict):
-    """Configuration data structure"""
-    enable_lsfg: bool
-    multiplier: int
-    flow_scale: float
-    hdr: bool
-    perf_mode: bool
-    immediate_mode: bool
-    disable_vkbasalt: bool
-    frame_cap: int
-
-
 class ConfigurationResponse(BaseResponse):
     """Response for configuration operations"""
     config: Optional[ConfigurationData]