Source

// Votes: one record per person per post (plus the same record listed under the person), written in the
// same batch that moves the post's count by exactly one. The policy refuses anything else.
import { get, set, setMany, increment, serverTimestamp } from "@bounded-sh/client";
import { me, signIn } from "./bounded";
import { visitedBoards } from "./mine";

export function castVote(boardId: string, postId: string, uid: string) {
  return setMany([
    { path: `boards/${boardId}/posts/${postId}`, document: { votes: increment(1) } },
    { path: `boards/${boardId}/posts/${postId}/votes/${uid}`, document: { at: serverTimestamp() } },
    { path: `boards/${boardId}/people/${uid}/votes/${postId}`, document: { at: serverTimestamp() } },
  ]);
}

export function removeVote(boardId: string, postId: string, uid: string) {
  return setMany([
    { path: `boards/${boardId}/posts/${postId}`, document: { votes: increment(-1) } },
    { path: `boards/${boardId}/posts/${postId}/votes/${uid}`, document: null },
    { path: `boards/${boardId}/people/${uid}/votes/${postId}`, document: null },
  ]);
}

const rows = (res: any): any[] => (Array.isArray(res) ? res : res?.data ?? []);
const idOf = (r: any) => String(r.id ?? String(r._id ?? "").split("/").pop());

/** Every vote this person has on a board, as post ids. */
export async function votesOn(boardId: string, uid: string): Promise<string[]> {
  return rows(await get(`boards/${boardId}/people/${uid}/votes`, { limit: 1000 })).map(idOf);
}

// Signing in makes a new account, so a guest's votes would stay behind (and count twice if cast again).
// Before leaving for sign-in the guest takes its votes off and notes them here; whoever comes back
// (the account, or the same guest if sign-in was cancelled) puts them back.
const CARRY = "feedback:carry";
interface Carry { from: string; votes: { b: string; p: string }[] }

export async function signInKeepingVotes(): Promise<void> {
  const m = await me();
  if (!m.guest) return;
  const carry: Carry = { from: m.id, votes: [] };
  for (const b of visitedBoards()) {
    let posts: string[] = [];
    try { posts = await votesOn(b, m.id); } catch { continue; /* a board we cannot read anymore */ }
    for (const p of posts) {
      try {
        await removeVote(b, p, m.id);
        carry.votes.push({ b, p });
        localStorage.setItem(CARRY, JSON.stringify(carry));
      } catch { /* this vote stays with the guest */ }
    }
  }
  await signIn();
}

let carried: Promise<number> | null = null;

/** Puts carried votes back under whoever is signed in now. Resolves to how many came back. */
export function restoreCarriedVotes(): Promise<number> {
  carried ??= (async () => {
    let carry: Carry | null = null;
    try { carry = JSON.parse(localStorage.getItem(CARRY) || "null"); } catch { /* ignore */ }
    if (!carry?.votes?.length) { localStorage.removeItem(CARRY); return 0; }
    const m = await me();
    let back = 0;
    for (const { b, p } of carry.votes) {
      try {
        if (!(await get(`boards/${b}/joins/${m.id}`))) await set(`boards/${b}/joins/${m.id}`, { at: serverTimestamp() });
        if (await get(`boards/${b}/people/${m.id}/votes/${p}`)) continue;
        const post = await get(`boards/${b}/posts/${p}`);
        if (!post || post.merged) continue;
        await castVote(b, p, m.id);
        back++;
      } catch { /* the post or board is gone */ }
    }
    localStorage.removeItem(CARRY);
    return back;
  })();
  return carried;
}