import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
import { randomUUID } from "node:crypto";

type Level = { price: string; quantity: string };
type TradingEvent = {
venue: string;
instrument: string;
sequence: number;
sourceTimestamp: string;
bids: Level[];
asks: Level[];
requestedSide: "BUY" | "SELL";
requestedQuantity: string;
limitPrice?: string;
strategyId: string;
};

export const handler = withDurableExecution(
async (event: TradingEvent, context: DurableContext) => {
const identity = await context.step("create-execution-identity", async () => ({
clientOrderId: randomUUID(),
decisionTimestamp: new Date().toISOString(),
}));

const snapshot = await context.step("validate-and-store-book", async () => {
const topThree = buildValidatedTopThree(event);
const evidence = await storeImmutableSnapshot(topThree, event);
return {
venue: event.venue,
instrument: event.instrument,
sequence: event.sequence,
sourceTimestamp: event.sourceTimestamp,
topThree,
evidenceUri: evidence.uri,
sha256: evidence.sha256,
};
});

const decision = await context.step("calculate-decision", async () => {
return calculateSpreadDepthAndImbalance(snapshot, event);
});

const initialRisk = await context.step("initial-pre-trade-risk", async () => {
return evaluateRisk({ event, snapshot, decision, identity });
});

if (initialRisk.decision === "REJECT") {
return context.step("record-risk-rejection", async () =>
recordTerminalOutcome(identity.clientOrderId, initialRisk)
);
}

if (initialRisk.decision === "REQUIRE_APPROVAL") {
const approval = await context.waitForCallback(
"wait-for-trade-approval",
async (callbackId) => {
await sendApprovalRequest({
callbackId,
clientOrderId: identity.clientOrderId,
evidenceUri: snapshot.evidenceUri,
riskReasons: initialRisk.reasons,
expiresAt: initialRisk.approvalExpiresAt,
});
},
{ timeout: { hours: 4 } },
);

await context.step("record-approval", async () =>
persistApproval(identity.clientOrderId, approval)
);
}

const finalRisk = await context.step("final-pre-submit-risk", async () => {
return revalidateImmediatelyBeforeSubmission({
event,
snapshot,
decision,
identity,
});
});

if (finalRisk.decision !== "ALLOW") {
return context.step("record-final-risk-stop", async () =>
recordTerminalOutcome(identity.clientOrderId, finalRisk)
);
}

await context.step("create-idempotent-order-intent", async () => {
return createOrderIntentConditionally({
clientOrderId: identity.clientOrderId,
event,
snapshot,
decision,
finalRisk,
});
});

await context.step("submit-order", async () => {
return submitUsingStableClientOrderId({
clientOrderId: identity.clientOrderId,
event,
});
});

const terminalStatus = await context.waitForCondition(
"reconcile-order-status",
async (state: { clientOrderId: string; status: string; done: boolean }) => {
const status = await getOrderStatus(state.clientOrderId);
return {
clientOrderId: state.clientOrderId,
status: status.code,
done: ["FILLED", "CANCELLED", "REJECTED", "EXPIRED"].includes(status.code),
};
},
{
initialState: {
clientOrderId: identity.clientOrderId,
status: "PENDING",
done: false,
},
waitStrategy: (state, attempt) => ({
shouldContinue: !state.done && attempt < 120,
delay: { seconds: Math.min(2 ** attempt, 60) },
}),
},
);

return context.step("finalize-audit-evidence", async () => {
return finalizeOrderEvidence({
identity,
event,
snapshot,
decision,
finalRisk,
terminalStatus,
});
});
},
);