/* eslint-disable */
/* tslint:disable */

/**
 * Mock Service Worker
 * @see https://mswjs.io
 * - Please do NOT modify this file
 * - Please do NOT serve this file on production
 */

const INTEGRITY_CHECKSUM = '7299013926a002954d549491a3946622';
const bypassHeaderName = 'x-msw-bypass';

let clients = new Set();
let workerId = Math.random().toString(36).substring(2, 15);

self.addEventListener('install', function () {
  return self.skipWaiting();
});

self.addEventListener('activate', function (event) {
  return event.waitUntil(self.clients.claim());
});

self.addEventListener('message', async function (event) {
  const clientId = event.source.id;
  const client = await self.clients.get(clientId);

  if (!client) {
    return;
  }

  switch (event.data.type) {
    case 'KEEPALIVE_REQUEST': {
      sendToClient(client, {
        type: 'KEEPALIVE_RESPONSE',
      });
      break;
    }

    case 'INTEGRITY_CHECK_REQUEST': {
      sendToClient(client, {
        type: 'INTEGRITY_CHECK_RESPONSE',
        payload: {
          checksum: INTEGRITY_CHECKSUM,
        },
      });
      break;
    }

    case 'MOCK_ACTIVATE': {
      clients.add(clientId);

      sendToClient(client, {
        type: 'MOCKING_ENABLED',
        payload: {
          workerId,
        },
      });
      break;
    }

    case 'MOCK_DEACTIVATE': {
      clients.delete(clientId);
      break;
    }

    default:
      break;
  }
});

self.addEventListener('fetch', function (event) {
  const request = event.request;
  const requestUrl = new URL(request.url);

  // Bypass navigation requests.
  if (request.mode === 'navigate') {
    return;
  }

  // Bypass requests with the bypass header.
  if (request.headers.get(bypassHeaderName) === 'true') {
    const modifiedHeaders = new Headers(request.headers);
    modifiedHeaders.delete(bypassHeaderName);

    return event.respondWith(
      fetch(request.url, {
        ...request,
        headers: modifiedHeaders,
      })
    );
  }

  // Bypass non-GET requests when not in the workers list.
  if (request.method !== 'GET' && !clients.has(event.clientId)) {
    return;
  }

  // Bypass requests to non-relative URLs.
  if (requestUrl.origin !== location.origin) {
    return;
  }

  event.respondWith(
    handleRequest(event)
      .catch((error) => {
        console.error('[MSW] Failed to handle request:', error);
        return fetch(request);
      })
  );
});

async function handleRequest(event) {
  const client = await self.clients.get(event.clientId);

  if (!client) {
    return fetch(event.request);
  }

  const response = await sendToClient(client, {
    type: 'REQUEST',
    payload: {
      id: Math.random().toString(36).substring(2, 15),
      url: event.request.url,
      method: event.request.method,
      headers: Object.fromEntries(event.request.headers.entries()),
      cache: event.request.cache,
      mode: event.request.mode,
      credentials: event.request.credentials,
      destination: event.request.destination,
      integrity: event.request.integrity,
      keepalive: event.request.keepalive,
      referrer: event.request.referrer,
      referrerPolicy: event.request.referrerPolicy,
      body: await getRequestBody(event.request),
      bodyUsed: event.request.bodyUsed,
      redirect: event.request.redirect,
      referrerPolicy: event.request.referrerPolicy,
      signal: event.request.signal,
      url: event.request.url,
      method: event.request.method,
    },
  });

  if (!response) {
    return fetch(event.request);
  }

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

function getRequestBody(request) {
  const contentType = request.headers.get('content-type');

  if (contentType && contentType.includes('application/json')) {
    return request.clone().json();
  }

  if (contentType && contentType.includes('application/x-www-form-urlencoded')) {
    return request.clone().formData();
  }

  return request.clone().text();
}

function sendToClient(client, message) {
  return new Promise((resolve, reject) => {
    const channel = new MessageChannel();

    channel.port1.onmessage = (event) => {
      if (event.data.error) {
        reject(event.data.error);
      } else {
        resolve(event.data);
      }
    };

    client.postMessage(message, [channel.port2]);
  });
}