import {
  normalizeOptionalLowercaseString,
  normalizeOptionalString,
} from "@openclaw/normalization-core/string-coerce";
import {
  ErrorCodes,
  errorShape,
  missingScopeErrorShape,
} from "../../../packages/gateway-protocol/src/index.js";
import type { OpenClawConfig } from "../../config/types.openclaw.js";
import { assertAgentRunLifecycleGenerationCurrent } from "../../infra/agent-events.js";
import { assertPreparedSkillLibrarySelection } from "../../skills/library/selection.js";
import { AGENT_SESSION_RESET_COMMAND_RE } from "../agent-command-policy.js";
import { setGatewayDedupeEntries } from "../agent-turn/agent-dedupe.js";
import { clientHasAdminScope } from "../agent-turn/agent-handler-helpers.js";
import { ADMIN_SCOPE } from "../method-scopes.js";
import { prepareSkillLibrarySessionCreation } from "../skill-library-session.js";
import { formatForLog } from "../ws-log.js";
import type { AgentRunRequest } from "./agent-request-types.js";
import {
  buildBareSessionResetResponse,
  loadBareSessionResetDeliverySession,
  resolveBareSessionResetResult,
  runSessionResetFromAgent,
} from "./agent-session-reset.js";
import { emitSessionsChanged } from "./session-change-event.js";
import { resolveAgentRunSessionCreation } from "./session-creation-provenance.js";
import type { GatewayRequestHandlerOptions } from "./types.js";

export type CommittedResetCompletion = {
  reason: "new" | "reset";
  sessionId?: string;
  sessionKey: string;
  agentId?: string;
  followUpPending: boolean;
};

type AgentResetPhaseResult = {
  stop: boolean;
  accepted: boolean;
  requestedSessionKey?: string;
  resolvedSessionId?: string;
  effectiveTranscriptInputText: string;
  message: string;
};

export async function runAgentResetPhase(params: {
  assertAdmissionCurrent?: () => void;
  request: AgentRunRequest;
  cfg: OpenClawConfig;
  requestedSessionKey?: string;
  resolvedSessionId?: string;
  effectiveTranscriptInputText: string;
  message: string;
  agentId?: string;
  sessionKeyFromTo?: string;
  lifecycleGeneration: string;
  runId: string;
  agentDedupeKeys: readonly string[];
  client: GatewayRequestHandlerOptions["client"];
  context: GatewayRequestHandlerOptions["context"];
  respond: GatewayRequestHandlerOptions["respond"];
  abortForLifecycleRotation: (target?: { sessionKey?: string; agentId?: string }) => boolean;
  setCommittedResetCompletion: (completion: CommittedResetCompletion) => void;
}): Promise<AgentResetPhaseResult> {
  const base = {
    requestedSessionKey: params.requestedSessionKey,
    resolvedSessionId: params.resolvedSessionId,
    effectiveTranscriptInputText: params.effectiveTranscriptInputText,
    message: params.message,
  };
  const resetCommandMatch = params.message.match(AGENT_SESSION_RESET_COMMAND_RE);
  if (!resetCommandMatch || !params.requestedSessionKey) {
    return { ...base, stop: false, accepted: false };
  }
  if (
    params.abortForLifecycleRotation({
      sessionKey: params.requestedSessionKey,
      agentId: params.agentId,
    })
  ) {
    return { ...base, stop: true, accepted: true };
  }
  const postResetMessage = normalizeOptionalString(resetCommandMatch[2]) ?? "";
  if (!clientHasAdminScope(params.client)) {
    params.respond(
      false,
      undefined,
      missingScopeErrorShape({ missingScope: ADMIN_SCOPE, requiredScopes: [ADMIN_SCOPE] }),
    );
    return { ...base, stop: true, accepted: false };
  }
  const resetReason =
    normalizeOptionalLowercaseString(resetCommandMatch[1]) === "new" ? "new" : "reset";
  let resetResult: Awaited<ReturnType<typeof runSessionResetFromAgent>>;
  try {
    const creation = prepareSkillLibrarySessionCreation(
      params.client,
      params.context.getRuntimeConfig,
      resolveAgentRunSessionCreation(params.client),
    );
    resetResult = await runSessionResetFromAgent({
      key: params.requestedSessionKey,
      ...(params.agentId ? { agentId: params.agentId } : {}),
      reason: resetReason,
      creation,
      ...(params.client?.authenticatedUserProfile
        ? { requestingOperatorProfileId: params.client.authenticatedUserProfile.profileId }
        : {}),
      ...(params.client?.internal?.operatorRoleActor
        ? { operatorRoleActor: params.client.internal.operatorRoleActor }
        : {}),
      assertCurrent: () => {
        params.assertAdmissionCurrent?.();
        assertAgentRunLifecycleGenerationCurrent(params.lifecycleGeneration);
        assertPreparedSkillLibrarySelection(creation.skillLibrarySelections);
      },
      onCommitted: (commit) => {
        params.setCommittedResetCompletion({
          reason: resetReason,
          sessionId: commit.sessionId,
          sessionKey: commit.key,
          agentId: params.agentId,
          followUpPending: Boolean(postResetMessage),
        });
      },
    });
  } catch (err) {
    if (
      params.abortForLifecycleRotation({
        sessionKey: params.requestedSessionKey,
        agentId: params.agentId,
      })
    ) {
      return { ...base, stop: true, accepted: true };
    }
    throw err;
  }
  if (!resetResult.ok) {
    params.respond(false, undefined, resetResult.error);
    return { ...base, stop: true, accepted: false };
  }
  const next = {
    ...base,
    requestedSessionKey: resetResult.key,
    resolvedSessionId: resetResult.sessionId ?? params.resolvedSessionId,
  };
  params.setCommittedResetCompletion({
    reason: resetReason,
    sessionId: resetResult.sessionId,
    sessionKey: resetResult.key,
    agentId: params.agentId,
    followUpPending: Boolean(postResetMessage),
  });
  if (postResetMessage) {
    if (
      params.abortForLifecycleRotation({ sessionKey: resetResult.key, agentId: params.agentId })
    ) {
      return { ...next, stop: true, accepted: true };
    }
    return {
      ...next,
      stop: false,
      accepted: false,
      effectiveTranscriptInputText: postResetMessage,
      message: postResetMessage,
    };
  }

  try {
    const deliverySession =
      params.request.deliver === true
        ? loadBareSessionResetDeliverySession({
            cfg: params.cfg,
            sessionKey: resetResult.key,
            ...(params.agentId ? { agentId: params.agentId } : {}),
          })
        : undefined;
    const resetAckResult = await resolveBareSessionResetResult({
      cfg: deliverySession?.cfg ?? params.cfg,
      context: params.context,
      reason: resetReason,
      sessionId: resetResult.sessionId,
      sessionKey: resetResult.key,
      agentId: deliverySession?.agentId ?? params.agentId,
      sessionEntry: deliverySession?.entry,
      request: params.sessionKeyFromTo ? { ...params.request, to: undefined } : params.request,
      runId: params.runId,
      assertCurrent: () => assertAgentRunLifecycleGenerationCurrent(params.lifecycleGeneration),
    });
    const responsePayload = buildBareSessionResetResponse({
      runId: params.runId,
      result: resetAckResult,
    });
    setGatewayDedupeEntries({
      dedupe: params.context.dedupe,
      keys: params.agentDedupeKeys,
      entry: { ts: Date.now(), ok: true, payload: responsePayload },
    });
    params.respond(true, responsePayload, undefined, { runId: params.runId });
    emitSessionsChanged(params.context, {
      sessionKey: resetResult.key,
      ...(params.agentId ? { agentId: params.agentId } : {}),
      reason: resetReason,
    });
    return { ...next, stop: true, accepted: true };
  } catch (err) {
    if (
      params.abortForLifecycleRotation({ sessionKey: resetResult.key, agentId: params.agentId })
    ) {
      return { ...next, stop: true, accepted: true };
    }
    params.respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, formatForLog(err)));
    return { ...next, stop: true, accepted: false };
  }
}