// Balanced Mix: a bit of everything, woven together.
// Context of links you loved, your subscriptions, your watchlist and
// recent links picked for you. Change the weights to taste.
// Once the semantic watchlist's model is downloaded, every post gets a
// taste score from your ratings: posts like links you rated high come
// first, posts like links you rated low are left out.
const WEIGHTS = { loved: 4, following: 3, watchlist: 2, forYou: 1 };
const SIZE = 30;
// Leave out posts at least this much like links you rated low
// (-1 = only near-copies of them, 0 = anything leaning that way)
const LEAVE_OUT_BELOW = -0.1;

const blacklist = await api.getBlacklist();
const own = await api.getOwnPosts();
const rated = new Set(own.map(p => p.url));
const recent = await api.getLatestRatings(300);

// 1. Links you rated 8 or higher: what the other people who shared
//    them shared just before and after (like the Context Feed)
const me = new Set(own.map(p => p.identifier));
const loved = [];
for (const post of own.filter(p => p.enjoyment >= 8).slice(0, 15)) {
  const others = (await api.getRatingsOfLink(post.url)).filter(r => !me.has(r.identifier));
  for (const theirs of others.slice(0, 3)) {
    const around = await api.getChronologicalRatings(theirs.rating_id, 2, 2);
    if (around) loved.push(...around.previous_ratings, ...around.next_ratings);
  }
}

// 2. Newest from your subscriptions
const following = [];
for (const sub of await api.getSubscriptions()) {
  following.push(...(await api.getPostsByDid(sub.did)).slice(0, 5));
}
following.sort((a, b) => b.time - a.time);

// 3. Recent posts mentioning a watchlist word (as a whole word, so "go"
//    doesn't match "government")
const words = await api.getWatchlist();
const watchlist = recent.filter(item => {
  const text = `${item.post_text} ${item.url}`;
  return words.some(w => api.mentions(text, w));
});

// Taste scores for all candidates at once (null without the model)
const candidates = [...loved, ...following, ...watchlist, ...recent];
const scores = await api.tasteScores(candidates);
const taste = new Map(candidates.map((item, i) => [item.rating_id, scores?.[i]?.score ?? 0]));
const byTaste = (a, b) => taste.get(b.rating_id) - taste.get(a.rating_id);

// 4. For you: the recent links that fit your taste best
//    (a random handful while there are no taste scores)
const shuffled = recent.map(item => [Math.random(), item]).sort((a, b) => a[0] - b[0]).map(([, item]) => item);
const forYou = scores ? [...recent].sort(byTaste) : shuffled;

// Best matches first; subscriptions stay newest first
if (scores) {
  loved.sort(byTaste);
  watchlist.sort(byTaste);
}

const ok = (item) =>
  !blacklist.some(w => item.url.toLowerCase().includes(w)) &&
  taste.get(item.rating_id) >= LEAVE_OUT_BELOW;

// Weave: take from each source in proportion to its weight
const sources = Object.entries({ loved, following, watchlist, forYou })
  .map(([name, items]) => ({ items: items.filter(ok), weight: WEIGHTS[name], taken: 0 }));
const seen = new Set(rated);
const feed = [];
while (feed.length < SIZE && sources.some(s => s.items.length)) {
  // the source furthest behind its share goes next
  const next = sources
    .filter(s => s.items.length)
    .sort((a, b) => a.taken / a.weight - b.taken / b.weight)[0];
  const item = next.items.shift();
  if (seen.has(item.url)) continue;
  seen.add(item.url);
  next.taken++;
  feed.push(item);
}
return feed;

// Taste: recent links ranked purely by your taste score.
// Needs the embedding model (Algo tab: turn on "Also match by meaning" once).
const SIZE = 30;

const blacklist = await api.getBlacklist();
const seen = new Set((await api.getOwnPosts()).map(p => p.url)); // skip what you rated
const recent = (await api.getLatestRatings(500)).filter(item => {
  const text = `${item.post_text} ${item.url}`.toLowerCase();
  if (seen.has(item.url) || blacklist.some(w => text.includes(w))) return false;
  seen.add(item.url); // each link once
  return true;
});

const scores = await api.tasteScores(recent);
if (!scores) return recent.slice(0, SIZE); // no model yet: newest first

return recent
  .map((item, i) => ({ item, score: scores[i]?.score ?? 0 }))
  .sort((a, b) => b.score - a.score)
  .slice(0, SIZE)
  .map(({ item }) => item);

// Returns newest content in the db
return await api.getLatestRatings();

// Context Feed: for links you rated, find the other people
// who shared the same link and show what they shared just before and
// after it. Someone who shared a link you liked often shares more you'll
// like. Skips links you've rated, applies the blacklist, and tops up
// from your subscriptions to 20 items.
const blacklist = await api.getBlacklist();
const own = await api.getOwnPosts();
const me = new Set(own.map(p => p.identifier));
const seen = new Set(own.map(p => p.url));   // don't show what you already rated
const feed = [];
const add = (item) => {
  const url = item.url.toLowerCase();
  if (seen.has(item.url) || blacklist.some(word => url.includes(word))) return;
  seen.add(item.url);
  feed.push(item);
};

// Your best-rated links first, then the newest
const favourites = [...own].sort((a, b) => b.enjoyment - a.enjoyment || b.time - a.time);
for (const post of favourites.slice(0, 30)) {
  const others = (await api.getRatingsOfLink(post.url))
    .filter(r => !me.has(r.identifier));
  for (const theirs of others.slice(0, 5)) {
    const around = await api.getChronologicalRatings(theirs.rating_id, 2, 2);
    if (around) [...around.previous_ratings, ...around.next_ratings].forEach(add);
  }
}

// Fill up from subscriptions
if (feed.length < 20) {
  for (const sub of await api.getSubscriptions()) {
    if (feed.length >= 20) break;
    for (const p of await api.getPostsByDid(sub.did)) {
      if (feed.length >= 20) break;
      add(p);
    }
  }
}
return feed;

// Trending: links several different people shared recently.
// Each link scores by how many people posted it, fading with age
// (like Hacker News), so a link shared by 5 people today beats one
// shared by 8 people last week.
const blacklist = await api.getBlacklist();
const pool = await api.getLatestRatings(500);

const byUrl = new Map();
for (const item of pool) {
  const url = item.url.toLowerCase();
  if (blacklist.some(word => url.includes(word))) continue;
  const entry = byUrl.get(item.url) ?? { item, people: new Set() };
  entry.people.add(item.identifier);
  if (item.time > entry.item.time) entry.item = item; // show the newest post
  byUrl.set(item.url, entry);
}

const now = Date.now() / 1000;
const score = ({ item, people }) => {
  const ageHours = Math.max(0, now - item.time) / 3600;
  return people.size / Math.pow(ageHours + 2, 1.5);
};

return [...byUrl.values()]
  .filter(e => e.people.size >= 2) // at least two different people
  .sort((a, b) => score(b) - score(a))
  .slice(0, 30)
  .map(e => e.item);

// Following: only accounts you subscribed to, newest first, taking
// turns between accounts so one very active account can't fill the
// whole feed.
const blacklist = await api.getBlacklist();
const allowed = (item) =>
  !blacklist.some(word => item.url.toLowerCase().includes(word));

const subscriptions = await api.getSubscriptions();
const queues = [];
for (const sub of subscriptions) {
  const posts = (await api.getPostsByDid(sub.did))
    .filter(allowed)
    .sort((a, b) => b.time - a.time);
  if (posts.length) queues.push(posts);
}

// Round robin: each account's newest, then each account's next, ...
const feed = [];
const seenUrls = new Set();
while (feed.length < 40 && queues.some(q => q.length)) {
  for (const q of queues) {
    const item = q.shift();
    if (item && !seenUrls.has(item.url)) {
      seenUrls.add(item.url);
      feed.push(item);
    }
  }
}
return feed;

// Watchlist: recent posts that mention one of your watchlist words
// (as whole words) in the post text or the link. The more different words a post
// matches, the higher it ranks; ties go to the newest.
const watchlist = await api.getWatchlist();
if (watchlist.length === 0) return [];
const blacklist = await api.getBlacklist();

const hits = [];
for (const item of await api.getLatestRatings(500)) {
  const text = `${item.post_text} ${item.review_text} ${item.url}`.toLowerCase();
  if (blacklist.some(word => text.includes(word))) continue;
  const matched = watchlist.filter(word => api.mentions(text, word)).length;
  if (matched > 0) hits.push({ item, matched });
}

const seenUrls = new Set();
return hits
  .sort((a, b) => b.matched - a.matched || b.item.time - a.item.time)
  .map(h => h.item)
  .filter(item => !seenUrls.has(item.url) && seenUrls.add(item.url))
  .slice(0, 40);

// Fresh & Diverse: the newest links, but at most 2 from the same
// person and 3 from the same website, skipping links you've already
// rated yourself. Good for browsing without one source taking over.
const MAX_PER_PERSON = 2;
const MAX_PER_SITE = 3;

const blacklist = await api.getBlacklist();
const alreadyRated = new Set((await api.getOwnPosts()).map(p => p.url));
const site = (url) => url.replace(/^(https?:\/\/)?(www\.|m\.)?/, '').split(/[/?]/)[0];

const perPerson = new Map();
const perSite = new Map();
const seenUrls = new Set();
const feed = [];

for (const item of await api.getLatestRatings(300)) {
  const url = item.url.toLowerCase();
  if (blacklist.some(word => url.includes(word))) continue;
  if (alreadyRated.has(item.url) || seenUrls.has(item.url)) continue;

  const p = perPerson.get(item.identifier) ?? 0;
  const s = perSite.get(site(url)) ?? 0;
  if (p >= MAX_PER_PERSON || s >= MAX_PER_SITE) continue;

  perPerson.set(item.identifier, p + 1);
  perSite.set(site(url), s + 1);
  seenUrls.add(item.url);
  feed.push(item);
  if (feed.length >= 30) break;
}
return feed;