loris/lib/business_logic/settings.dart

import 'package:flutter/painting.dart';
import 'package:loris/themes/themes.dart';
import 'package:shared_preferences/shared_preferences.dart';
import './websocket.dart' as websocket;
import 'package:loris/themes/themes.dart' as themes;

class AccountSettings {
  final String identity;
  late String instanceUrl;
  static const String instanceUrlKey = "instance-url";
  late String webSocketUrl = "";
  static const String webSocketUrlKey = "web-socket";
  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.webSocketUrl =
        settings.prefs.getString("${settings.identity}.$webSocketUrlKey") ?? "";
    settings.authCode =
        settings.prefs.getString("${settings.identity}.$authCodeKey") ?? "";
    return settings;
  }

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

  Future<bool> saveWebsocketUrl(String url) async {
    webSocketUrl = url;
    var p = await prefs.setString("$identity.$webSocketUrlKey", url);
    websocket.reloadWebsockets();
    return p;
  }

  Map<String, String> getAuthHeaders() {
    return {"Authorization": "Bearer $token"};
  }

  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(String clientSecret, String clientId) async {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    await prefs.setString("$identity.$clientSecretKey", clientSecret);
    await prefs.setString("$identity.$clientIdKey", clientId);
  }

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

class Settings {
  static const currentClientSecretKey = "currentsecret";
  late String currentClientSecret;
  static const currentClientIdkey = "currentclientid";
  late String currentClientId;
  late double postWidth = 0.8;
  static const postWidthKey = "post-width";
  late double maxPostWidth = 1000;
  static const maxPostWidthKey = "max-post-width";
  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;
  static const themeKey = "theme";
  late CustomColors theme;

  Settings._create();

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

    settings.prefs = await SharedPreferences.getInstance();

    settings.currentClientSecret =
        settings.prefs.getString(currentClientSecretKey) ?? "";
    settings.currentClientId =
        settings.prefs.getString(currentClientIdkey) ?? "";
    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) ?? "";
    if (!settings.identities.containsKey(settings.activeIdentity) &&
        settings.identities.isNotEmpty) {
      settings.activeIdentity = settings.identities.keys.first;
    }

    settings.postWidth = settings.prefs.getDouble(postWidthKey) ?? 0.8;
    settings.maxPostWidth = settings.prefs.getDouble(maxPostWidthKey) ?? 1000;

    final themename = settings.prefs.getString(themeKey);
    settings.theme = themes.available.firstWhere(
      (element) => element.name == themename,
      orElse: () => themes.available[0],
    );

    return settings;
  }

  Future<bool> saveTheme(String name) async {
    theme = themes.available.firstWhere(
      (element) => element.name == name,
    );
    return prefs.setString(themeKey, name);
  }

  Future<bool> saveMaxPostWidth(double width) {
    maxPostWidth = width;
    return prefs.setDouble(maxPostWidthKey, width);
  }

  Future<bool> saveCurrentClientId(String id) async {
    currentClientId = id;
    return prefs.setString(currentClientIdkey, id);
  }

  Future<bool> saveCurrentClientSecret(String secret) async {
    currentClientId = secret;
    return prefs.setString(currentClientSecretKey, secret);
  }

  Future<bool> savePostWidth(double width) {
    postWidth = width;
    return prefs.setDouble(postWidthKey, width);
  }

  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)});
    var p = await prefs.setStringList(identitiesKey, a);
    return p;
  }

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

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

  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) {
      await saveActiveIdentity(identities.keys.first);
    }
    var p = await prefs.setStringList(
      identitiesKey,
      identities.keys.toList(),
    );
    websocket.reloadWebsockets();
    return p;
  }
}