import { createHash } from "node:crypto";

import fs from "node:fs/promises";

import path from "node:path";

import { ApplicationCommandType, type APIApplicationCommand } from "discord-api-types/v10";

import {

createApplicationCommand,

export class DiscordCommandDeployer {

private readonly hashes = new Map<string, string>();

private hashesLoaded = false;

constructor(

private readonly params: {

clientId: string;

commands: BaseCommand[];

devGuilds?: string[];

hashStorePath?: string;

rest: () => RequestClient;

},

) {}

options: { force?: boolean },

): Promise<void> {

const hash = stableCommandSetHash(commands);

await this.loadPersistedHashes();

if (!options.force && this.hashes.get(key) === hash) {

return;

}

await deploy();

this.hashes.set(key, hash);

await this.persistHashes();

}

private async loadPersistedHashes(): Promise<void> {

if (this.hashesLoaded) {

return;

}

this.hashesLoaded = true;

const storePath = this.params.hashStorePath;

if (!storePath) {

return;

}

try {

const raw = await fs.readFile(storePath, "utf8");

const parsed = JSON.parse(raw) as { hashes?: unknown };

if (!parsed.hashes || typeof parsed.hashes !== "object") {

return;

}

for (const [key, value] of Object.entries(parsed.hashes)) {

if (typeof value === "string" && key.trim() && value.trim()) {

this.hashes.set(key, value);

}

}

} catch {

// Best-effort cache only. A corrupt or missing file should never block startup.

}

}

private async persistHashes(): Promise<void> {

const storePath = this.params.hashStorePath;

if (!storePath) {

return;

}

try {

await fs.mkdir(path.dirname(storePath), { recursive: true });

const tmpPath = `${storePath}.${process.pid}.${Date.now()}.tmp`;

await fs.writeFile(

tmpPath,

`${JSON.stringify(

{

version: 1,

updatedAt: new Date().toISOString(),

hashes: Object.fromEntries(

[...this.hashes.entries()].toSorted(([left], [right]) => left.localeCompare(right)),

),

},

null,

2,

)}\n`,

"utf8",

);

await fs.rename(tmpPath, storePath);

} catch {

// The cache is only an optimization to avoid redundant Discord writes.

}

}

private get rest(): RequestClient {