tg-bot-ts/src/systems/updates.ts

/**
 * Updates — manages bot changelog/update posts.
 *
 * Usage:
 *   import { Updates } from "@systems/updates";
 *
 *   Updates.list()
 *   Updates.latest()
 *   Updates.get({ version: "v0.8" })
 *   Updates.post({ version: "v0.8", client })
 *   Updates.preview({ version: "v0.8", interaction })
 */

 import path from "path";
 import { Client, EmbedBuilder, TextChannel, MessageFlags } from "discord.js";
 import { ChatInputCommandInteraction } from "discord.js";
 import { Store } from "@systems/store";
 import { Paths } from "@paths";
 import { Emoji } from "@systems/emojis";
 import { Config } from "@systems/config";
 import { Logger } from "@systems/logger";
 import { PollUI } from "@ui/poll";
 import { Nation, VoteEntry, PollState } from "@types";
 import { WRank, WRankEntry } from "@systems/wrank";
 import { Leaves } from "@systems/leaves";
 
 const log = Logger.for("updates");
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 interface UpdateItem {
   text:     string;
   emojiKey: string | null;
 }
 
 interface UpdateSection {
   type:  "new" | "improvement" | "fix" | "technical";
   label: string;
   emoji: string;
   items: UpdateItem[];
 }
 
 interface UpdateExample {
   caption: string;
   type:    "poll";
   layout:  string;
   file:    string;
 }
 
 export interface UpdateEntry {
   version:   string;
   date:      string;
   title:     string;
   layout:    string;
   messageId: string | null;
   sections:  UpdateSection[];
   examples:  UpdateExample[];
 }
 
 interface VersionsIndex {
   latest:   string;
   versions: string[];
 }
 
 interface ExamplePollState {
   slot:     number;
   locked:   boolean;
   confirmed: "yes" | "no" | null;
   yes:      VoteEntry[];
   no:       VoteEntry[];
   wrank?:   {
     characterName: string;
     userKey:       string;
     nation:        Nation;
     currentRank:   number;
     previousRank?: number;
     weeklyPoints:  number;
     tgCount:       number;
   }[];
   leaves?: {
     characterName: string;
     historyKey:    string;
   }[];
 }
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function updatesDir(): string {
   return Paths.data("updates");
 }
 
 function versionDir(version: string): string {
   return path.join(updatesDir(), version);
 }
 
 function buildUpdateEmbed(entry: UpdateEntry): EmbedBuilder {
   const embed = new EmbedBuilder()
     .setTitle(`⚔️ The Arbiter — ${entry.version}  ·  ${entry.date}`)
     .setColor(0xe8a317)
     .setTimestamp();
 
   // Build description from sections
   const lines: string[] = [];
 
   for (const section of entry.sections) {
     lines.push(`${section.emoji} **${section.label}**`);
     for (const item of section.items) {
       const emojiStr = item.emojiKey ? (Emoji.get(item.emojiKey) || "•") : "•";
       lines.push(`${emojiStr} ${item.text}`);
     }
     lines.push("");
   }
 
   embed.setDescription(lines.join("\n").trim());
   embed.setFooter({ text: `${entry.version} — ${entry.title}` });
 
   return embed;
 }
 
 function buildExamplePollState(exampleData: ExamplePollState): PollState {
   // Build yes/no Maps
   const yes = new Map<string, VoteEntry>();
   const no  = new Map<string, VoteEntry>();
 
   for (const entry of exampleData.yes) {
     yes.set(entry.userKey ?? entry.displayName ?? entry.characterName ?? "", entry);
   }
   for (const entry of exampleData.no) {
     no.set(entry.userKey ?? entry.displayName ?? "", entry);
   }
 
   return {
     slot:      exampleData.slot,
     locked:    exampleData.locked,
     confirmed: exampleData.confirmed,
     yes,
     no,
   };
 }
 
 function injectMockWrank(exampleData: ExamplePollState): (() => void) | null {
   if (!exampleData.wrank?.length) return null;
 
   // We inject mock wrank entries temporarily into WRank's current week
   // and return a cleanup function to restore the original state
   const week     = WRank.currentWeek();
   const original = JSON.parse(JSON.stringify(week.entries));
 
   // Temporarily replace entries with mock data
   week.entries[Nation.Capella] = [];
   week.entries[Nation.Procyon] = [];
 
   for (const e of exampleData.wrank) {
     const nation = e.nation === Nation.Capella ? Nation.Capella : Nation.Procyon;
     week.entries[nation].push({
       userKey:       e.userKey,
       characterName: e.characterName,
       class:         "WI" as any,
       nation,
       weeklyPoints:  e.weeklyPoints,
       tgCount:       e.tgCount,
       currentRank:   e.currentRank,
       previousRank:  e.previousRank,
     });
   }
 
   // Return cleanup function
   return () => {
     week.entries[Nation.Capella] = original[Nation.Capella] ?? [];
     week.entries[Nation.Procyon] = original[Nation.Procyon] ?? [];
   };
 }
 
 function injectMockLeaves(exampleData: ExamplePollState): (() => void) | null {
   if (!exampleData.leaves?.length) return null;
 
   // Mark leaves temporarily
   for (const l of exampleData.leaves) {
     Leaves.mark({
       characterName: l.characterName,
       ownerKey:      "example",
       historyKey:    l.historyKey as any,
       markedBy:      "example",
     });
   }
 
   return () => {
     if (!exampleData.leaves) return;
     for (const l of exampleData.leaves) {
       Leaves.unmark({ characterName: l.characterName, historyKey: l.historyKey as any });
     }
   };
 }
 
 // ─── Updates namespace ────────────────────────────────────────────────────────
 
 export const Updates = {
   list(): string[] {
     const index = Store.read<VersionsIndex>(path.join(updatesDir(), "versions.json"));
     return index?.versions ?? [];
   },
 
   latest(): string | null {
     const index = Store.read<VersionsIndex>(path.join(updatesDir(), "versions.json"));
     return index?.latest ?? null;
   },
 
   get({ version }: { version: string }): UpdateEntry | null {
     return Store.read<UpdateEntry>(path.join(versionDir(version), "update.json"));
   },
 
   setMessageId({ version, messageId }: { version: string; messageId: string }): void {
     const entry = Updates.get({ version });
     if (!entry) return;
     entry.messageId = messageId;
     Store.write(path.join(versionDir(version), "update.json"), entry);
   },
 
   buildEmbeds(entry: UpdateEntry): EmbedBuilder[] {
     const embeds: EmbedBuilder[] = [buildUpdateEmbed(entry)];
 
     // Build example embeds
     for (const example of entry.examples) {
       const examplePath = path.join(versionDir(entry.version), example.file);
       const exampleData = Store.read<ExamplePollState>(examplePath);
       if (!exampleData) continue;
 
       // Inject mock data
       const cleanupWrank  = injectMockWrank(exampleData);
       const cleanupLeaves = injectMockLeaves(exampleData);
 
       try {
         // Set the layout
         PollUI.setLayout(example.layout);
 
         // Build the poll state
         const state = buildExamplePollState(exampleData);
 
         // Build embed using the real poll UI
         const exampleEmbed = PollUI.buildEmbed(state, { overrideLockMsg: example.caption });
        //  exampleEmbed.setTitle(""); // no title for examples
         embeds.push(exampleEmbed);
       } finally {
         cleanupWrank?.();
         cleanupLeaves?.();
         PollUI.setLayout(Config.get({ section: "poll", key: "layout" }));
       }
     }
 
     return embeds;
   },
 
   async post({ version, client }: { version: string; client: Client }): Promise<void> {
     const entry = Updates.get({ version });
     if (!entry) {
       log.error(`Version ${version} not found`);
       return;
     }
 
     const channelId = Config.get({ section: "channels", key: "updates" });
     if (!channelId) {
       log.error("updates channel not configured");
       return;
     }
 
     const channel = await client.channels.fetch(channelId) as TextChannel;
     const embeds  = Updates.buildEmbeds(entry);
 
     if (entry.messageId) {
       // Edit existing message
       try {
         const msg = await channel.messages.fetch(entry.messageId);
         await msg.edit({ embeds });
         log.info(`Edited update ${version} (${entry.messageId})`);
         return;
       } catch {
         log.warn(`Could not edit message ${entry.messageId}, posting new`);
       }
     }
 
     // Post new message
     const msg = await channel.send({ embeds });
     Updates.setMessageId({ version, messageId: msg.id });
     log.info(`Posted update ${version} (${msg.id})`);
   },
 
   async preview({ version, interaction }: {
     version:     string;
     interaction: ChatInputCommandInteraction;
   }): Promise<void> {
     const entry = Updates.get({ version });
     if (!entry) {
       await interaction.reply({ content: `❌ Version \`${version}\` not found.`, flags: MessageFlags.Ephemeral });
       return;
     }
 
     const embeds = Updates.buildEmbeds(entry);
     await interaction.reply({ embeds, flags: MessageFlags.Ephemeral });
   },
 };