/**
 * Resolves the real path of a system path, walking up to the first existing ancestor
 * if the path or its descendants do not exist, and preserving the non-existent segments.
 */
function resolveRealPath(systemPath: string): string {
  let current = resolveSystemPath(systemPath);
  const segments: string[] = [];
  for (;;) {
    try {
      const real = realpathSync(current);
      return resolveSystemPath(real, ...segments.reverse());
    } catch (e) {
      if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {
        throw e;
      }
      const parent = dirname(current);
      if (parent === current) {
        throw e;
      }
      segments.push(basename(current));
      current = parent;
    }
  }
}

/**
 * A {@link virtualFs.ScopedHost} that additionally rejects any write/delete/rename whose real
 * (symlink-resolved) location escapes the workspace root.
 *
 * The lexical containment of `ScopedHost` (and the schematics `Tree`, which rejects `..`) does not
 * resolve symlinks, so a workspace that contains a symlinked directory could otherwise route a
 * schematic/migration write to a file outside the workspace. This mirrors the realpath-based root
 * restriction already used by the MCP host (`createRootRestrictedHost`).
 */
class WorkspaceRootHost<T extends object> extends virtualFs.ScopedHost<T> {
  private readonly _systemRoot: string;

  constructor(delegate: virtualFs.Host<T>, root: Path) {
    super(delegate, root);
    this._systemRoot = resolveRealPath(getSystemPath(root));
  }

  private _assertWithinRoot(path: Path): void {
    const systemPath = resolveSystemPath(getSystemPath(this._resolve(path)));
    const real = resolveRealPath(systemPath);

    const rel = relative(this._systemRoot, real);
    if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
      throw new Error(
        `Schematic attempted to access a path outside of the workspace root: ` +
          getSystemPath(this._resolve(path)),
      );
    }
  }

  override write(path: Path, content: virtualFs.FileBuffer): Observable<void> {
    this._assertWithinRoot(path);

    return super.write(path, content);
  }

  override delete(path: Path): Observable<void> {
    this._assertWithinRoot(path);

    return super.delete(path);
  }

  override rename(from: Path, to: Path): Observable<void> {
    this._assertWithinRoot(from);
    this._assertWithinRoot(to);

    return super.rename(from, to);
  }
}