trestle.core.beta_features

def beta_feature(feature_name: str) -> Callable[[BetaCallable], BetaCallable]:
    """Decorate a command run method so it requires an enabled beta feature."""

    def decorator(func: BetaCallable) -> BetaCallable:
        @functools.wraps(func)
        def wrapper(self: Any, args: Any, *func_args: Any, **func_kwargs: Any) -> int:
            trestle_root = pathlib.Path(getattr(args, 'trestle_root', pathlib.Path.cwd()))
            feature = get_beta_feature(feature_name)
            if getattr(args, 'beta', False) or feature_name in get_enabled_features(trestle_root):
                return func(self, args, *func_args, **func_kwargs)

            self.out(f"Error: The '{self.name}' command is a beta feature and is not enabled.")
            self.out('')
            self.out(f'Feature: {feature.name}')
            self.out(f'Description: {feature.description}')
            self.out(f'Stability: {feature.stability}')
            if feature.documentation_url:
                self.out(f'Documentation: {feature.documentation_url}')
            self.out('')
            self.out('To enable this feature, run:')
            self.out(f'  trestle beta enable {feature.name}')
            return CmdReturnCodes.COMMAND_ERROR.value

        setattr(wrapper, BETA_FEATURE_ATTR, feature_name)
        return cast(BetaCallable, wrapper)

    return decorator

def disable_all_features(trestle_root: pathlib.Path) -> int:
    """Disable every config-enabled beta feature and return the number changed."""
    config_path = get_beta_config_path(trestle_root)
    enabled_features = _read_config_enabled_features(config_path)
    configured_features = set(BETA_FEATURES).intersection(enabled_features)
    if configured_features:
        _write_config_enabled_features(config_path, enabled_features.difference(configured_features))
    return len(configured_features)

def disable_feature(feature_name: str, trestle_root: pathlib.Path) -> bool:
    """Disable a beta feature in the selected config file and return True if it changed."""
    feature = get_beta_feature(feature_name)
    if feature.enabled_by_default:
        raise TrestleError(f"Beta feature '{feature_name}' is enabled by default and cannot be disabled.")
    if feature_name in _read_environment_enabled_features():
        raise TrestleError(
            f"Beta feature '{feature_name}' is enabled by {TRESTLE_BETA_FEATURES_ENV}. "
            f'Remove it from {TRESTLE_BETA_FEATURES_ENV} to disable it.'
        )

    config_path = get_beta_config_path(trestle_root)
    enabled_features = _read_config_enabled_features(config_path)

    if feature_name not in enabled_features:
        return False

    enabled_features.remove(feature_name)
    _write_config_enabled_features(config_path, enabled_features)
    return True

def enable_all_features(trestle_root: pathlib.Path) -> int:
    """Enable every registered beta feature and return the number changed."""
    config_path = get_beta_config_path(trestle_root)
    enabled_features = _read_config_enabled_features(config_path)
    newly_enabled = set(BETA_FEATURES).difference(enabled_features)
    if newly_enabled:
        _write_config_enabled_features(config_path, enabled_features.union(newly_enabled))
    return len(newly_enabled)

def enable_feature(feature_name: str, trestle_root: pathlib.Path) -> bool:
    """Enable a beta feature in the selected config file and return True if it changed."""
    get_beta_feature(feature_name)
    config_path = get_beta_config_path(trestle_root)
    enabled_features = _read_config_enabled_features(config_path)

    if feature_name in enabled_features:
        return False

    enabled_features.add(feature_name)
    _write_config_enabled_features(config_path, enabled_features)
    return True

def get_beta_config_path(trestle_root: pathlib.Path) -> pathlib.Path:
    """Get the beta config path for a trestle workspace path or the user fallback."""
    workspace_root = file_utils.extract_trestle_project_root(pathlib.Path(trestle_root).resolve())
    if workspace_root is not None:
        return workspace_root / const.TRESTLE_CONFIG_DIR / const.TRESTLE_CONFIG_FILE
    return get_user_beta_config_path()

def get_beta_feature(feature_name: str) -> BetaFeature:
    """Get a registered beta feature by name."""
    try:
        return BETA_FEATURES[feature_name]
    except KeyError:
        raise TrestleError(f"Beta feature '{feature_name}' not found.")

def get_beta_feature_name(command_callable: Callable[..., Any]) -> Optional[str]:
    """Get the beta feature name from a decorated command callable if present."""
    feature_name = getattr(command_callable, BETA_FEATURE_ATTR, None)
    if feature_name is not None:
        return cast(str, feature_name)
    bound_function = getattr(command_callable, '__func__', None)
    return cast(Optional[str], getattr(bound_function, BETA_FEATURE_ATTR, None))

def get_enabled_features(trestle_root: pathlib.Path) -> Set[str]:
    """Get registered beta features enabled for the given trestle root."""
    enabled_features = _read_config_enabled_features(get_beta_config_path(trestle_root))
    enabled_features.update(_read_environment_enabled_features())

    for feature_name, feature in BETA_FEATURES.items():
        if feature.enabled_by_default:
            enabled_features.add(feature_name)

    return {feature_name for feature_name in enabled_features if feature_name in BETA_FEATURES}

def get_registered_features() -> Dict[str, BetaFeature]:
    """Get all registered beta features."""
    return BETA_FEATURES

def get_user_beta_config_path() -> pathlib.Path:
    """Get the user-level beta feature config path."""
    if os.name == 'nt':  # pragma: no cover
        appdata = os.environ.get('APPDATA')
        config_root = pathlib.Path(appdata) if appdata else pathlib.Path.home() / 'AppData' / 'Roaming'
    else:
        config_root = pathlib.Path(os.environ.get('XDG_CONFIG_HOME', pathlib.Path.home() / '.config'))
    return config_root / 'trestle' / 'beta.ini'

def is_beta_enabled(feature_name: str, trestle_root: pathlib.Path) -> bool:
    """Return True if the beta feature is registered and enabled."""
    get_beta_feature(feature_name)
    return feature_name in get_enabled_features(trestle_root)

def parse_feature_names(feature_names: str) -> Set[str]:
    """Parse comma and whitespace separated beta feature names."""
    normalized_feature_names = feature_names.replace(',', ' ')
    return {name.strip() for name in normalized_feature_names.split() if name.strip()}