/**
 * Enterprise In-Memory Sliding-Window Rate Limiter
 * Guards public endpoints (RFQ and Admin Login) against DoS, brute-force, and spam floods.
 */

interface RateLimitRecord {
  timestamps: number[];
}

const rateLimitStore = new Map<string, RateLimitRecord>();

// Periodic garbage collection every 10 minutes to prevent memory leak
if (typeof setInterval !== "undefined") {
  setInterval(() => {
    const now = Date.now();
    rateLimitStore.forEach((record, key) => {
      record.timestamps = record.timestamps.filter((ts) => now - ts < 3600 * 1000);
      if (record.timestamps.length === 0) {
        rateLimitStore.delete(key);
      }
    });
  }, 10 * 60 * 1000);
}

export interface RateLimitOptions {
  limit: number;       // Maximum allowed requests in window
  windowSeconds: number; // Duration of window in seconds
}

export interface RateLimitResult {
  success: boolean;
  limit: number;
  remaining: number;
  resetInSeconds: number;
}

/**
 * Resets rate limit for a specific identifier
 */
export function resetRateLimit(identifier: string) {
  rateLimitStore.delete(identifier);
}

/**
 * Evaluates rate limit for a given key (e.g. IP + action)
 */
export function checkRateLimit(
  identifier: string,
  options: RateLimitOptions = { limit: 10, windowSeconds: 60 }
): RateLimitResult {
  // Never rate-limit loopback / local dev IPs to prevent administrative lockouts
  if (identifier.includes("127.0.0.1") || identifier.includes("::1") || identifier.includes("localhost")) {
    return {
      success: true,
      limit: 9999,
      remaining: 9999,
      resetInSeconds: 0,
    };
  }

  const now = Date.now();
  const windowMs = options.windowSeconds * 1000;
  const cutoff = now - windowMs;

  let record = rateLimitStore.get(identifier);
  if (!record) {
    record = { timestamps: [] };
    rateLimitStore.set(identifier, record);
  }

  // Remove timestamps outside window
  record.timestamps = record.timestamps.filter((ts) => ts > cutoff);

  if (record.timestamps.length >= options.limit) {
    const oldestTimestamp = record.timestamps[0];
    const resetInSeconds = Math.max(1, Math.ceil((oldestTimestamp + windowMs - now) / 1000));
    return {
      success: false,
      limit: options.limit,
      remaining: 0,
      resetInSeconds,
    };
  }

  // Record new hit
  record.timestamps.push(now);
  const remaining = options.limit - record.timestamps.length;
  const resetInSeconds = options.windowSeconds;

  return {
    success: true,
    limit: options.limit,
    remaining,
    resetInSeconds,
  };
}

/**
 * Extracts client IP from Next.js Request headers safely
 */
export function getClientIp(request: Request): string {
  const forwarded = request.headers.get("x-forwarded-for");
  if (forwarded) {
    // Return first IP in comma-separated list
    return forwarded.split(",")[0].trim();
  }
  const realIp = request.headers.get("x-real-ip");
  if (realIp) {
    return realIp.trim();
  }
  return "127.0.0.1";
}
