import * as plugins from './smartchok.plugins.js';
import { Stringmap } from '@push.rocks/lik';

export type TSmartchokStatus = 'idle' | 'starting' | 'watching';
export type TFsEvent =
  | 'add'
  | 'addDir'
  | 'change'
  | 'error'
  | 'unlink'
  | 'unlinkDir'
  | 'ready'
  | 'raw';

/**
 * Smartchok allows easy wathcing of files
 */
export class Smartchok {
  public watchStringmap = new Stringmap();
  public status: TSmartchokStatus = 'idle';
  private watcher: plugins.chokidar.FSWatcher;
  private globPatterns: string[] = [];
  private globMatchers: Map<string, (path: string) => boolean> = new Map();
  private watchingDeferred = plugins.smartpromise.defer<void>(); // used to run things when watcher is initialized
  private eventObservablemap = new plugins.smartrx.Observablemap(); // register one observable per event

  /**
   * constructor of class smartchok
   */
  constructor(watchArrayArg: string[]) {
    this.watchStringmap.addStringArray(watchArrayArg);
  }

  private getGlobBase(globPattern: string) {
    // Characters that mark the beginning of a glob pattern
    const globChars = ['*', '?', '[', ']', '{', '}'];

    // Find the index of the first glob character
    const firstGlobCharIndex = globPattern.split('').findIndex((char) => globChars.includes(char));

    // If no glob characters are found, return the entire string
    if (firstGlobCharIndex === -1) {
      return globPattern;
    }

    // Extract the substring up to the first glob character
    const basePathPortion = globPattern.substring(0, firstGlobCharIndex);

    // Find the last slash before the glob pattern starts
    const lastSlashIndex = basePathPortion.lastIndexOf('/');

    // If there is no slash, return the basePathPortion as is
    if (lastSlashIndex === -1) {
      return basePathPortion;
    }

    // Return the base path up to and including the last slash
    return basePathPortion.substring(0, lastSlashIndex + 1);
  }

  /**
   * adds files to the list of watched files
   */
  public add(pathArrayArg: string[]) {
    this.watchStringmap.addStringArray(pathArrayArg);
  }

  /**
   * removes files from the list of watched files
   */
  public remove(pathArg: string) {
    this.watchStringmap.removeString(pathArg);
  }

  /**
   * gets an observable for a certain event
   */
  public getObservableFor(
    fsEvent: TFsEvent
  ): Promise<plugins.smartrx.rxjs.Observable<[string, plugins.fs.Stats]>> {
    const done = plugins.smartpromise.defer<plugins.smartrx.rxjs.Observable<any>>();
    this.watchingDeferred.promise.then(() => {
      const eventObservable = this.eventObservablemap.getSubjectForEmitterEvent(
        this.watcher,
        fsEvent
      );
      done.resolve(eventObservable);
    });
    return done.promise;
  }

  /**
   * starts the watcher
   * @returns Promise<void>
   */
  public start(): Promise<void> {
    const done = plugins.smartpromise.defer<void>();
    this.status = 'starting';
    
    // Store original glob patterns and create matchers
    this.globPatterns = this.watchStringmap.getStringArray();
    const basePaths = new Set<string>();
    
    this.globPatterns.forEach((pattern) => {
      const basePath = this.getGlobBase(pattern);
      basePaths.add(basePath);
      
      // Create a picomatch matcher for each glob pattern
      const matcher = plugins.picomatch(pattern, {
        dot: true,
        basename: false
      });
      this.globMatchers.set(pattern, matcher);
    });
    
    // Convert Set to Array for chokidar
    const watchPaths = Array.from(basePaths);
    console.log('Base paths to watch:', watchPaths);
    
    this.watcher = plugins.chokidar.watch(watchPaths, {
      persistent: true,
      ignoreInitial: false,
      followSymlinks: false,
      depth: 4,
      awaitWriteFinish: {
        stabilityThreshold: 300,
        pollInterval: 100
      },
      ignored: (path: string, stats?: plugins.fs.Stats) => {
        // Don't filter during initialization - let chokidar watch everything
        // We'll filter events as they come in
        return false;
      }
    });
    
    // Set up event handlers with glob filtering
    const fileEvents: Array<'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir'> = 
      ['add', 'addDir', 'change', 'unlink', 'unlinkDir'];
    
    // Handle file events
    fileEvents.forEach(eventName => {
      this.watcher.on(eventName, (path: string, stats?: plugins.fs.Stats) => {
        // Only emit event if the path matches our glob patterns
        if (this.shouldWatchPath(path)) {
          this.eventObservablemap.getSubjectForEmitterEvent(this.watcher, eventName)
            .next([path, stats]);
        }
      });
    });
    
    // Handle error events
    this.watcher.on('error', (error: Error) => {
      this.eventObservablemap.getSubjectForEmitterEvent(this.watcher, 'error')
        .next([error, undefined]);
    });
    
    // Handle raw events
    this.watcher.on('raw', (eventType: string, path: string, details: any) => {
      if (this.shouldWatchPath(path)) {
        this.eventObservablemap.getSubjectForEmitterEvent(this.watcher, 'raw')
          .next([path, undefined]);
      }
    });
    
    this.watcher.on('ready', () => {
      this.status = 'watching';
      this.watchingDeferred.resolve();
      done.resolve();
    });
    return done.promise;
  }

  /**
   * stop the watcher process if watching
   */
  public async stop() {
    const closeWatcher = async () => {
      await this.watcher.close();
    };
    if (this.status === 'watching') {
      console.log('closing while watching');
      await closeWatcher();
    } else if (this.status === 'starting') {
      await this.watchingDeferred.promise;
      await closeWatcher();
    }
  }
  
  /**
   * Checks if a path should be watched based on glob patterns
   */
  private shouldWatchPath(filePath: string): boolean {
    // Normalize the path - remove leading ./ if present
    let normalizedPath = filePath.replace(/\\/g, '/');
    if (normalizedPath.startsWith('./')) {
      normalizedPath = normalizedPath.substring(2);
    }
    
    // Check if the path matches any of our glob patterns
    for (const [pattern, matcher] of this.globMatchers) {
      // Also normalize the pattern for comparison
      let normalizedPattern = pattern;
      if (normalizedPattern.startsWith('./')) {
        normalizedPattern = normalizedPattern.substring(2);
      }
      
      // Try matching with both the original pattern and normalized
      if (matcher(normalizedPath) || matcher(filePath)) {
        return true;
      }
      
      // Also try matching without the leading path
      const withoutLeading = 'test/' + normalizedPath.split('test/').slice(1).join('test/');
      if (matcher(withoutLeading)) {
        return true;
      }
    }
    return false;
  }
}