import { createHash } from "node:crypto";

import os from "node:os";

import path from "node:path";

import { loadJsonFile } from "openclaw/plugin-sdk/json-store";

import type { PluginStateSyncKeyedStore } from "openclaw/plugin-sdk/plugin-state-runtime";

import {

releaseFeishuMessageProcessing,

};

const memory = new Map<string, number>();

const importedLegacyNamespaces = new Set<string>();

const cachedDedupStores = new Map<string, PluginStateSyncKeyedStore<FeishuDedupStoreEntry>>();

type LegacyDedupeData = Record<string, number>;

function normalizeMessageId(messageId: string | undefined | null): string | null {

const trimmed = messageId?.trim();

return trimmed ? trimmed : null;

return namespace?.trim() || "global";

}

function resolveLegacyStateDir(env: NodeJS.ProcessEnv = process.env): string {

const stateOverride = env.OPENCLAW_STATE_DIR?.trim();

if (stateOverride) {

return stateOverride;

}

if (env.VITEST || env.NODE_ENV === "test") {

return path.join(os.tmpdir(), ["openclaw-vitest", String(process.pid)].join("-"));

}

return path.join(os.homedir(), ".openclaw");

}

function resolveLegacyNamespaceFilePath(namespace: string): string {

const safe = namespace.replace(/[^a-zA-Z0-9_-]/g, "_");

return path.join(resolveLegacyStateDir(), "feishu", "dedup", `${safe}.json`);

}

function pluginStateNamespace(namespace: string): string {

return `dedup.${namespace.replace(/[^a-zA-Z0-9_-]/g, "_")}`;

}

return false;

}

function sanitizeLegacyDedupeData(value: unknown): LegacyDedupeData {

if (!value || typeof value !== "object" || Array.isArray(value)) {

return {};

}

const out: LegacyDedupeData = {};

for (const [key, seenAt] of Object.entries(value as Record<string, unknown>)) {

if (typeof seenAt === "number" && Number.isFinite(seenAt) && seenAt > 0) {

out[key] = seenAt;

}

}

return out;

}

function importLegacyDedupNamespace(

namespace: string,

now = Date.now(),

log?: (...args: unknown[]) => void,

): void {

if (importedLegacyNamespaces.has(namespace)) {

return;

}

try {

const data = sanitizeLegacyDedupeData(loadJsonFile(resolveLegacyNamespaceFilePath(namespace)));

const store = openDedupStore(namespace);

for (const [messageId, seenAt] of Object.entries(data)) {

if (!isRecent(seenAt, now)) {

continue;

}

const key = dedupeStoreKey(namespace, messageId);

if (store.lookup(key) != null) {

continue;

}

store.register(

key,

{ namespace, messageId, seenAt },

{ ttlMs: Math.max(1, DEDUP_TTL_MS - (now - seenAt)) },

);

}

importedLegacyNamespaces.add(namespace);

} catch (error) {

importedLegacyNamespaces.delete(namespace);

log?.(`feishu-dedup: legacy state import failed: ${String(error)}`);

}

}

export { releaseFeishuMessageProcessing, tryBeginFeishuMessageProcessing };

export async function claimUnprocessedFeishuMessage(params: {

return true;

}

const now = Date.now();

importLegacyDedupNamespace(normalizedNamespace, now, log);

if (hasMemory(normalizedNamespace, normalizedMessageId, now)) {

return false;

}

return false;

}

const now = Date.now();

importLegacyDedupNamespace(normalizedNamespace, now, log);

if (hasMemory(normalizedNamespace, normalizedMessageId, now)) {

return true;

}

}

}

export async function warmupDedupFromDisk(

export async function warmupDedupFromPluginState(

namespace: string,

log?: (...args: unknown[]) => void,

): Promise<number> {

const normalizedNamespace = normalizeNamespace(namespace);

try {

let loaded = 0;

const now = Date.now();

importLegacyDedupNamespace(normalizedNamespace, now, log);

for (const entry of openDedupStore(normalizedNamespace).entries()) {

if (entry.value.namespace !== normalizedNamespace || !isRecent(entry.value.seenAt, now)) {

continue;

export const testingHooks = {

resetFeishuDedupForTests() {

memory.clear();

importedLegacyNamespaces.clear();

for (const store of cachedDedupStores.values()) {

store.clear();

}