addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});

function parse_url(url) {
  const theURL = url instanceof URL ? url : new URL(url);
  return [theURL.pathname.split("/"), theURL.searchParams];
}

function uuidv4() {
  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) =>
    (
      c ^
      (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))
    ).toString(16),
  );
}

function ok(body, init) {
  return new Response(body, { ...init, status: 200 });
}

function handlePath(path, searchParams) {
  const uuid = path.length >= 2 && path[1];
  const response = path.length === 4 && path[3];
  if (response) {
    return { route: "respond", uuid, response, email: path[2] };
  } else if (uuid) {
    return { route: "summary", uuid };
  } else {
    return { route: "notfound", path, searchParams };
  }
}

async function get() {}

const routeHandlers = {
  async notfound({ path }) {
    return new Response(`invalid path ${path}`, { status: 404 });
  },
  async summary({ uuid }) {
    const settings = await RSVPS.get(`${uuid}:settings`);

    if (settings) {
      const rsvps = {};
      let args = { prefix: `${uuid}:response:` };
      let rawRSVPs;
      do {
        rawRSVPs = await RSVPS.list(args);
        for (let { name } of rawRSVPs.keys) {
          const [_, __, email] = name.split(":");
          const response = await RSVPS.get(name);
          rsvps[email] = response;
        }
        args = { cursor: rawRSVPs.cursor };
      } while (!rawRSVPs.list_complete);
      const responseData = {
        settings: JSON.parse(settings),
        rsvps,
      };
      return ok(JSON.stringify(responseData), {
        headers: { "Content-Type": "application/json" },
      });
    } else {
      return new Response(`invalid invite ${uuid}`, { status: 404 });
    }
  },

  async respond({ uuid, email, response }) {
    const settings = await RSVPS.get(`${uuid}:settings`);
    if (settings) {
      if (!email.includes("@")) {
        return new Response(`invalid email ${response}`, { status: 404 });
      }
      if (response === "yes" || response === "no" || response === "maybe") {
        await RSVPS.put(`${uuid}:response:${email}`, response);
        return new Response(`${uuid} ${email} ${response}`, { status: 200 });
      } else {
        return new Response(`invalid response ${response}`, { status: 404 });
      }
    } else {
      return new Response(`invalid invite ${uuid}`, { status: 404 });
    }
  },
};

const methodHandlers = {
  async GET(p, sp) {
    const route = handlePath(p, sp);
    return await routeHandlers[route.route](route);
  },
  async POST() {
    const inviteUUID = uuidv4();
    await RSVPS.put(`${inviteUUID}:settings`, "{}");
    return ok(inviteUUID);
  },
  default() {
    return new Response("405 unsupported", { status: 405 });
  },
};

/**
 * Respond with hello worker text
 * @param {Request} request
 */
async function handleRequest(request) {
  /** @type {number} */
  const nums = JSON.parse((await RSVPS.get("test:count")) || "0") + 1;
  await RSVPS.put("test:count", JSON.stringify(nums));
  const [p, sp] = parse_url(request.url);

  return await (methodHandlers[request.method] || methodHandlers.default)(
    p,
    sp,
  );
}