import fs from "node:fs";
import path from "node:path";
import { spawn, type ChildProcess } from "node:child_process";
import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
import type { Decision, DirigentConfig } from "./rules.js";
import { startModeratorPresence, stopModeratorPresence } from "./moderator-presence.js";
import { registerMessageReceivedHook } from "./hooks/message-received.js";
import { registerBeforeModelResolveHook } from "./hooks/before-model-resolve.js";
import { registerBeforePromptBuildHook } from "./hooks/before-prompt-build.js";
import { registerBeforeMessageWriteHook } from "./hooks/before-message-write.js";
import { registerMessageSentHook } from "./hooks/message-sent.js";
import { registerDirigentCommand } from "./commands/dirigent-command.js";
import { registerDirigentTools } from "./tools/register-tools.js";
import { getLivePluginConfig } from "./core/live-config.js";
import { ensurePolicyStateLoaded, persistPolicies, policyState } from "./policy/store.js";
import { buildAgentIdentity, buildUserIdToAccountIdMap, resolveAccountId } from "./core/identity.js";
import { extractMentionedUserIds, getModeratorUserId } from "./core/mentions.js";
import { ensureTurnOrder, recordChannelAccount } from "./core/turn-bootstrap.js";

// ── No-Reply API child process lifecycle ──────────────────────────────
let noReplyProcess: ChildProcess | null = null;

function startNoReplyApi(logger: { info: (m: string) => void; warn: (m: string) => void }, pluginDir: string, port = 8787): void {
  logger.info(`dirigent: startNoReplyApi called, pluginDir=${pluginDir}`);

  if (noReplyProcess) {
    logger.info("dirigent: no-reply API already running, skipping");
    return;
  }

  const serverPath = path.resolve(pluginDir, "..", "no-reply-api", "server.mjs");
  logger.info(`dirigent: resolved serverPath=${serverPath}`);

  if (!fs.existsSync(serverPath)) {
    logger.warn(`dirigent: no-reply API server not found at ${serverPath}, skipping`);
    return;
  }

  logger.info(`dirigent: no-reply API server found, spawning process...`);

  noReplyProcess = spawn(process.execPath, [serverPath], {
    env: { ...process.env, PORT: String(port) },
    stdio: ["ignore", "pipe", "pipe"],
    detached: false,
  });

  noReplyProcess.stdout?.on("data", (d: Buffer) => logger.info(`dirigent: no-reply-api: ${d.toString().trim()}`));
  noReplyProcess.stderr?.on("data", (d: Buffer) => logger.warn(`dirigent: no-reply-api: ${d.toString().trim()}`));

  noReplyProcess.on("exit", (code, signal) => {
    logger.info(`dirigent: no-reply API exited (code=${code}, signal=${signal})`);
    noReplyProcess = null;
  });

  logger.info(`dirigent: no-reply API started (pid=${noReplyProcess.pid}, port=${port})`);
}

function stopNoReplyApi(logger: { info: (m: string) => void }): void {
  if (!noReplyProcess) return;
  logger.info("dirigent: stopping no-reply API");
  noReplyProcess.kill("SIGTERM");
  noReplyProcess = null;
}

type DecisionRecord = {
  decision: Decision;
  createdAt: number;
  needsRestore?: boolean;
};

type DebugConfig = {
  enableDebugLogs?: boolean;
  debugLogChannelIds?: string[];
};

const sessionDecision = new Map<string, DecisionRecord>();
const sessionAllowed = new Map<string, boolean>(); // Track if session was allowed to speak (true) or forced no-reply (false)
const sessionInjected = new Set<string>(); // Track which sessions have already injected the end marker
const sessionChannelId = new Map<string, string>(); // Track sessionKey -> channelId mapping
const sessionAccountId = new Map<string, string>(); // Track sessionKey -> accountId mapping
const sessionTurnHandled = new Set<string>(); // Track sessions where turn was already advanced in before_message_write
const MAX_SESSION_DECISIONS = 2000;
const DECISION_TTL_MS = 5 * 60 * 1000;

function buildEndMarkerInstruction(endSymbols: string[], isGroupChat: boolean, schedulingIdentifier: string, waitIdentifier: string): string {
  const symbols = endSymbols.length > 0 ? endSymbols.join("") : "🔚";
  let instruction = `Your response MUST end with ${symbols}. Exception: gateway keywords (e.g. NO_REPLY, HEARTBEAT_OK) must NOT include ${symbols}.`;
  if (isGroupChat) {
    instruction += `\n\nGroup chat rules: If this message is not relevant to you, does not need your response, or you have nothing valuable to add, reply with NO_REPLY. Do not speak just for the sake of speaking.`;
    instruction += `\n\nWait for human reply: If you need a human to respond to your message, end with ${waitIdentifier} instead of ${symbols}. This pauses all agents until a human speaks. Use this sparingly — only when you are confident the human is actively participating in the discussion (has sent a message recently). Do NOT use it speculatively.`;
  }
  return instruction;
}

function buildSchedulingIdentifierInstruction(schedulingIdentifier: string): string {
  return `\n\nScheduling identifier: "${schedulingIdentifier}". This identifier itself is meaningless — it carries no semantic content. When you receive a message containing <@YOUR_USER_ID> followed by the scheduling identifier, check recent chat history and decide whether you have something to say. If not, reply NO_REPLY.`;
}

function pruneDecisionMap(now = Date.now()) {
  for (const [k, v] of sessionDecision.entries()) {
    if (now - v.createdAt > DECISION_TTL_MS) sessionDecision.delete(k);
  }

  if (sessionDecision.size <= MAX_SESSION_DECISIONS) return;
  const keys = sessionDecision.keys();
  while (sessionDecision.size > MAX_SESSION_DECISIONS) {
    const k = keys.next();
    if (k.done) break;
    sessionDecision.delete(k.value);
  }
}

// --- Moderator bot helpers ---

/** Extract Discord user ID from a bot token (base64-encoded in first segment) */
function userIdFromToken(token: string): string | undefined {
  try {
    const segment = token.split(".")[0];
    // Add padding
    const padded = segment + "=".repeat((4 - (segment.length % 4)) % 4);
    return Buffer.from(padded, "base64").toString("utf8");
  } catch {
    return undefined;
  }
}

/** Resolve accountId → Discord user ID by reading the account's bot token from config */
function resolveDiscordUserId(api: OpenClawPluginApi, accountId: string): string | undefined {
  const root = (api.config as Record<string, unknown>) || {};
  const channels = (root.channels as Record<string, unknown>) || {};
  const discord = (channels.discord as Record<string, unknown>) || {};
  const accounts = (discord.accounts as Record<string, Record<string, unknown>>) || {};
  const acct = accounts[accountId];
  if (!acct?.token || typeof acct.token !== "string") return undefined;
  return userIdFromToken(acct.token);
}

/** Send a message as the moderator bot via Discord REST API */
async function sendModeratorMessage(token: string, channelId: string, content: string, logger: { info: (msg: string) => void; warn: (msg: string) => void }): Promise<boolean> {
  try {
    const r = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
      method: "POST",
      headers: {
        "Authorization": `Bot ${token}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ content }),
    });
    if (!r.ok) {
      const text = await r.text();
      logger.warn(`dirigent: moderator send failed (${r.status}): ${text}`);
      return false;
    }
    logger.info(`dirigent: moderator message sent to channel=${channelId}`);
    return true;
  } catch (err) {
    logger.warn(`dirigent: moderator send error: ${String(err)}`);
    return false;
  }
}

function pickDefined(input: Record<string, unknown>) {
  const out: Record<string, unknown> = {};
  for (const [k, v] of Object.entries(input)) {
    if (v !== undefined) out[k] = v;
  }
  return out;
}

function shouldDebugLog(cfg: DebugConfig, channelId?: string): boolean {
  if (!cfg.enableDebugLogs) return false;
  const allow = Array.isArray(cfg.debugLogChannelIds) ? cfg.debugLogChannelIds : [];
  if (allow.length === 0) return true;
  if (!channelId) return true;
  return allow.includes(channelId);
}

function debugCtxSummary(ctx: Record<string, unknown>, event: Record<string, unknown>) {
  const meta = ((ctx.metadata || event.metadata || {}) as Record<string, unknown>) || {};
  return {
    sessionKey: typeof ctx.sessionKey === "string" ? ctx.sessionKey : undefined,
    commandSource: typeof ctx.commandSource === "string" ? ctx.commandSource : undefined,
    messageProvider: typeof ctx.messageProvider === "string" ? ctx.messageProvider : undefined,
    channel: typeof ctx.channel === "string" ? ctx.channel : undefined,
    channelId: typeof ctx.channelId === "string" ? ctx.channelId : undefined,
    senderId: typeof ctx.senderId === "string" ? ctx.senderId : undefined,
    from: typeof ctx.from === "string" ? ctx.from : undefined,
    metaSenderId:
      typeof meta.senderId === "string"
        ? meta.senderId
        : typeof meta.sender_id === "string"
          ? meta.sender_id
          : undefined,
    metaUserId:
      typeof meta.userId === "string"
        ? meta.userId
        : typeof meta.user_id === "string"
          ? meta.user_id
          : undefined,
  };
}

export default {
  id: "dirigent",
  name: "Dirigent",
  register(api: OpenClawPluginApi) {
    // Merge pluginConfig with defaults (in case config is missing from openclaw.json)
    const baseConfig = {
      enableDiscordControlTool: true,
      enableDirigentPolicyTool: true,
      discordControlApiBaseUrl: "http://127.0.0.1:8790",
      schedulingIdentifier: "➡️",
      waitIdentifier: "👤",
      ...(api.pluginConfig || {}),
    } as DirigentConfig & {
      enableDiscordControlTool: boolean;
      discordControlApiBaseUrl: string;
      discordControlApiToken?: string;
      discordControlCallerId?: string;
      enableDirigentPolicyTool: boolean;
    };

    const liveAtRegister = getLivePluginConfig(api, baseConfig as DirigentConfig);
    ensurePolicyStateLoaded(api, liveAtRegister);

    // Resolve plugin directory for locating sibling modules (no-reply-api/)
    // Note: api.resolvePath(".") returns cwd, not script directory. Use import.meta.url instead.
    const pluginDir = path.dirname(new URL(import.meta.url).pathname);
    api.logger.info(`dirigent: pluginDir resolved from import.meta.url: ${pluginDir}`);

    // Gateway lifecycle: start/stop no-reply API and moderator bot with the gateway
    api.on("gateway_start", () => {
      api.logger.info(`dirigent: gateway_start event received`);

      // Check no-reply-api server file exists
      const serverPath = path.resolve(pluginDir, "..", "no-reply-api", "server.mjs");
      api.logger.info(`dirigent: checking no-reply-api server at ${serverPath}, exists=${fs.existsSync(serverPath)}`);

      // Additional debug: list what's in the parent directory
      const parentDir = path.resolve(pluginDir, "..");
      try {
        const entries = fs.readdirSync(parentDir);
        api.logger.info(`dirigent: parent dir (${parentDir}) entries: ${JSON.stringify(entries)}`);
      } catch (e) {
        api.logger.warn(`dirigent: cannot read parent dir: ${String(e)}`);
      }

      startNoReplyApi(api.logger, pluginDir);

      const live = getLivePluginConfig(api, baseConfig as DirigentConfig);
      api.logger.info(`dirigent: config loaded, moderatorBotToken=${live.moderatorBotToken ? "[set]" : "[not set]"}`);

      if (live.moderatorBotToken) {
        api.logger.info("dirigent: starting moderator bot presence...");
        startModeratorPresence(live.moderatorBotToken, api.logger);
        api.logger.info("dirigent: moderator bot presence started");
      } else {
        api.logger.info("dirigent: moderator bot not starting - no moderatorBotToken in config");
      }
    });

    api.on("gateway_stop", () => {
      stopNoReplyApi(api.logger);
      stopModeratorPresence();
      api.logger.info("dirigent: gateway stopping, services shut down");
    });

    // Register tools
    registerDirigentTools({
      api,
      baseConfig: baseConfig as DirigentConfig,
      policyState,
      pickDefined,
      persistPolicies,
      ensurePolicyStateLoaded,
      getLivePluginConfig,
    });

    // Turn management is handled internally by the plugin (not exposed as tools).
    // Use `/dirigent turn-status`, `/dirigent turn-advance`, `/dirigent turn-reset` for manual control.

    registerMessageReceivedHook({
      api,
      baseConfig: baseConfig as DirigentConfig,
      getLivePluginConfig,
      shouldDebugLog,
      debugCtxSummary,
      ensureTurnOrder,
      getModeratorUserId,
      recordChannelAccount,
      extractMentionedUserIds,
      buildUserIdToAccountIdMap,
    });

    registerBeforeModelResolveHook({
      api,
      baseConfig: baseConfig as DirigentConfig,
      sessionDecision,
      sessionAllowed,
      sessionChannelId,
      sessionAccountId,
      policyState,
      DECISION_TTL_MS,
      ensurePolicyStateLoaded,
      getLivePluginConfig,
      resolveAccountId,
      pruneDecisionMap,
      shouldDebugLog,
      ensureTurnOrder,
    });

    registerBeforePromptBuildHook({
      api,
      baseConfig: baseConfig as DirigentConfig,
      sessionDecision,
      sessionInjected,
      policyState,
      DECISION_TTL_MS,
      ensurePolicyStateLoaded,
      getLivePluginConfig,
      shouldDebugLog,
      buildEndMarkerInstruction,
      buildSchedulingIdentifierInstruction,
      buildAgentIdentity,
    });

    // Register slash commands for Discord
    registerDirigentCommand({
      api,
      policyState,
    });

    // Handle NO_REPLY detection before message write
    registerBeforeMessageWriteHook({
      api,
      baseConfig: baseConfig as DirigentConfig,
      policyState,
      sessionAllowed,
      sessionChannelId,
      sessionAccountId,
      sessionTurnHandled,
      ensurePolicyStateLoaded,
      getLivePluginConfig,
      shouldDebugLog,
      ensureTurnOrder,
      resolveDiscordUserId,
      sendModeratorMessage,
    });

    // Turn advance: when an agent sends a message, check if it signals end of turn
    registerMessageSentHook({
      api,
      baseConfig: baseConfig as DirigentConfig,
      policyState,
      sessionChannelId,
      sessionAccountId,
      sessionTurnHandled,
      ensurePolicyStateLoaded,
      getLivePluginConfig,
      resolveDiscordUserId,
      sendModeratorMessage,
    });
  },
};