// Fixed Window の実装
class FixedWindowRateLimiter {
  constructor(limit, windowMs) {
    this.limit = limit;
    this.windowMs = windowMs;
    this.windows = new Map(); // key -> { count, windowStart }
  }
 
  isAllowed(key) {
    const now = Date.now();
    const windowStart = Math.floor(now / this.windowMs) * this.windowMs;
 
    const entry = this.windows.get(key);
 
    if (!entry || entry.windowStart !== windowStart) {
      // 新しいウィンドウ
      this.windows.set(key, { count: 1, windowStart });
      return {
        allowed: true,
        remaining: this.limit - 1,
        resetAt: windowStart + this.windowMs,
      };
    }
 
    if (entry.count < this.limit) {
      entry.count++;
      return {
        allowed: true,
        remaining: this.limit - entry.count,
        resetAt: windowStart + this.windowMs,
      };
    }
 
    return {
      allowed: false,
      remaining: 0,
      resetAt: windowStart + this.windowMs,
      retryAfter: Math.ceil((windowStart + this.windowMs - now) / 1000),
    };
  }
 
  // 古いウィンドウのクリーンアップ
  cleanup() {
    const now = Date.now();
    for (const [key, entry] of this.windows.entries()) {
      if (now - entry.windowStart > this.windowMs * 2) {
        this.windows.delete(key);
      }
    }
  }
}
 
// 使用例
const limiter = new FixedWindowRateLimiter(100, 60000); // 100req/分
 
function handleRequest(req) {
  const key = `rate:${req.ip}`;
  const result = limiter.isAllowed(key);
 
  if (!result.allowed) {
    return { status: 429, retryAfter: result.retryAfter };
  }
 
  return { status: 200, remaining: result.remaining };
}

// Sliding Window Log の実装
class SlidingWindowLogLimiter {
  constructor(limit, windowMs) {
    this.limit = limit;
    this.windowMs = windowMs;
    this.logs = new Map(); // key -> timestamp[]
  }
 
  isAllowed(key) {
    const now = Date.now();
    const windowStart = now - this.windowMs;
 
    // 既存のログを取得、なければ初期化
    let timestamps = this.logs.get(key) || [];
 
    // ウィンドウ外のタイムスタンプを削除
    timestamps = timestamps.filter(ts => ts > windowStart);
 
    if (timestamps.length < this.limit) {
      timestamps.push(now);
      this.logs.set(key, timestamps);
 
      return {
        allowed: true,
        remaining: this.limit - timestamps.length,
        resetAt: Math.ceil((timestamps[0] + this.windowMs) / 1000),
      };
    }
 
    // 最も古いタイムスタンプから次にスロットが空く時間を計算
    const oldestInWindow = timestamps[0];
    const retryAfter = Math.ceil((oldestInWindow + this.windowMs - now) / 1000);
 
    this.logs.set(key, timestamps);
 
    return {
      allowed: false,
      remaining: 0,
      retryAfter,
      resetAt: Math.ceil((oldestInWindow + this.windowMs) / 1000),
    };
  }
}
 
// Redis を使った Sliding Window Log
async function slidingWindowLogRedis(redis, key, limit, windowMs) {
  const now = Date.now();
  const windowStart = now - windowMs;
 
  const pipeline = redis.pipeline();
 
  // 古いエントリを削除
  pipeline.zremrangebyscore(key, '-inf', windowStart);
  // 現在のカウントを取得
  pipeline.zcard(key);
 
  const results = await pipeline.exec();
  const count = results[1][1];
 
  if (count < limit) {
    // 新しいエントリを追加（ユニークなメンバー名が必要）
    const member = `${now}:${Math.random().toString(36).substr(2, 9)}`;
    await redis.zadd(key, now, member);
    await redis.pexpire(key, windowMs);
 
    return { allowed: true, remaining: limit - count - 1 };
  }
 
  // 最も古いエントリの時間を取得
  const oldest = await redis.zrange(key, 0, 0, 'WITHSCORES');
  const retryAfter = oldest.length >= 2
    ? Math.ceil((parseFloat(oldest[1]) + windowMs - now) / 1000)
    : 1;
 
  return { allowed: false, remaining: 0, retryAfter };
}

// Sliding Window Counter の実装
class SlidingWindowCounter {
  constructor(limit, windowMs) {
    this.limit = limit;
    this.windowMs = windowMs;
    this.counters = new Map();
  }
 
  isAllowed(key) {
    const now = Date.now();
    const currentWindow = Math.floor(now / this.windowMs) * this.windowMs;
    const previousWindow = currentWindow - this.windowMs;
 
    let data = this.counters.get(key);
    if (!data) {
      data = { windows: {} };
      this.counters.set(key, data);
    }
 
    const currentCount = data.windows[currentWindow] || 0;
    const previousCount = data.windows[previousWindow] || 0;
 
    // 現在のウィンドウ内の経過率
    const elapsed = (now - currentWindow) / this.windowMs;
    // 前のウィンドウの重み
    const previousWeight = 1 - elapsed;
 
    // 推定リクエスト数
    const estimatedCount = previousCount * previousWeight + currentCount;
 
    if (estimatedCount < this.limit) {
      data.windows[currentWindow] = currentCount + 1;
 
      // 古いウィンドウを削除
      for (const w of Object.keys(data.windows)) {
        if (parseInt(w) < previousWindow) {
          delete data.windows[w];
        }
      }
 
      return {
        allowed: true,
        remaining: Math.floor(this.limit - estimatedCount - 1),
        resetAt: Math.ceil((currentWindow + this.windowMs) / 1000),
      };
    }
 
    return {
      allowed: false,
      remaining: 0,
      retryAfter: Math.ceil((this.windowMs - (now - currentWindow)) / 1000),
    };
  }
}

// Token Bucket の実装（メモリ内）
class TokenBucket {
  constructor(capacity, refillRate) {
    this.capacity = capacity;       // 最大トークン数
    this.refillRate = refillRate;   // トークン/秒
    this.buckets = new Map();
  }
 
  isAllowed(key, tokensRequired = 1) {
    const now = Date.now();
 
    let bucket = this.buckets.get(key);
    if (!bucket) {
      bucket = { tokens: this.capacity, lastRefill: now };
      this.buckets.set(key, bucket);
    }
 
    // トークンを補充
    const elapsed = (now - bucket.lastRefill) / 1000;
    bucket.tokens = Math.min(
      this.capacity,
      bucket.tokens + elapsed * this.refillRate
    );
    bucket.lastRefill = now;
 
    if (bucket.tokens >= tokensRequired) {
      bucket.tokens -= tokensRequired;
      return {
        allowed: true,
        remaining: Math.floor(bucket.tokens),
        retryAfter: 0,
      };
    }
 
    // トークンが足りない場合、次にトークンが利用可能になる時間
    const deficit = tokensRequired - bucket.tokens;
    const retryAfter = Math.ceil(deficit / this.refillRate);
 
    return {
      allowed: false,
      remaining: 0,
      retryAfter,
    };
  }
}
 
// リクエストサイズに応じたトークン消費
class WeightedTokenBucket extends TokenBucket {
  constructor(capacity, refillRate, weightFn) {
    super(capacity, refillRate);
    this.weightFn = weightFn;
  }
 
  isAllowedForRequest(key, request) {
    const weight = this.weightFn(request);
    return this.isAllowed(key, weight);
  }
}
 
// 使用例: エンドポイントの重さに応じた消費
const weightedLimiter = new WeightedTokenBucket(
  100, // capacity
  10,  // refill_rate: 10 tokens/sec
  (req) => {
    // GETは1トークン、POSTは5トークン、ファイルアップロードは20トークン
    const weights = {
      'GET': 1,
      'POST': 5,
      'PUT': 5,
      'DELETE': 3,
    };
    if (req.path.includes('/upload')) return 20;
    return weights[req.method] || 1;
  }
);

// Leaky Bucket の実装
class LeakyBucket {
  constructor(capacity, leakRate) {
    this.capacity = capacity;     // キューの最大サイズ
    this.leakRate = leakRate;     // 処理速度（リクエスト/秒）
    this.buckets = new Map();
  }
 
  isAllowed(key) {
    const now = Date.now();
 
    let bucket = this.buckets.get(key);
    if (!bucket) {
      bucket = { water: 0, lastLeak: now };
      this.buckets.set(key, bucket);
    }
 
    // 経過時間に応じてキューを排出
    const elapsed = (now - bucket.lastLeak) / 1000;
    bucket.water = Math.max(0, bucket.water - elapsed * this.leakRate);
    bucket.lastLeak = now;
 
    if (bucket.water < this.capacity) {
      bucket.water += 1;
      return {
        allowed: true,
        queuePosition: Math.ceil(bucket.water),
        estimatedWait: Math.ceil(bucket.water / this.leakRate),
      };
    }
 
    return {
      allowed: false,
      retryAfter: Math.ceil(1 / this.leakRate),
    };
  }
}
 
// Leaky Bucket をキューとして使う場合
class LeakyBucketQueue {
  constructor(capacity, processRate) {
    this.capacity = capacity;
    this.processRate = processRate; // 1秒あたりの処理数
    this.queue = [];
    this.processing = false;
  }
 
  async enqueue(task) {
    if (this.queue.length >= this.capacity) {
      throw new Error('Queue is full. Try again later.');
    }
 
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.startProcessing();
    });
  }
 
  startProcessing() {
    if (this.processing) return;
    this.processing = true;
 
    const interval = 1000 / this.processRate;
    const timer = setInterval(async () => {
      if (this.queue.length === 0) {
        clearInterval(timer);
        this.processing = false;
        return;
      }
 
      const { task, resolve, reject } = this.queue.shift();
      try {
        const result = await task();
        resolve(result);
      } catch (error) {
        reject(error);
      }
    }, interval);
  }
}

// Sliding Window Counter の Redis 実装
 
const Redis = require('ioredis');
const redis = new Redis();
 
async function slidingWindowRateLimit(key, limit, windowSizeMs) {
  const now = Date.now();
  const windowStart = now - windowSizeMs;
 
  // Lua スクリプト（アトミック操作）
  const script = `
    local key = KEYS[1]
    local now = tonumber(ARGV[1])
    local window_start = tonumber(ARGV[2])
    local limit = tonumber(ARGV[3])
    local window_ms = tonumber(ARGV[4])
 
    -- 期限切れのエントリを削除
    redis.call('ZREMRANGEBYSCORE', key, '-inf', window_start)
 
    -- 現在のカウント
    local count = redis.call('ZCARD', key)
 
    if count < limit then
      -- リクエストを記録
      redis.call('ZADD', key, now, now .. ':' .. math.random(100000))
      redis.call('PEXPIRE', key, window_ms)
      return {1, limit - count - 1, 0}  -- allowed, remaining, retryAfter
    else
      -- 最も古いエントリの時刻
      local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
      local retry_after = oldest[2] + window_ms - now
      return {0, 0, retry_after}  -- denied, remaining, retryAfter
    end
  `;
 
  const [allowed, remaining, retryAfter] = await redis.eval(
    script, 1, key, now, windowStart, limit, windowSizeMs
  );
 
  return {
    allowed: allowed === 1,
    remaining,
    retryAfter: Math.ceil(retryAfter / 1000),
    limit,
    reset: Math.ceil((now + windowSizeMs) / 1000),
  };
}

// Token Bucket の Redis 実装
async function tokenBucketRateLimit(key, capacity, refillRate) {
  const script = `
    local key = KEYS[1]
    local capacity = tonumber(ARGV[1])
    local refill_rate = tonumber(ARGV[2])
    local now = tonumber(ARGV[3])
 
    local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
    local tokens = tonumber(bucket[1]) or capacity
    local last_refill = tonumber(bucket[2]) or now
 
    -- トークン補充
    local elapsed = (now - last_refill) / 1000
    tokens = math.min(capacity, tokens + elapsed * refill_rate)
 
    if tokens >= 1 then
      tokens = tokens - 1
      redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
      redis.call('PEXPIRE', key, 60000)
      return {1, math.floor(tokens)}
    else
      redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
      redis.call('PEXPIRE', key, 60000)
      local retry_after = (1 - tokens) / refill_rate
      return {0, 0, math.ceil(retry_after)}
    end
  `;
 
  const result = await redis.eval(script, 1, key, capacity, refillRate, Date.now());
  return { allowed: result[0] === 1, remaining: result[1], retryAfter: result[2] };
}

// Redis Cluster 対応のレート制限
class DistributedRateLimiter {
  constructor(redisCluster, options) {
    this.redis = redisCluster;
    this.options = options;
    this.localCache = new Map(); // ローカルフォールバック
    this.localLimiter = new SlidingWindowCounter(
      options.limit * 1.2, // ローカルは少し緩めに
      options.windowMs
    );
  }
 
  async isAllowed(key) {
    try {
      return await this.checkRedis(key);
    } catch (error) {
      console.warn(`Redis rate limit failed, using local fallback: ${error.message}`);
      return this.checkLocal(key);
    }
  }
 
  async checkRedis(key) {
    const { limit, windowMs } = this.options;
    return await slidingWindowRateLimit(
      `rate_limit:${key}`,
      limit,
      windowMs
    );
  }
 
  checkLocal(key) {
    return this.localLimiter.isAllowed(key);
  }
}
 
// Redis Sentinel を使った高可用性レート制限
const redis = new Redis({
  sentinels: [
    { host: 'sentinel-1', port: 26379 },
    { host: 'sentinel-2', port: 26379 },
    { host: 'sentinel-3', port: 26379 },
  ],
  name: 'rate-limit-master',
  retryStrategy(times) {
    return Math.min(times * 50, 2000);
  },
});

// ローカルバッファで Redis アクセスを最小化
class BufferedRateLimiter {
  constructor(redis, options) {
    this.redis = redis;
    this.limit = options.limit;
    this.windowMs = options.windowMs;
    this.batchSize = options.batchSize || 10;   // 10リクエスト分をローカルバッファ
    this.syncInterval = options.syncInterval || 1000; // 1秒ごとに同期
 
    this.localCounters = new Map();
    this.startSync();
  }
 
  async isAllowed(key) {
    let local = this.localCounters.get(key);
    if (!local) {
      local = { count: 0, quota: this.batchSize, synced: 0 };
      this.localCounters.set(key, local);
      // 初回は Redis からクオータを取得
      await this.fetchQuota(key, local);
    }
 
    if (local.count < local.quota) {
      local.count++;
      return { allowed: true, remaining: local.quota - local.count };
    }
 
    // ローカルクオータ使い切り → Redis に同期して追加取得
    await this.syncToRedis(key, local);
    await this.fetchQuota(key, local);
 
    if (local.count < local.quota) {
      local.count++;
      return { allowed: true, remaining: local.quota - local.count };
    }
 
    return { allowed: false, remaining: 0 };
  }
 
  async fetchQuota(key, local) {
    const script = `
      local key = KEYS[1]
      local limit = tonumber(ARGV[1])
      local batch = tonumber(ARGV[2])
      local window_ms = tonumber(ARGV[3])
      local now = tonumber(ARGV[4])
 
      local current = tonumber(redis.call('GET', key) or '0')
      local available = limit - current
 
      if available <= 0 then
        return 0
      end
 
      local grant = math.min(batch, available)
      redis.call('INCRBY', key, grant)
 
      if redis.call('PTTL', key) == -1 then
        redis.call('PEXPIRE', key, window_ms)
      end
 
      return grant
    `;
 
    const granted = await this.redis.eval(
      script, 1, `rate:${key}`,
      this.limit, this.batchSize, this.windowMs, Date.now()
    );
 
    local.quota = granted;
    local.count = 0;
  }
 
  async syncToRedis(key, local) {
    // 使い切れなかったクオータを戻す
    const unused = local.quota - local.count;
    if (unused > 0) {
      await this.redis.decrby(`rate:${key}`, unused);
    }
    local.count = 0;
    local.quota = 0;
  }
 
  startSync() {
    setInterval(async () => {
      for (const [key, local] of this.localCounters.entries()) {
        await this.syncToRedis(key, local);
        await this.fetchQuota(key, local);
      }
    }, this.syncInterval);
  }
}

// Express ミドルウェア - プロダクション品質
function rateLimitMiddleware(options) {
  const {
    limit = 100,
    windowMs = 60000,
    keyGenerator,
    handler,
    skip,
    onLimitReached,
    headers = true,
    draft7Headers = false,
  } = options;
 
  return async (req, res, next) => {
    // スキップ条件
    if (skip && await skip(req)) {
      return next();
    }
 
    const key = keyGenerator
      ? keyGenerator(req)
      : `rate_limit:${req.ip}`;
 
    try {
      const result = await slidingWindowRateLimit(key, limit, windowMs);
 
      // レスポンスヘッダーに制限情報を設定
      if (headers) {
        res.set({
          'X-RateLimit-Limit': result.limit,
          'X-RateLimit-Remaining': Math.max(0, result.remaining),
          'X-RateLimit-Reset': result.reset,
        });
      }
 
      // IETF draft-7 ヘッダー
      if (draft7Headers) {
        res.set({
          'RateLimit-Limit': result.limit,
          'RateLimit-Remaining': Math.max(0, result.remaining),
          'RateLimit-Reset': Math.ceil((result.reset * 1000 - Date.now()) / 1000),
        });
      }
 
      if (!result.allowed) {
        res.set('Retry-After', result.retryAfter);
 
        // カスタムハンドラー
        if (onLimitReached) {
          onLimitReached(req, res, result);
        }
 
        if (handler) {
          return handler(req, res, next, result);
        }
 
        return res.status(429).json({
          type: 'https://api.example.com/errors/rate-limit',
          title: 'Rate Limit Exceeded',
          status: 429,
          detail: `Rate limit of ${limit} requests per ${windowMs / 1000}s exceeded.`,
          retryAfter: result.retryAfter,
        });
      }
 
      next();
    } catch (error) {
      // レート制限システムのエラー時はリクエストを許可
      console.error('Rate limit error:', error);
      next();
    }
  };
}
 
// 使用例: エンドポイントごとに異なる制限
const app = require('express')();
 
// グローバル制限
app.use('/api/v1/',
  rateLimitMiddleware({
    limit: 100,
    windowMs: 60000,
    keyGenerator: (req) => `rate:${req.apiKey?.id || req.ip}`,
  })
);
 
// ログインエンドポイント: 厳しく制限
app.use('/api/v1/auth/login',
  rateLimitMiddleware({
    limit: 5,
    windowMs: 300000,  // 5分間
    keyGenerator: (req) => `rate:login:${req.ip}`,
    onLimitReached: (req, res, result) => {
      // セキュリティチームに通知
      securityAlert('login_rate_limit', {
        ip: req.ip,
        userAgent: req.headers['user-agent'],
      });
    },
  })
);
 
// パスワードリセット: さらに厳しく
app.use('/api/v1/auth/reset-password',
  rateLimitMiddleware({
    limit: 3,
    windowMs: 3600000,  // 1時間
    keyGenerator: (req) => `rate:reset:${req.body?.email || req.ip}`,
  })
);
 
// ファイルアップロード: リソース消費が大きいので制限
app.use('/api/v1/upload',
  rateLimitMiddleware({
    limit: 10,
    windowMs: 3600000,  // 1時間に10ファイル
    keyGenerator: (req) => `rate:upload:${req.userId}`,
  })
);
 
// 検索エンドポイント: 中程度の制限
app.use('/api/v1/search',
  rateLimitMiddleware({
    limit: 30,
    windowMs: 60000,
    keyGenerator: (req) => `rate:search:${req.userId || req.ip}`,
    skip: (req) => req.user?.plan === 'enterprise', // Enterpriseはスキップ
  })
);

// プランに応じた動的レート制限
class PlanBasedRateLimiter {
  constructor(redis) {
    this.redis = redis;
    this.plans = {
      free: {
        global: { limit: 100, windowMs: 60000 },
        search: { limit: 10, windowMs: 60000 },
        upload: { limit: 5, windowMs: 3600000 },
        ai: { limit: 20, windowMs: 3600000 },
      },
      pro: {
        global: { limit: 1000, windowMs: 60000 },
        search: { limit: 100, windowMs: 60000 },
        upload: { limit: 50, windowMs: 3600000 },
        ai: { limit: 200, windowMs: 3600000 },
      },
      enterprise: {
        global: { limit: 10000, windowMs: 60000 },
        search: { limit: 1000, windowMs: 60000 },
        upload: { limit: 500, windowMs: 3600000 },
        ai: { limit: 2000, windowMs: 3600000 },
      },
    };
  }
 
  middleware(endpoint = 'global') {
    return async (req, res, next) => {
      const plan = req.user?.plan || 'free';
      const limits = this.plans[plan]?.[endpoint] || this.plans.free.global;
 
      const key = `rate:${plan}:${endpoint}:${req.user?.id || req.ip}`;
      const result = await slidingWindowRateLimit(
        key, limits.limit, limits.windowMs
      );
 
      res.set({
        'X-RateLimit-Limit': limits.limit,
        'X-RateLimit-Remaining': Math.max(0, result.remaining),
        'X-RateLimit-Reset': result.reset,
        'X-RateLimit-Plan': plan,
      });
 
      if (!result.allowed) {
        res.set('Retry-After', result.retryAfter);
        return res.status(429).json({
          type: 'rate_limit_exceeded',
          message: `${plan} plan limit of ${limits.limit} requests exceeded.`,
          upgrade: plan !== 'enterprise'
            ? 'Upgrade your plan for higher limits: https://example.com/pricing'
            : undefined,
          retryAfter: result.retryAfter,
        });
      }
 
      next();
    };
  }
 
  // プランの動的更新（アップグレード時に即座に反映）
  async updatePlan(userId, newPlan) {
    // キャッシュされたレート制限情報をリセット
    const keys = await this.redis.keys(`rate:*:*:${userId}`);
    if (keys.length > 0) {
      await this.redis.del(...keys);
    }
  }
}
 
// 使用例
const planLimiter = new PlanBasedRateLimiter(redis);
app.use('/api/v1/', planLimiter.middleware('global'));
app.use('/api/v1/search', planLimiter.middleware('search'));
app.use('/api/v1/upload', planLimiter.middleware('upload'));
app.use('/api/v1/ai', planLimiter.middleware('ai'));

// NestJS デコレータベースのレート制限
import { SetMetadata, UseGuards, Injectable, CanActivate } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
 
// カスタムデコレータ
export const RATE_LIMIT_KEY = 'rateLimit';
 
export interface RateLimitOptions {
  limit: number;
  windowMs: number;
  keyPrefix?: string;
}
 
export const RateLimit = (options: RateLimitOptions) =>
  SetMetadata(RATE_LIMIT_KEY, options);
 
// レート制限ガード
@Injectable()
export class RateLimitGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    private rateLimiter: RateLimiterService,
  ) {}
 
  async canActivate(context: ExecutionContext): Promise<boolean> {
    const options = this.reflector.get<RateLimitOptions>(
      RATE_LIMIT_KEY,
      context.getHandler(),
    );
 
    if (!options) return true;
 
    const request = context.switchToHttp().getRequest();
    const response = context.switchToHttp().getResponse();
 
    const key = `${options.keyPrefix || 'rate'}:${request.user?.id || request.ip}`;
    const result = await this.rateLimiter.check(key, options.limit, options.windowMs);
 
    response.set({
      'X-RateLimit-Limit': options.limit.toString(),
      'X-RateLimit-Remaining': Math.max(0, result.remaining).toString(),
      'X-RateLimit-Reset': result.reset.toString(),
    });
 
    if (!result.allowed) {
      response.set('Retry-After', result.retryAfter.toString());
      throw new HttpException(
        {
          statusCode: 429,
          message: 'Rate limit exceeded',
          retryAfter: result.retryAfter,
        },
        HttpStatus.TOO_MANY_REQUESTS,
      );
    }
 
    return true;
  }
}
 
// コントローラでの使用
@Controller('users')
@UseGuards(RateLimitGuard)
export class UsersController {
  @Get()
  @RateLimit({ limit: 100, windowMs: 60000 })
  findAll() {
    return this.usersService.findAll();
  }
 
  @Post()
  @RateLimit({ limit: 20, windowMs: 60000, keyPrefix: 'rate:create' })
  create(@Body() dto: CreateUserDto) {
    return this.usersService.create(dto);
  }
 
  @Post('bulk-import')
  @RateLimit({ limit: 5, windowMs: 3600000, keyPrefix: 'rate:bulk' })
  bulkImport(@Body() dto: BulkImportDto) {
    return this.usersService.bulkImport(dto);
  }
}

package ratelimit
 
import (
    "context"
    "fmt"
    "net/http"
    "strconv"
    "time"
 
    "github.com/go-redis/redis/v8"
)
 
// RateLimiter はレート制限の設定を保持する
type RateLimiter struct {
    redis    *redis.Client
    limit    int
    windowMs int64
}
 
// Result はレート制限チェックの結果
type Result struct {
    Allowed    bool
    Remaining  int
    RetryAfter int
    Reset      int64
}
 
// NewRateLimiter は新しいレート制限インスタンスを生成する
func NewRateLimiter(rdb *redis.Client, limit int, windowMs int64) *RateLimiter {
    return &RateLimiter{
        redis:    rdb,
        limit:    limit,
        windowMs: windowMs,
    }
}
 
// Check はレート制限をチェックする
func (rl *RateLimiter) Check(ctx context.Context, key string) (*Result, error) {
    now := time.Now().UnixMilli()
    windowStart := now - rl.windowMs
 
    script := redis.NewScript(`
        local key = KEYS[1]
        local now = tonumber(ARGV[1])
        local window_start = tonumber(ARGV[2])
        local limit = tonumber(ARGV[3])
        local window_ms = tonumber(ARGV[4])
 
        redis.call('ZREMRANGEBYSCORE', key, '-inf', window_start)
        local count = redis.call('ZCARD', key)
 
        if count < limit then
            redis.call('ZADD', key, now, now .. ':' .. math.random(100000))
            redis.call('PEXPIRE', key, window_ms)
            return {1, limit - count - 1, 0}
        else
            local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
            local retry_after = 0
            if oldest[2] then
                retry_after = oldest[2] + window_ms - now
            end
            return {0, 0, retry_after}
        end
    `)
 
    result, err := script.Run(ctx, rl.redis, []string{key},
        now, windowStart, rl.limit, rl.windowMs).Int64Slice()
    if err != nil {
        return nil, fmt.Errorf("rate limit check failed: %w", err)
    }
 
    return &Result{
        Allowed:    result[0] == 1,
        Remaining:  int(result[1]),
        RetryAfter: int(result[2] / 1000),
        Reset:      (now + rl.windowMs) / 1000,
    }, nil
}
 
// Middleware はHTTPミドルウェアとしてレート制限を適用する
func (rl *RateLimiter) Middleware(keyFn func(*http.Request) string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            key := keyFn(r)
            result, err := rl.Check(r.Context(), key)
            if err != nil {
                // レート制限システムエラー時はリクエストを許可
                next.ServeHTTP(w, r)
                return
            }
 
            w.Header().Set("X-RateLimit-Limit", strconv.Itoa(rl.limit))
            w.Header().Set("X-RateLimit-Remaining", strconv.Itoa(result.Remaining))
            w.Header().Set("X-RateLimit-Reset", strconv.FormatInt(result.Reset, 10))
 
            if !result.Allowed {
                w.Header().Set("Retry-After", strconv.Itoa(result.RetryAfter))
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(http.StatusTooManyRequests)
                fmt.Fprintf(w, `{"error":"rate_limit_exceeded","retry_after":%d}`,
                    result.RetryAfter)
                return
            }
 
            next.ServeHTTP(w, r)
        })
    }
}
 
// 使用例
func setupRoutes() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    limiter := NewRateLimiter(rdb, 100, 60000) // 100 req/min
 
    mux := http.NewServeMux()
    mux.Handle("/api/",
        limiter.Middleware(func(r *http.Request) string {
            return "rate:" + r.RemoteAddr
        })(apiHandler),
    )
}

// レスポンスヘッダーの設定ヘルパー
class RateLimitHeaders {
  static set(res, result, options = {}) {
    const {
      prefix = 'X-RateLimit',
      includeIetf = false,
      includePlan = false,
      plan = null,
    } = options;
 
    // de facto 標準ヘッダー
    res.set({
      [`${prefix}-Limit`]: result.limit.toString(),
      [`${prefix}-Remaining`]: Math.max(0, result.remaining).toString(),
      [`${prefix}-Reset`]: result.reset.toString(),
    });
 
    // IETF draft ヘッダー
    if (includeIetf) {
      const resetInSeconds = Math.max(0, result.reset - Math.floor(Date.now() / 1000));
      res.set({
        'RateLimit-Limit': result.limit.toString(),
        'RateLimit-Remaining': Math.max(0, result.remaining).toString(),
        'RateLimit-Reset': resetInSeconds.toString(),
      });
    }
 
    // プラン情報
    if (includePlan && plan) {
      res.set(`${prefix}-Plan`, plan);
    }
 
    // 429 の場合
    if (!result.allowed && result.retryAfter > 0) {
      res.set('Retry-After', result.retryAfter.toString());
    }
  }
 
  static error429(result, options = {}) {
    const { detail, upgrade } = options;
 
    return {
      type: 'https://api.example.com/errors/rate-limit',
      title: 'Rate Limit Exceeded',
      status: 429,
      detail: detail || `Rate limit of ${result.limit} requests exceeded.`,
      retryAfter: result.retryAfter,
      ...(upgrade ? { upgrade } : {}),
    };
  }
}

// SDK内でのレート制限対応
 
async function requestWithRateLimit(fn, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && attempt < maxRetries) {
        const retryAfter = error.headers?.['retry-after']
          ? parseInt(error.headers['retry-after']) * 1000
          : Math.min(1000 * 2 ** attempt, 30000);
 
        // ジッターを追加（全クライアントが同時にリトライしないように）
        const jitter = Math.random() * 1000;
        const delay = retryAfter + jitter;
 
        console.warn(
          `Rate limited (attempt ${attempt + 1}/${maxRetries}). ` +
          `Retrying in ${Math.round(delay)}ms...`
        );
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw error;
    }
  }
}
 
// Exponential Backoff with Jitter
class RetryWithBackoff {
  constructor(options = {}) {
    this.maxRetries = options.maxRetries || 5;
    this.baseDelay = options.baseDelay || 1000;
    this.maxDelay = options.maxDelay || 60000;
    this.jitterFactor = options.jitterFactor || 0.5;
  }
 
  async execute(fn) {
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        return await fn();
      } catch (error) {
        if (!this.isRetryable(error) || attempt === this.maxRetries) {
          throw error;
        }
 
        const delay = this.calculateDelay(attempt, error);
        console.warn(`Retry attempt ${attempt + 1}/${this.maxRetries} in ${delay}ms`);
        await this.sleep(delay);
      }
    }
  }
 
  isRetryable(error) {
    return error.status === 429 || error.status >= 500;
  }
 
  calculateDelay(attempt, error) {
    // Retry-After ヘッダーがあれば優先
    if (error.headers?.['retry-after']) {
      const retryAfter = parseInt(error.headers['retry-after']);
      if (!isNaN(retryAfter)) {
        return retryAfter * 1000;
      }
    }
 
    // Exponential backoff with full jitter
    const exponential = this.baseDelay * Math.pow(2, attempt);
    const capped = Math.min(exponential, this.maxDelay);
    const jitter = capped * this.jitterFactor * Math.random();
    return capped + jitter;
  }
 
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}
 
// 使用例
const retrier = new RetryWithBackoff({ maxRetries: 5, baseDelay: 1000 });
const result = await retrier.execute(() => fetch('/api/data'));

// プロアクティブなレート制限
// → レスポンスヘッダーを監視し、残り少ない場合にスロットリング
class RateLimitAwareClient {
  constructor(options = {}) {
    this.baseUrl = options.baseUrl || '';
    this.remaining = Infinity;
    this.resetAt = 0;
    this.limit = 0;
 
    // プロアクティブスロットリング設定
    this.throttleThreshold = options.throttleThreshold || 0.1; // 残り10%でスロットリング
    this.requestQueue = [];
    this.processing = false;
  }
 
  async request(url, options = {}) {
    // 残りが少ない場合はプロアクティブにウェイト
    if (this.shouldThrottle()) {
      await this.waitForReset();
    }
 
    const response = await fetch(this.baseUrl + url, options);
 
    // ヘッダーからレート制限情報を更新
    this.updateLimits(response);
 
    if (response.status === 429) {
      const retryAfter = parseInt(response.headers.get('Retry-After') || '1');
      await new Promise(r => setTimeout(r, retryAfter * 1000));
      return this.request(url, options); // リトライ
    }
 
    return response;
  }
 
  shouldThrottle() {
    if (this.limit === 0) return false;
    return this.remaining / this.limit <= this.throttleThreshold;
  }
 
  async waitForReset() {
    if (this.remaining <= 0 && Date.now() < this.resetAt) {
      const waitMs = this.resetAt - Date.now() + 100; // 100ms のバッファ
      console.warn(`Proactive throttle: waiting ${waitMs}ms for rate limit reset`);
      await new Promise(r => setTimeout(r, waitMs));
    }
  }
 
  updateLimits(response) {
    const limit = response.headers.get('X-RateLimit-Limit');
    const remaining = response.headers.get('X-RateLimit-Remaining');
    const reset = response.headers.get('X-RateLimit-Reset');
 
    if (limit) this.limit = parseInt(limit);
    if (remaining) this.remaining = parseInt(remaining);
    if (reset) this.resetAt = parseInt(reset) * 1000;
  }
}
 
// バッチリクエストでレート制限を最適化
class BatchRequestClient extends RateLimitAwareClient {
  constructor(options = {}) {
    super(options);
    this.batchSize = options.batchSize || 10;
    this.batchDelay = options.batchDelay || 100; // ms between batches
  }
 
  async batchRequest(urls, options = {}) {
    const results = [];
 
    for (let i = 0; i < urls.length; i += this.batchSize) {
      const batch = urls.slice(i, i + this.batchSize);
 
      const batchResults = await Promise.allSettled(
        batch.map(url => this.request(url, options))
      );
 
      results.push(...batchResults);
 
      // バッチ間にディレイ
      if (i + this.batchSize < urls.length) {
        // 残りリクエスト数に基づいて動的にディレイを調整
        const delay = this.calculateBatchDelay();
        await new Promise(r => setTimeout(r, delay));
      }
    }
 
    return results;
  }
 
  calculateBatchDelay() {
    if (this.remaining <= this.batchSize * 2) {
      // 残りが少ない場合は長いディレイ
      return this.batchDelay * 5;
    }
    if (this.remaining <= this.batchSize * 5) {
      return this.batchDelay * 2;
    }
    return this.batchDelay;
  }
}

import time
import random
import requests
from functools import wraps
from dataclasses import dataclass
from typing import Optional, Callable
 
 
@dataclass
class RateLimitInfo:
    """レート制限情報"""
    limit: int = 0
    remaining: int = float('inf')
    reset_at: float = 0
    retry_after: Optional[int] = None
 
 
class RateLimitedClient:
    """レート制限対応のHTTPクライアント"""
 
    def __init__(self, base_url: str, max_retries: int = 3):
        self.base_url = base_url
        self.max_retries = max_retries
        self.session = requests.Session()
        self.rate_info = RateLimitInfo()
 
    def get(self, path: str, **kwargs) -> requests.Response:
        return self._request('GET', path, **kwargs)
 
    def post(self, path: str, **kwargs) -> requests.Response:
        return self._request('POST', path, **kwargs)
 
    def _request(self, method: str, path: str, **kwargs) -> requests.Response:
        url = f"{self.base_url}{path}"
 
        for attempt in range(self.max_retries + 1):
            # プロアクティブなウェイト
            self._proactive_wait()
 
            try:
                response = self.session.request(method, url, **kwargs)
                self._update_rate_info(response)
 
                if response.status_code == 429:
                    if attempt < self.max_retries:
                        delay = self._calculate_delay(attempt, response)
                        print(f"Rate limited. Retrying in {delay:.1f}s "
                              f"(attempt {attempt + 1}/{self.max_retries})")
                        time.sleep(delay)
                        continue
                    raise RateLimitError(response)
 
                return response
 
            except requests.ConnectionError:
                if attempt < self.max_retries:
                    time.sleep(2 ** attempt)
                    continue
                raise
 
        raise RateLimitError("Max retries exceeded")
 
    def _proactive_wait(self):
        """残りリクエスト数が少ない場合にプロアクティブにウェイト"""
        if self.rate_info.remaining <= 1:
            wait_time = self.rate_info.reset_at - time.time()
            if wait_time > 0:
                print(f"Proactive wait: {wait_time:.1f}s")
                time.sleep(wait_time + 0.1)
 
    def _update_rate_info(self, response: requests.Response):
        """レスポンスヘッダーからレート制限情報を更新"""
        headers = response.headers
        self.rate_info = RateLimitInfo(
            limit=int(headers.get('X-RateLimit-Limit', 0)),
            remaining=int(headers.get('X-RateLimit-Remaining', float('inf'))),
            reset_at=float(headers.get('X-RateLimit-Reset', 0)),
            retry_after=int(headers['Retry-After']) if 'Retry-After' in headers else None,
        )
 
    def _calculate_delay(self, attempt: int, response: requests.Response) -> float:
        """リトライまでの遅延を計算"""
        retry_after = response.headers.get('Retry-After')
        if retry_after:
            return float(retry_after) + random.uniform(0, 1)
 
        # Exponential backoff with jitter
        base = min(2 ** attempt, 60)
        jitter = random.uniform(0, base * 0.5)
        return base + jitter
 
 
class RateLimitError(Exception):
    """レート制限エラー"""
    def __init__(self, response_or_message):
        if isinstance(response_or_message, requests.Response):
            self.response = response_or_message
            self.retry_after = int(
                response_or_message.headers.get('Retry-After', 0)
            )
            super().__init__(
                f"Rate limit exceeded. Retry after {self.retry_after}s"
            )
        else:
            super().__init__(str(response_or_message))
 
 
# デコレータとしての使用
def rate_limited(max_retries=3, base_delay=1.0):
    """レート制限対応デコレータ"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except RateLimitError as e:
                    if attempt < max_retries:
                        delay = e.retry_after or (base_delay * 2 ** attempt)
                        jitter = random.uniform(0, delay * 0.25)
                        time.sleep(delay + jitter)
                        continue
                    raise
        return wrapper
    return decorator
 
 
# 使用例
client = RateLimitedClient("https://api.example.com", max_retries=3)
 
@rate_limited(max_retries=5)
def fetch_users():
    return client.get("/v1/users")
 
users = fetch_users()

// 複数のレート制限を組み合わせる
class CompositeRateLimiter {
  constructor(limiters) {
    this.limiters = limiters; // { name, limiter, key, limit, windowMs }[]
  }
 
  async isAllowed(request) {
    const results = [];
    let mostRestrictive = null;
 
    for (const config of this.limiters) {
      const key = typeof config.key === 'function'
        ? config.key(request)
        : config.key;
 
      const result = await config.limiter.isAllowed(key);
      results.push({ name: config.name, ...result });
 
      if (!result.allowed) {
        if (!mostRestrictive || result.retryAfter > mostRestrictive.retryAfter) {
          mostRestrictive = { name: config.name, ...result };
        }
      }
    }
 
    return {
      allowed: results.every(r => r.allowed),
      results,
      mostRestrictive,
    };
  }
}
 
// 使用例: 3層のレート制限
const compositeLimiter = new CompositeRateLimiter([
  {
    name: 'global',
    limiter: new SlidingWindowCounter(1000, 60000),
    key: (req) => `global:${req.ip}`,
  },
  {
    name: 'user',
    limiter: new SlidingWindowCounter(100, 60000),
    key: (req) => `user:${req.userId}`,
  },
  {
    name: 'endpoint',
    limiter: new SlidingWindowCounter(20, 60000),
    key: (req) => `endpoint:${req.userId}:${req.path}`,
  },
]);
 
// ミドルウェアとして使用
app.use(async (req, res, next) => {
  const result = await compositeLimiter.isAllowed(req);
 
  // 最も厳しい制限の情報をヘッダーに設定
  const globalResult = result.results.find(r => r.name === 'global');
  res.set({
    'X-RateLimit-Limit': globalResult.limit || 1000,
    'X-RateLimit-Remaining': Math.max(0, globalResult.remaining || 0),
  });
 
  if (!result.allowed) {
    const { mostRestrictive } = result;
    res.set('Retry-After', mostRestrictive.retryAfter);
    return res.status(429).json({
      error: 'rate_limit_exceeded',
      limitType: mostRestrictive.name,
      retryAfter: mostRestrictive.retryAfter,
    });
  }
 
  next();
});