export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);

    // Route handling
    if (url.pathname === '/api/health') {
      return new Response('OK', { status: 200 });
    }

    // Fetch from origin and transform
    const response = await fetch(request);
    const html = await response.text();
    const modified = html.replace('</head>', '<script src="/analytics.js"></script></head>');

    return new Response(modified, {
      status: response.status,
      headers: response.headers,
    });
  },
};

function setCacheHeaders(response: Response, type: 'static' | 'dynamic' | 'api'): Response {
  const headers = new Headers(response.headers);

  switch (type) {
    case 'static':
      // Immutable assets with content hash in filename
      headers.set('Cache-Control', 'public, max-age=31536000, immutable');
      break;
    case 'dynamic':
      // HTML pages - serve stale while revalidating in background
      headers.set('Cache-Control', 'public, max-age=60, stale-while-revalidate=86400');
      headers.set('Surrogate-Key', 'page-content');
      break;
    case 'api':
      // API responses - short cache with revalidation
      headers.set('Cache-Control', 'public, max-age=5, stale-while-revalidate=30');
      headers.set('Vary', 'Authorization, Accept');
      break;
  }

  return new Response(response.body, { status: response.status, headers });
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const country = request.headers.get('CF-IPCountry') ?? 'US';
    const continent = request.cf?.continent ?? 'NA';

    // Route to nearest regional origin
    const origins: Record<string, string> = {
      EU: 'https://eu.api.example.com',
      AS: 'https://ap.api.example.com',
      NA: 'https://us.api.example.com',
    };
    const origin = origins[continent] ?? origins['NA'];

    // GDPR compliance - block or redirect EU users to compliant flow
    if (continent === 'EU' && new URL(request.url).pathname.startsWith('/track')) {
      return new Response('Tracking disabled in EU', { status: 451 });
    }

    const url = new URL(request.url);
    url.hostname = new URL(origin).hostname;
    return fetch(url.toString(), request);
  },
};

interface Env {
  CONFIG_KV: KVNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Read feature flags from KV (eventually consistent, ~60s propagation)
    const flags = await env.CONFIG_KV.get('feature-flags', 'json') as Record<string, boolean> | null;

    if (flags?.['maintenance-mode']) {
      return new Response('We are performing maintenance. Back soon.', {
        status: 503,
        headers: { 'Retry-After': '300' },
      });
    }

    // Cache KV reads in the Worker's memory for the request lifetime
    // KV reads are fast (~10ms) but not free - avoid reading per-subrequest
    const config = await env.CONFIG_KV.get('site-config', 'json');

    return fetch(request);
  },
};

interface Env {
  RATE_LIMITER: DurableObjectNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const ip = request.headers.get('CF-Connecting-IP') ?? 'unknown';
    const key = `${ip}:${new URL(request.url).pathname}`;

    // Use Durable Object for consistent rate counting
    const id = env.RATE_LIMITER.idFromName(key);
    const limiter = env.RATE_LIMITER.get(id);

    const allowed = await limiter.fetch('https://internal/check');
    if (!allowed.ok) {
      return new Response('Rate limit exceeded', {
        status: 429,
        headers: { 'Retry-After': '60' },
      });
    }

    return fetch(request);
  },
};

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // Sticky assignment via cookie
    let variant = getCookie(request, 'ab-variant');
    if (!variant) {
      variant = Math.random() < 0.5 ? 'control' : 'experiment';
    }

    // Rewrite to variant-specific origin path
    if (variant === 'experiment' && url.pathname === '/pricing') {
      url.pathname = '/pricing-v2';
    }

    const response = await fetch(url.toString(), request);
    const newResponse = new Response(response.body, response);

    // Set sticky cookie so user stays in same variant
    newResponse.headers.append('Set-Cookie', `ab-variant=${variant}; Path=/; Max-Age=86400`);
    // Vary on cookie to prevent cache mixing variants
    newResponse.headers.set('Vary', 'Cookie');

    return newResponse;
  },
};

function getCookie(request: Request, name: string): string | null {
  const cookies = request.headers.get('Cookie') ?? '';
  const match = cookies.match(new RegExp(`${name}=([^;]+)`));
  return match ? match[1] : null;
}

// Hoist expensive initialization outside the fetch handler
// This runs once per isolate, not per request
const decoder = new TextDecoder();
const encoder = new TextEncoder();
const STATIC_CONFIG = { version: '1.0', maxRetries: 3 };

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const start = Date.now();

    // Use streaming to reduce memory pressure and TTFB
    const originResponse = await fetch('https://api.example.com/data');
    const { readable, writable } = new TransformStream();

    // Non-blocking: pipe transform in background
    ctx.waitUntil(transformStream(originResponse.body!, writable));

    // Log timing without blocking response
    ctx.waitUntil(
      Promise.resolve().then(() => {
        console.log(`Request processed in ${Date.now() - start}ms`);
      })
    );

    return new Response(readable, {
      headers: { 'Content-Type': 'application/json' },
    });
  },
};

async function transformStream(input: ReadableStream, output: WritableStream): Promise<void> {
  const reader = input.getReader();
  const writer = output.getWriter();
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      await writer.write(value);
    }
  } finally {
    await writer.close();
  }
}