#!/usr/bin/python3

"""App configuration for Custom File Dialog"""
from pathlib import Path
import os
from typing import Dict, Any
from shared_libs.common_tools import Translate


class AppConfig:
    """Central configuration and system setup manager for the Wire-Py application.

    This class serves as a singleton-like container for all global configuration data,
    including paths, UI settings, localization, versioning, and system-specific resources.
    It ensures that required directories, files, and services are created and configured
    before the application starts. Additionally, it provides tools for managing translations,
    default settings, and autostart functionality to maintain a consistent user experience.

    Key Responsibilities:
    - Centralizes all configuration values (paths, UI preferences, localization).
    - Ensures required directories and files exist.
    - Handles translation setup via `gettext` for multilingual support.
    - Manages default settings file generation.
    - Configures autostart services using systemd for user-specific launch behavior.

    This class is used globally across the application to access configuration data
    consistently and perform system-level setup tasks.
    """

    # Helper to make icon paths robust, so the script can be run from anywhere
    SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
    MAX_ITEMS_TO_DISPLAY = 1000

    # Base paths
    BASE_DIR: Path = Path.home()
    CONFIG_DIR: Path = BASE_DIR / ".config/cfiledialog"

    # Configuration files
    SETTINGS_FILE: Path = CONFIG_DIR / "settings"
    DEFAULT_SETTINGS: Dict[str, str] = {
        "# Configuration": "on",
        "# Theme": "dark",
        "# Tooltips": True,
        "# Autostart": "off",
    }

    # UI configuration
    UI_CONFIG: Dict[str, Any] = {
        "window_size": (1050, 850),
        "window_min_size": (650, 550),
        "font_family": "Ubuntu",
        "font_size": 11,
        "resizable_window": (True, True),
    }

    @classmethod
    def ensure_directories(cls) -> None:
        """Ensures that all required directories exist"""
        if not cls.CONFIG_DIR.exists():
            cls.CONFIG_DIR.mkdir(parents=True, exist_ok=True)

    @classmethod
    def create_default_settings(cls) -> None:
        """Creates default settings if they don't exist"""
        if not cls.SETTINGS_FILE.exists():
            content = "\n".join(
                f"[{k.upper()}]\n{v}" for k, v in cls.DEFAULT_SETTINGS.items()
            )
            cls.SETTINGS_FILE.write_text(content)


import json

# here is initializing the class for translation strings
_ = Translate.setup_translations("custom_file_fialog")


class CfdConfigManager:
    """
    Manages CFD-specific settings using a JSON file for flexibility.
    """
    _config = None
    _config_file = AppConfig.CONFIG_DIR / "cfd_settings.json"
    _default_settings = {
        "search_icon_pos": "left",     # 'left' or 'right'
        "button_box_pos": "left",      # 'left' or 'right'
        "window_size_preset": "1050x850",  # e.g., "1050x850"
        "default_view_mode": "icons"    # 'icons' or 'list'
    }

    @classmethod
    def _ensure_config_file(cls):
        """Ensures the config file exists with default values if not present."""
        if not cls._config_file.exists():
            try:
                cls._config_file.parent.mkdir(parents=True, exist_ok=True)
                with open(cls._config_file, 'w', encoding='utf-8') as f:
                    json.dump(cls._default_settings, f, indent=4)
            except IOError as e:
                print(f"Error creating default settings file: {e}")

    @classmethod
    def load(cls):
        """Loads settings from the JSON file, applying defaults for missing keys."""
        cls._ensure_config_file()
        if cls._config is None:
            try:
                with open(cls._config_file, 'r', encoding='utf-8') as f:
                    loaded_config = json.load(f)
                # Merge with defaults to ensure all keys are present
                cls._config = cls._default_settings.copy()
                cls._config.update(loaded_config)
            except (IOError, json.JSONDecodeError):
                cls._config = cls._default_settings.copy()
        return cls._config

    @classmethod
    def save(cls, settings):
        """Saves the given settings dictionary to the JSON file."""
        try:
            with open(cls._config_file, 'w', encoding='utf-8') as f:
                json.dump(settings, f, indent=4)
            cls._config = settings  # Update cached config
        except IOError as e:
            print(f"Error saving settings: {e}")


class Msg:

    STR: Dict[str, str] = {
        # Strings for messages

    }
    TTIP: Dict[str, str] = {
        # Strings for Tooltips

    }