import { BaseStorage, FindOptions } from './base-storage.js';
import { StorageMemory } from './storage-memory.js';

/**
 * Storage Adapter that takes another Storage Adapter (e.g. IndexedDB) and "syncs" its contents to system memory for faster read access.
 *
 * All read operations will use system memory - all write operations will use the provided adapter.
 */
export class StorageMemorySynced<T extends Record<string, any> = Record<string, any>> extends BaseStorage<T> {
  constructor(
    private inMemoryCache: StorageMemory<T>,
    private store: BaseStorage<T>,
  ) {
    super();

    // Hook into all write operations so that we can sync the In-Memory cache.
    this.store.on('insert', async (payload) => {
      await this.inMemoryCache.insertOne(payload.value);
      this.emit('insert', payload);
    });

    this.store.on('update', async (payload) => {
      // For update events, we need to find and update the document in memory
      // Since we don't have the filter, we'll update by key
      const filter = {
        id: payload.value.id,
      } as unknown as Partial<T>

      // Update the document in memory by ID.
      await this.inMemoryCache.updateOne(filter, payload.value);
      this.emit('update', payload);
    });

    this.store.on('delete', async (payload) => {
      await this.inMemoryCache.deleteOne(payload.value);

      // Re-emit the delete event with the original payload.
      this.emit('delete', payload);
    });

    this.store.on('clear', async () => {
      // Clear all documents from memory cache
      await this.inMemoryCache.deleteMany({});

      // Re-emit the clear event with the original payload.
      this.emit('clear', undefined);
    });
  }

  static async create<T extends Record<string, any>>(store: BaseStorage<T>) {
    // Instantiate in-memory cache and the backing store.
    const inMemoryCache = new StorageMemory<T>();

    // Create instance of this store.
    const memorySyncedStore = new StorageMemorySynced<T>(inMemoryCache, store);

    // Sync the data from the backing store into the In-Memory cache.
    const allDocuments = await store.find();
    for (const document of allDocuments) {
      await inMemoryCache.insertOne(document);
    }

    // Return our instance of this store.
    return memorySyncedStore;
  }

  async insertMany(documents: Array<T>): Promise<void> {
    await this.store.insertMany(documents);
  }

  async find(filter?: Partial<T>, options?: FindOptions): Promise<T[]> {
    return await this.inMemoryCache.find(filter, options);
  }

  async updateMany(
    filter: Partial<T>,
    update: Partial<T>,
    options: FindOptions = {} as FindOptions
  ): Promise<number> {
    return await this.store.updateMany(filter, update, options);
  }

  async deleteMany(filter: Partial<T>, options: FindOptions = {} as FindOptions): Promise<number> {
    return await this.store.deleteMany(filter, options);
  }

  deriveChild<C extends Record<string, any>>(path: string): BaseStorage<C> {
    const childStore = this.store.deriveChild<C>(path);
    const childMemory = this.inMemoryCache.deriveChild<C>(path);
    
    // Create a new synced storage for the child
    return new StorageMemorySynced<C>(childMemory as StorageMemory<C>, childStore);
  }
}