Semaphore for async concurrency control

interface QueuedResolver {
  resolve: () => void;
  reject: (reason?: unknown) => void;
}

class Semaphore {
  private permits: number;
  private readonly maxPermits: number;
  private readonly queue: QueuedResolver[] = [];

  constructor(maxPermits: number) {
    if (maxPermits < 1) {
      throw new Error('Semaphore requires at least 1 permit');
    }
    this.permits = maxPermits;
    this.maxPermits = maxPermits;
  }

  async acquire(): Promise<void> {
    if (this.permits > 0) {
      this.permits--;
      return Promise.resolve();
    }

    return new Promise<void>((resolve, reject) => {
      this.queue.push({ resolve, reject });
    });
  }

  release(): void {
    if (this.queue.length > 0) {
      const next = this.queue.shift()!;
      next.resolve();
    } else if (this.permits < this.maxPermits) {
      this.permits++;
    }
  }

  async withPermit<T>(fn: () => Promise<T>): Promise<T> {
    await this.acquire();
    try {
      return await fn();
    } finally {
      this.release();
    }
  }

  get availablePermits(): number {
    return this.permits;
  }

  get waitingCount(): number {
    return this.queue.length;
  }

  cancelAll(reason: string = 'Semaphore cancelled'): void {
    while (this.queue.length > 0) {
      const waiter = this.queue.shift()!;
      waiter.reject(new Error(reason));
    }
  }
}

interface ApiResponse<T> {
  data: T;
  timestamp: number;
}

interface User {
  id: number;
  name: string;
  email: string;
}

const simulateApiCall = async (userId: number): Promise<ApiResponse<User>> => {
  const delay = 500 + Math.random() * 1000;
  await new Promise(resolve => setTimeout(resolve, delay));
  
  if (Math.random() < 0.1) {
    throw new Error(`API error for user ${userId}`);
  }
  
  return {
    data: {
      id: userId,
      name: `User ${userId}`,
      email: `user${userId}@example.com`
    },
    timestamp: Date.now()
  };
};

const fetchUsersWithRateLimit = async (userIds: number[], maxConcurrent: number): Promise<Map<number, User | Error>> => {
  const semaphore = new Semaphore(maxConcurrent);
  const results = new Map<number, User | Error>();
  
  const fetchUser = async (userId: number): Promise<void> => {
    await semaphore.withPermit(async () => {
      console.log(`[${new Date().toISOString()}] Fetching user ${userId} (${semaphore.waitingCount} waiting)`);
      try {
        const response = await simulateApiCall(userId);
        results.set(userId, response.data);
        console.log(`[${new Date().toISOString()}] Completed user ${userId}`);
      } catch (error) {
        results.set(userId, error instanceof Error ? error : new Error(String(error)));
        console.log(`[${new Date().toISOString()}] Failed user ${userId}`);
      }
    });
  };

  await Promise.all(userIds.map(fetchUser));
  return results;
};

const runDemo = async (): Promise<void> => {
  console.log('Starting rate-limited API calls demo...\n');
  console.log('Fetching 10 users with max 3 concurrent requests:\n');
  
  const userIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  const startTime = Date.now();
  
  const results = await fetchUsersWithRateLimit(userIds, 3);
  
  const elapsed = Date.now() - startTime;
  console.log(`\nCompleted in ${elapsed}ms`);
  console.log('\nResults:');
  
  results.forEach((result, userId) => {
    if (result instanceof Error) {
      console.log(`  User ${userId}: ERROR - ${result.message}`);
    } else {
      console.log(`  User ${userId}: ${result.name} (${result.email})`);
    }
  });
};

runDemo().catch(console.error);