DataSource.ts

import PouchDB from 'pouchdb';
import pouchdbFind from 'pouchdb-find';
import { ContextRepository } from '@/data/ContextRepository';
import { DocumentTypes } from '@/data/documentTypes';
import { LocalSettings } from '@/data/documentTypes/LocalSettings';
import { PreferencesRepository } from '@/data/PreferencesRepository';
import { TaskRepository } from '@/data/TaskRepository';
import { Logger } from '@/helpers/Logger';
import { MigrationManager } from './migrations/MigrationManager';

export enum SyncStatus {
  NOT_CONFIGURED = 'not_configured',
  INACTIVE = 'inactive',
  ACTIVE = 'active',
  PAUSED = 'paused',
  ERROR = 'error',
}

export class DataSource {
  protected db: PouchDB.Database<DocumentTypes>;

  private migrationManager: MigrationManager;
  private syncHandler: PouchDB.Replication.Sync<{}> | null = null;
  private taskRepository: TaskRepository | null = null;
  private contextRepository: ContextRepository | null = null;
  private preferencesRepository: PreferencesRepository | null = null;

  public onMigrationStatusChange?: (isMigrating: boolean) => void;
  public onSyncStatusChange?: (status: SyncStatus) => void;
  public syncStatus: SyncStatus = SyncStatus.NOT_CONFIGURED;

  /**
   * Creates a new LocalDataSource instance.
   * If a database is provided, it will use that database; otherwise, it will create a new
   * PouchDB instance.
   *
   * @param database Optional PouchDB database instance to use.
   * @param migrationManager Optional MigrationManager instance to use for migrations.
   */
  constructor(database: PouchDB.Database<DocumentTypes>, migrationManager?: MigrationManager) {
    this.db = database;

    PouchDB.plugin(pouchdbFind);

    if (migrationManager) {
      this.migrationManager = migrationManager;
    } else {
      this.migrationManager = new MigrationManager(this.db);
    }
  }

  /**
   * Get the PouchDB database instance.
   */
  getDatabase(): PouchDB.Database<DocumentTypes> {
    return this.db;
  }

  /**
   * Cleanup all active subscriptions and resources.
   * This should be called when the DataSource instance is no longer needed
   * to prevent memory leaks and ensure proper cleanup of PouchDB change feeds.
   */
  async cleanup(): Promise<void> {
    Logger.info('Cleaning up DataSource');

    await this.getTaskRepository().cleanup();
    await this.getContextRepository().cleanup();

    Logger.info('DataSource cleanup completed');
  }

  /**
   * Create/return the TaskRepository singleton
   */
  getTaskRepository(): TaskRepository {
    if (!this.taskRepository) {
      this.taskRepository = new TaskRepository(this.db);
    }

    return this.taskRepository;
  }

  /**
   * Create/return the ContextRepository singleton
   */
  getContextRepository(): ContextRepository {
    if (!this.contextRepository) {
      this.contextRepository = new ContextRepository(this.db);
    }

    return this.contextRepository;
  }

  /**
   * Create/return the PreferencesRepository singleton
   */
  getPreferencesRepository(): PreferencesRepository {
    if (!this.preferencesRepository) {
      this.preferencesRepository = new PreferencesRepository(this.db);
    }

    return this.preferencesRepository;
  }

  /**
   * Initialize the sync process with the remote server.
   */
  async initializeSync() {
    Logger.info('Initializing sync');
    const settings = await this.getLocalSettings();

    if (!settings.syncServerUrl || !settings.syncServerAccessToken) {
      Logger.info('No sync server settings found, skipping sync setup');
      this.setSyncStatus(SyncStatus.NOT_CONFIGURED);
      return;
    }

    const syncDb = this.createSyncDb(settings);
    await this.verifySyncConnection(syncDb);

    try {
      this.syncHandler = this.db
        .sync(syncDb, {
          live: true,
          retry: true,
        })
        .on('change', (info) => {
          Logger.info('Sync change:', info);
          this.setSyncStatus(SyncStatus.ACTIVE);
        })
        .on('paused', () => {
          Logger.info('Sync paused (up to date)');
          this.setSyncStatus(SyncStatus.PAUSED);
        })
        .on('active', () => {
          Logger.info('Sync resumed');
          this.setSyncStatus(SyncStatus.ACTIVE);
        })
        .on('denied', (err) => {
          Logger.error('Sync denied:', err);
          this.setSyncStatus(SyncStatus.ERROR);
        })
        .on('complete', (info) => {
          Logger.info('Sync complete:', info);
          this.setSyncStatus(SyncStatus.INACTIVE);
        })
        .on('error', (err) => {
          Logger.error('Error replicating to remote database:', err);
          this.setSyncStatus(SyncStatus.ERROR);
        });
    } catch (error) {
      Logger.error('Error initializing sync:', error);
      this.cancelSync();
      this.setSyncStatus(SyncStatus.ERROR);
      throw error; // Re-throw to handle it in the calling code
    }
  }

  /**
   * Create a new PouchDB database for syncing with a couchdb server.
   *
   * @param settings
   */
  createSyncDb(settings: LocalSettings): PouchDB.Database {
    Logger.info('Creating sync database');
    return new PouchDB(settings.syncServerUrl, {
      headers: {
        Authorization: `Bearer ${settings.syncServerAccessToken}`,
      },
    } as PouchDB.Configuration.DatabaseConfiguration & { headers?: Record<string, string> });
  }

  /**
   * Cancels the current sync operation if it is active.
   */
  cancelSync() {
    Logger.info('Cancelling sync');
    if (this.syncHandler) {
      this.syncHandler.cancel();
      this.syncHandler = null;
      if (this.syncStatus !== SyncStatus.ERROR) {
        this.setSyncStatus(SyncStatus.INACTIVE);
      }
    } else {
      Logger.info('No active sync to cancel');
    }
  }

  /**
   * Run any pending migrations.
   */
  async runMigrations(): Promise<void> {
    if (!(await this.migrationManager.needsMigration())) {
      return;
    }

    try {
      this.onMigrationStatusChange?.(true);
      await this.migrationManager.runMigrations();
    } finally {
      this.onMigrationStatusChange?.(false);
    }
  }

  /**
   * Get the local settings from the database. These settings are not synced to the server
   *
   */
  async getLocalSettings(): Promise<LocalSettings> {
    try {
      Logger.info('Getting local settings');
      return await this.db.get<LocalSettings>('_local/settings');
    } catch (error) {
      if (this.isPouchNotFoundError(error)) {
        // If the document does not exist, return default settings
        Logger.info('Local settings not found, returning default settings');
        return {
          _id: '_local/settings',
        };
      }
      Logger.error('Error getting local settings:', error);
      throw error;
    }
  }

  /**
   * Set the local settings in the database. These will never be synced to the server.
   *
   * @param settings
   */
  async setLocalSettings(settings: LocalSettings): Promise<void> {
    try {
      Logger.info('Setting local settings');
      await this.db.put<LocalSettings>(settings);
    } catch (error) {
      Logger.error('Error setting local settings:', error);
      throw error; // Re-throw to handle it in the calling code
    }
  }

  /**
   * Export all data from the database, excluding _local documents.
   */
  async exportAllData(): Promise<DocumentTypes[]> {
    Logger.info('Exporting all data from the database');
    try {
      const result = await this.db.allDocs<DocumentTypes>({
        include_docs: true,
      });

      return result.rows.map((row) => row.doc!);
    } catch (error) {
      Logger.error('Error exporting data:', error);
      throw error;
    }
  }

  /**
   * Import data into the database.
   * @param docs
   */
  async importData(docs: DocumentTypes[]): Promise<void> {
    Logger.info('Importing data into the database');
    try {
      // We probably don't want to allow _local documents to be imported, as it
      // can activate sync
      const filteredDocs = docs.filter((doc) => !doc._id.startsWith('_local/'));

      const cleanedDocs = filteredDocs.map((doc) => {
        const { _rev, ...cleanDoc } = doc as any;
        return cleanDoc;
      });

      await this.db.bulkDocs(cleanedDocs);
      Logger.info('Data imported successfully:');
    } catch (error) {
      Logger.error('Error importing data:', error);
      throw error; // Re-throw to handle it in the calling code
    }
  }

  private async verifySyncConnection(syncDb: PouchDB.Database): Promise<void> {
    try {
      await syncDb.info();
    } catch (error) {
      this.setSyncStatus(SyncStatus.ERROR);
      Logger.error('Error connecting to sync database:', error);
      throw new Error(
        'Failed to connect to sync database. Please check your sync server URL and access token.'
      );
    }
  }

  // Is the error a PouchDB not found error?
  /**
   * Check if sync is configured.
   */
  async isSyncConfigured(): Promise<boolean> {
    const settings = await this.getLocalSettings();
    return !!settings.syncServerUrl;
  }

  private setSyncStatus(status: SyncStatus) {
    if (this.syncStatus !== status) {
      this.syncStatus = status;
      this.onSyncStatusChange?.(this.syncStatus);
    }
  }

  // Is the error a PouchDB not found error?
  private isPouchNotFoundError(err: any): err is PouchDB.Core.Error {
    return err && (err.status === 404 || err.name === 'not_found');
  }
}