import { StorageType } from './interfaces/index.js';

export * from "./interfaces/index.js";

export class CacheManager {
    /**
     * Nome da chave utilizada para armazenar o cache no armazenamento.
     */
    private static readonly storageKey = 'cacheManager';

    /**
     * Estrutura de armazenamento em memória.
     */
    private static inMemoryCache = new Map<string, any>();

    /**
     * Recupera ou define o valor no cache.
     *
     * @param key Identificador único para armazenar e recuperar o valor.
     * @param fetchCallback Função que retorna uma `Promise` com o valor a ser armazenado no cache caso ele não exista ou tenha expirado.
     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
     * @returns Uma `Promise` com o valor armazenado ou obtido via `fetchCallback`.
     */
    public static async getOrSet<T>(
        key: string,
        fetchCallback: () => Promise<T>,
        storageType: StorageType = StorageType.IN_MEMORY_CACHE
    ): Promise<T> {
        const cache = this.getCache(storageType);

        if (cache[key]) {
            return cache[key].data;
        }

        const data = await fetchCallback();
        cache[key] = { data };
        this.saveCache(cache, storageType);
        return data;
    }

    /**
     * Remove uma entrada específica do cache.
     *
     * @param key Identificador único da entrada a ser removida.
     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
     */
    public static clear(key: string, storageType: StorageType = StorageType.IN_MEMORY_CACHE): void {
        const cache = this.getCache(storageType);
        delete cache[key];
        this.saveCache(cache, storageType);
    }

    /**
     * Remove todas as entradas do cache.
     *
     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`. 
     */
    public static clearAll(storageType: StorageType = StorageType.IN_MEMORY_CACHE): void {
        if (storageType === StorageType.IN_MEMORY_CACHE) {
            this.inMemoryCache.clear();
        } else {
            this.getStorage(storageType).removeItem(this.storageKey);
        }
    }

    /**
     * Obtém o cache armazenado no armazenamento especificado.
     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
     * @returns Um objeto representando o cache armazenado.
     */
    private static getCache(storageType: StorageType): Record<string, any> {
        if (storageType === StorageType.IN_MEMORY_CACHE) {
            return Object.fromEntries(this.inMemoryCache);
        }

        const storage = this.getStorage(storageType);
        const cache = storage.getItem(this.storageKey);
        return cache ? JSON.parse(cache) : {};
    }

    /**
     * Salva o cache no armazenamento especificado.
     * @param cache O objeto representando o cache a ser salvo.
     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
     */
    private static saveCache(cache: Record<string, any>, storageType: StorageType): void {
        if (storageType === StorageType.IN_MEMORY_CACHE) {
            this.inMemoryCache = new Map(Object.entries(cache));
        } else {
            const storage = this.getStorage(storageType);
            storage.setItem(this.storageKey, JSON.stringify(cache));
        }
    }

    /**
     * Retorna o armazenamento correspondente ao tipo especificado.
     * @param storageType Tipo de armazenamento: `'sessionStorage'` ou `'localStorage'`.
     * @returns O objeto de armazenamento correspondente.
     */
    private static getStorage(storageType: StorageType): Storage {
        return storageType === StorageType.LOCAL_STORAGE ? localStorage : sessionStorage;
    }
}