App/api/client.ts

import { Api } from "@jellyfin/sdk/lib/api";
import { JellyfinInfo } from "./info";
import { JellifyServer } from "../types/JellifyServer";
import { JellifyUser } from "../types/JellifyUser";
import { storage } from '../constants/storage';
import { MMKVStorageKeys } from "../enums/mmkv-storage-keys";
import uuid from 'react-native-uuid';
import { JellifyLibrary } from "../types/JellifyLibrary";

export default class Client {
    static #instance: Client;

    private api : Api | undefined = undefined;
    private user : JellifyUser | undefined = undefined;
    private server : JellifyServer | undefined = undefined;
    private library : JellifyLibrary | undefined = undefined;
    private sessionId : string = uuid.v4();

    private constructor(
        api?: Api | undefined, 
        user?: JellifyUser | undefined, 
        server?: JellifyServer | undefined, 
        library?: JellifyLibrary | undefined
    ) {

        const userJson = storage.getString(MMKVStorageKeys.User)
        const serverJson = storage.getString(MMKVStorageKeys.Server);
        const libraryJson = storage.getString(MMKVStorageKeys.Library);

        if (user)
            this.setAndPersistUser(user)
        else if (userJson)
            this.user = JSON.parse(userJson)
        else
            this.user = undefined;
        
        if (server) 
            this.setAndPersistServer(server)
        else if (serverJson)
            this.server = JSON.parse(serverJson);
        else 
            this.server = undefined;
        
        if (library)
            this.setAndPersistLibrary(library)
        else if (libraryJson)
            this.library = JSON.parse(libraryJson)
        else 
            this.library = undefined;

        if (api)
            this.api = api
        else if (this.user && this.server)
            this.api = new Api(this.server.url, JellyfinInfo.clientInfo, JellyfinInfo.deviceInfo, this.user.accessToken);
        else
            this.api = undefined;
    }

    public static get instance(): Client {
        if (!Client.#instance) {
            Client.#instance = new Client();
        }

        return Client.#instance;
    }

    public static get api(): Api | undefined {
        return Client.#instance.api;
    }

    public static get server(): JellifyServer | undefined {
        return Client.#instance.server;
    }

    public static get user(): JellifyUser | undefined {
        return Client.#instance.user;
    }

    public static get library(): JellifyLibrary | undefined {
        return Client.#instance.library;
    }

    public static get sessionId(): string {
        return Client.#instance.sessionId;
    }

    public static signOut(): void {
        Client.#instance.removeCredentials()
    }

    public static switchServer() : void {
        Client.#instance.removeServer();
    }

    public static switchUser(): void {
        Client.#instance.removeUser();
    }

    public static setUser(user: JellifyUser): void {
        Client.#instance.setAndPersistUser(user);
    }

    private setAndPersistUser(user: JellifyUser) {
        this.user = user;

        // persist user details
        storage.set(MMKVStorageKeys.User, JSON.stringify(user));
    }

    private setAndPersistServer(server : JellifyServer) {
        this.server = server;

        storage.set(MMKVStorageKeys.Server, JSON.stringify(server));
    }

    private setAndPersistLibrary(library : JellifyLibrary) {
        this.library = library;

        storage.set(MMKVStorageKeys.Library, JSON.stringify(library))
    }

    private removeCredentials() {
        this.library = undefined;
        this.library = undefined;
        this.server = undefined;
        this.user = undefined;

        storage.delete(MMKVStorageKeys.Server)
        storage.delete(MMKVStorageKeys.Library)
        storage.delete(MMKVStorageKeys.User)
    }

    private removeServer() {
        this.server = undefined;

        storage.delete(MMKVStorageKeys.Server)
    }

    private removeUser() {
        this.user = undefined;

        storage.delete(MMKVStorageKeys.User)
    }

    /**
     * Uses the jellifyClient to create a public Jellyfin API instance.
     * @param serverUrl The URL of the Jellyfin server
     * @returns 
     */
    public static setPublicApiClient(server : JellifyServer) : void {
        const api = JellyfinInfo.createApi(server.url);

        Client.#instance = new Client(api, undefined, server, undefined)
    }

    /**
     * 
     * @param serverUrl The URL of the Jellyfin server
     * @param accessToken The assigned accessToken for the Jellyfin user
     */
    public static setPrivateApiClient(server : JellifyServer, user : JellifyUser) : void {
        const api = JellyfinInfo.createApi(server.url, user.accessToken);

        Client.#instance = new Client(api, user, server, undefined);
    }

    public static setLibrary(library : JellifyLibrary) : void {

        Client.#instance = new Client(undefined, undefined, undefined, library);
    }
}