Inceptum/launcher/src/main/java/io/gitlab/jfronny/inceptum/launcher/api/account/AccountManager.java

package io.gitlab.jfronny.inceptum.launcher.api.account;

import io.gitlab.jfronny.commons.io.JFiles;
import io.gitlab.jfronny.commons.serialize.gson.api.GsonHolder;
import io.gitlab.jfronny.gson.reflect.TypeToken;
import io.gitlab.jfronny.inceptum.launcher.LauncherEnv;
import io.gitlab.jfronny.inceptum.common.*;

import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

public class AccountManager {
    private static final Type abstractAccountListType = new TypeToken<List<MicrosoftAccount>>() {}.getType();
    private static MicrosoftAccount SELECTED_ACCOUNT;
    private static final List<MicrosoftAccount> ACCOUNTS = new ArrayList<>();
    public static final AuthInfo NULL_AUTH = new AuthInfo("Joe", "2536abce90e8476a871679918164abc5", "99abe417230342cb8e9e2168ab46297a", "legacy");

    public static AuthInfo getSelectedAccount() {
        if (SELECTED_ACCOUNT == null) return NULL_AUTH;
        else if (SELECTED_ACCOUNT.ensureAccessTokenValid()) return new AuthInfo(SELECTED_ACCOUNT);
        else {
            Utils.LOGGER.error("Couldn't login properly, using offline mode");
            return NULL_AUTH;
        }
    }

    public static boolean accountMissing() {
        return ACCOUNTS.isEmpty();
    }

    public static List<MicrosoftAccount> getAccounts() {
        return List.copyOf(ACCOUNTS);
    }

    public static int getSelectedIndex() {
        if (SELECTED_ACCOUNT == null) return ACCOUNTS.size();
        return ACCOUNTS.indexOf(SELECTED_ACCOUNT);
    }

    public static void saveAccounts() {
        try {
            JFiles.writeObject(MetaHolder.ACCOUNTS_PATH, ACCOUNTS);
        } catch (IOException e) {
            Utils.LOGGER.error("Could not save accounts", e);
        }
    }

    public static void loadAccounts() {
        Utils.LOGGER.info("Loading accounts");
        if (Files.exists(MetaHolder.ACCOUNTS_PATH)) {
            try {
                ACCOUNTS.addAll(JFiles.readObject(MetaHolder.ACCOUNTS_PATH, abstractAccountListType));
            } catch (IOException e) {
                Utils.LOGGER.error("Could not load accounts", e);
            }
        }
        for (MicrosoftAccount account : ACCOUNTS) {
            account.refreshAccessToken();
            if (account.accountId.equalsIgnoreCase(InceptumConfig.lastAccount)) {
                SELECTED_ACCOUNT = account;
            }
        }
        Utils.LOGGER.info("Finished loading accounts");
    }

    public static void addAccount(MicrosoftAccount account) {
        ACCOUNTS.add(account);
        if (ACCOUNTS.size() > 1) {
            LauncherEnv.showOkCancel("Account added successfully. Switch to it now?", "Success", () -> switchAccount(account), R::nop);
        } else switchAccount(account);
        saveAccounts();
    }

    public static void removeAccount(MicrosoftAccount account) {
        if (SELECTED_ACCOUNT == account) {
            if (ACCOUNTS.size() == 1)
                switchAccount(null);
            else
                switchAccount(ACCOUNTS.get(0));
        }
        ACCOUNTS.remove(account);
        saveAccounts();
    }

    public static void switchAccount(MicrosoftAccount account) {
        if (account == null) {
            Utils.LOGGER.info("Logging out");
            SELECTED_ACCOUNT = null;
            InceptumConfig.lastAccount = null;
        } else {
            Utils.LOGGER.info("Changed account to " + account);
            SELECTED_ACCOUNT = account;
            InceptumConfig.lastAccount = account.accountId;
        }
        InceptumConfig.saveConfig();
    }

    public static Object getAccountByName(String username) {
        for (MicrosoftAccount account : ACCOUNTS) {
            if (account.accountId.equalsIgnoreCase(username))
                return account;
        }
        return null;
    }

    public static boolean isAccountByName(String username) {
        for (MicrosoftAccount account : ACCOUNTS) {
            if (account.accountId.equalsIgnoreCase(username))
                return true;
        }
        return false;
    }
}