// ignore_for_file: file_names

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:shared_preferences/shared_preferences.dart';

// part 'sharedPrefs.g.dart';

final sharedPreferencesProvider =
    Provider<SharedPreferences>((ref) => throw UnimplementedError());

class SharedPrefNotifier<T> extends StateNotifier<T> {
  final SharedPreferences prefs;
  final String key;
  final T defaultValue;

  SharedPrefNotifier({
    required this.prefs,
    required this.key,
    required this.defaultValue,
  }) : super(prefs.containsKey(key)
            ? _getValue<T>(prefs, key, defaultValue)
            : defaultValue);

  // Helper to get the value with proper typing
  static T _getValue<T>(SharedPreferences prefs, String key, T defaultValue) {
    if (T == String) {
      return prefs.getString(key) as T? ?? defaultValue;
    }

    if (T == bool) {
      return prefs.getBool(key) as T? ?? defaultValue;
    }

    if (T == int) {
      return prefs.getInt(key) as T? ?? defaultValue;
    }

    if (T == double) {
      return prefs.getDouble(key) as T? ?? defaultValue;
    }

    if (T == List<String>) {
      return prefs.getStringList(key) as T? ?? defaultValue;
    }

    throw UnsupportedError('Type $T not supported by SharedPreferences');
  }

  Future<void> update(T value) async {
    if (T == String) {
      await prefs.setString(key, value as String);
      state = value;
      return;
    }

    if (T == bool) {
      await prefs.setBool(key, value as bool);
      state = value;
      return;
    }

    if (T == int) {
      await prefs.setInt(key, value as int);
      state = value;
      return;
    }

    if (T == double) {
      await prefs.setDouble(key, value as double);
      state = value;
      return;
    }

    if (T == List<String>) {
      await prefs.setStringList(key, value as List<String>);
      state = value;
      return;
    }

    throw UnsupportedError('Type $T not supported by SharedPreferences');
  }
}

final isDarkModeProvider =
    StateNotifierProvider<SharedPrefNotifier<bool>, bool>((ref) {
  final prefs = ref.watch(sharedPreferencesProvider);
  return SharedPrefNotifier<bool>(
    prefs: prefs,
    key: 'is_dark_mode',
    defaultValue: false,
  );
});

enum AppThemePreference {
  system,
  light,
  dark,
}

class ThemePreferenceNotifier extends StateNotifier<AppThemePreference> {
  ThemePreferenceNotifier(this._prefs)
      : super(_themePreferenceFromStorage(_prefs.getString(_themeModeKey)));

  static const String _themeModeKey = 'app_theme_preference';

  final SharedPreferences _prefs;

  Future<void> update(AppThemePreference value) async {
    await _prefs.setString(_themeModeKey, value.name);
    state = value;
  }
}

AppThemePreference _themePreferenceFromStorage(String? value) {
  return switch (value) {
    'light' => AppThemePreference.light,
    'dark' => AppThemePreference.dark,
    _ => AppThemePreference.system,
  };
}

final appThemePreferenceProvider =
    StateNotifierProvider<ThemePreferenceNotifier, AppThemePreference>((ref) {
  final prefs = ref.watch(sharedPreferencesProvider);
  return ThemePreferenceNotifier(prefs);
});