loris/lib/business_logic/settings.dart

import 'package:flutter/painting.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../business_logic/auth/oauth.dart' as oauth;

class AccountSettings {
  final String identity;
  late String instanceUrl;
  static const String instanceUrlKey = "instance-url";
  late String authCode;
  static const String authCodeKey = "authcode";
  late String clientSecret;
  static const clientSecretKey = "client-secret";
  late String clientId;
  static const clientIdKey = "client-id";
  late String token;
  static const tokenKey = "access-token";
  late SharedPreferences prefs;

  AccountSettings._create(this.identity);

  static Future<AccountSettings> create(String identity) async {
    AccountSettings settings = AccountSettings._create(identity);
    settings.prefs = await SharedPreferences.getInstance();
    settings.clientSecret =
        settings.prefs.getString("${settings.identity}.$clientSecretKey") ?? "";
    settings.clientId =
        settings.prefs.getString("${settings.identity}.$clientIdKey") ?? "";
    settings.token =
        settings.prefs.getString("${settings.identity}.$tokenKey") ?? "";
    settings.instanceUrl =
        settings.prefs.getString("${settings.identity}.$instanceUrlKey") ??
            "example.com";
    settings.authCode =
        settings.prefs.getString("${settings.identity}.$authCodeKey") ?? "";
    return settings;
  }

  Future<void> delete() async {
    await prefs.remove("$identity.$instanceUrlKey");
    await prefs.remove("$identity.$authCodeKey");
    await prefs.remove("$identity.$clientSecretKey");
    await prefs.remove("$identity.$clientIdKey");
    await prefs.remove("$identity.$tokenKey");
  }

  Future<bool> saveInstanceUrl(String url) async {
    instanceUrl = url;
    return await prefs.setString("$identity.$instanceUrlKey", url);
  }

  Future<bool> saveAuthCode(String code) async {
    authCode = code;
    return await prefs.setString("$identity.$authCodeKey", code);
  }

  Future<void> saveApp(oauth.App app) async {
    clientId = app.clientId;
    clientSecret = app.clientSecret;
    await prefs.setString("$identity.$clientSecretKey", app.clientSecret);
    await prefs.setString("$identity.$clientIdKey", app.clientId);
  }

  Future<bool> saveToken(String token) async {
    this.token = token;
    return await prefs.setString("$identity.$tokenKey", token);
  }
}

class Settings {
  late Locale locale;
  static const localeKey = "active-locale";
  late int batchSize;
  static const batchSizeKey = "post-batch-size";
  late Map<String, AccountSettings> identities = {};
  static const identitiesKey = "identities";
  late String activeIdentity = "";
  static const activeIdentityKey = "active-identity";
  late SharedPreferences prefs;

  Settings._create();

  static Future<Settings> create() async {
    Settings settings = Settings._create();

    settings.prefs = await SharedPreferences.getInstance();
    settings.locale = Locale(settings.prefs.getString(localeKey) ?? "en");

    settings.batchSize = settings.prefs.getInt(batchSizeKey) ?? 20;
    if (settings.batchSize < 5) {
      settings.batchSize = 5;
    }

    List<String> identityList =
        settings.prefs.getStringList(identitiesKey) ?? [];
    settings.identities = {};
    for (int i = 0; i < identityList.length; i++) {
      settings.identities.addAll(
          {identityList[i]: await AccountSettings.create(identityList[i])});
    }
    settings.activeIdentity = settings.prefs.getString(activeIdentityKey) ?? "";

    return settings;
  }

  Future<bool> addNewIdentity(String key) async {
    List<String> a = identities.keys.toList();
    a.removeWhere((element) {
      return element == key;
    });
    a.add(key);
    identities.addAll({key: await AccountSettings.create(key)});

    return prefs.setStringList(identitiesKey, a);
  }

  Future<bool> saveLocale(String locale) async {
    this.locale = Locale(locale);
    return await prefs.setString(localeKey, locale);
  }

  Future<bool> saveActiveIdentity(String identity) {
    activeIdentity = identity;
    return prefs.setString(activeIdentityKey, identity);
  }

  Future<bool> saveBatchSize(int size) async {
    batchSize = size;
    return await prefs.setInt(batchSizeKey, size);
  }

  Future<bool> removeIdentity(String key) async {
    await identities[key]!.delete();
    identities.remove(key);
    if (identities.isNotEmpty) {
      activeIdentity = identities.keys.first;
    }
    return await prefs.setStringList(
      identitiesKey,
      identities.keys.toList(),
    );
  }
}