youtube_personal/lib/services/app_settings_service.dart

import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'preferred_language_service.dart';

class AppSettingsService {
  AppSettingsService._();

  static final AppSettingsService instance = AppSettingsService._();

  static const String _defaultResolutionKey =
      'youtube_personal.settings.default_resolution.v1';
  static const String _preferredLanguageKey =
      'youtube_personal.settings.preferred_language.v1';
  static const String _youngAudienceFilterKey =
      'youtube_personal.settings.young_audience_filter.v1';
  static const String _pauseScreenSleepMinutesKey =
      'youtube_personal.settings.pause_screen_sleep_minutes.v1';
  static const String _appearanceModeKey =
      'youtube_personal.settings.appearance_mode.v1';

  static const int historicalDefaultResolution = 1080;

  final SharedPreferencesAsync _preferences = SharedPreferencesAsync();

  final ValueNotifier<int> defaultResolution =
      ValueNotifier<int>(historicalDefaultResolution);

  final ValueNotifier<String> preferredLanguage =
      ValueNotifier<String>('auto');

  final ValueNotifier<int> youngAudienceFilterLevel =
      ValueNotifier<int>(0);

  final ValueNotifier<int> pauseScreenSleepMinutes =
      ValueNotifier<int>(5);

  final ValueNotifier<String> appearanceMode =
      ValueNotifier<String>('light');

  Future<void> initialize() async {
    final storedResolution = await _preferences.getInt(_defaultResolutionKey);
    final storedLanguage = await _preferences.getString(_preferredLanguageKey);
    final storedYoungAudienceFilter =
        await _preferences.getInt(_youngAudienceFilterKey);
    final storedPauseScreenSleepMinutes =
        await _preferences.getInt(_pauseScreenSleepMinutesKey);
    final storedAppearanceMode =
        await _preferences.getString(_appearanceModeKey);

    if (storedResolution != null &&
        supportedResolutions.contains(storedResolution)) {
      defaultResolution.value = storedResolution;
    }

    if (storedLanguage != null &&
        PreferredLanguageService.isSupported(storedLanguage)) {
      preferredLanguage.value = storedLanguage;
    }

    if (storedYoungAudienceFilter != null &&
        supportedYoungAudienceFilterLevels
            .contains(storedYoungAudienceFilter)) {
      youngAudienceFilterLevel.value = storedYoungAudienceFilter;
    }

    if (storedPauseScreenSleepMinutes != null &&
        supportedPauseScreenSleepMinutes
            .contains(storedPauseScreenSleepMinutes)) {
      pauseScreenSleepMinutes.value = storedPauseScreenSleepMinutes;
    }

    if (storedAppearanceMode != null &&
        supportedAppearanceModes.contains(storedAppearanceMode)) {
      appearanceMode.value = storedAppearanceMode;
    }
  }

  Future<void> setAppearanceMode(String mode) async {
    if (!supportedAppearanceModes.contains(mode)) {
      return;
    }
    if (appearanceMode.value == mode) {
      return;
    }
    appearanceMode.value = mode;
    await _preferences.setString(_appearanceModeKey, mode);
  }

  Future<void> setDefaultResolution(int resolution) async {
    if (!supportedResolutions.contains(resolution)) {
      return;
    }

    if (defaultResolution.value == resolution) {
      return;
    }

    defaultResolution.value = resolution;
    await _preferences.setInt(_defaultResolutionKey, resolution);
  }

  Future<void> setPreferredLanguage(String languageCode) async {
    if (!PreferredLanguageService.isSupported(languageCode)) {
      return;
    }

    if (preferredLanguage.value == languageCode) {
      return;
    }

    preferredLanguage.value = languageCode;
    await _preferences.setString(_preferredLanguageKey, languageCode);
  }

  Future<void> setPauseScreenSleepMinutes(int minutes) async {
    if (!supportedPauseScreenSleepMinutes.contains(minutes)) {
      return;
    }

    if (pauseScreenSleepMinutes.value == minutes) {
      return;
    }

    pauseScreenSleepMinutes.value = minutes;
    await _preferences.setInt(_pauseScreenSleepMinutesKey, minutes);
  }

  Future<void> setYoungAudienceFilterLevel(int level) async {
    if (!supportedYoungAudienceFilterLevels.contains(level)) {
      return;
    }

    if (youngAudienceFilterLevel.value == level) {
      return;
    }

    youngAudienceFilterLevel.value = level;
    await _preferences.setInt(_youngAudienceFilterKey, level);
  }

  static const List<String> supportedAppearanceModes = <String>[
    'auto',
    'dark',
    'light',
    'system',
  ];

  static String appearanceModeLabel(String mode) {
    return switch (mode) {
      'dark' => 'Sombre',
      'light' => 'Clair',
      'auto' => 'Auto (jour/nuit)',
      _ => 'Système',
    };
  }

  static const List<int> supportedPauseScreenSleepMinutes = <int>[
    2,
    5,
    10,
    0,
  ];

  static String pauseScreenSleepLabel(int minutes) {
    return switch (minutes) {
      0 => 'Jamais',
      2 => '2 minutes',
      10 => '10 minutes',
      _ => '5 minutes',
    };
  }

  static const List<int> supportedYoungAudienceFilterLevels = <int>[
    0,
    1,
    2,
  ];

  static String youngAudienceFilterLabel(int level) {
    return switch (level) {
      1 => 'Modéré',
      2 => 'Strict',
      _ => 'Désactivé',
    };
  }

  static const List<int> supportedResolutions = <int>[
    0,
    360,
    720,
    1080,
    1440,
    2160,
  ];

  static String resolutionLabel(int resolution) {
    return switch (resolution) {
      0 => 'Auto',
      2160 => '2160p (4K)',
      _ => '${resolution}p',
    };
  }
}