import { createWorkflow, ClaudeHarness } from "@open-harness/core";

type State = { input: string; result: string | null };
const { agent, runReactive } = createWorkflow<State>();

const analyzer = agent({
  prompt: "Analyze: {{ state.input }}",
  activateOn: ["workflow:start"],
  emits: ["analysis:complete"],
  updates: "result",
});

const result = await runReactive({
  agents: { analyzer },
  state: { input: "Hello", result: null },
  harness: new ClaudeHarness(),
  endWhen: (s) => s.result !== null,
});

interface RunReactiveConfig<TState> {
  // Required
  agents: Record<string, Agent>;
  state: TState;
  harness: Harness;

  // Optional
  endWhen?: (state: TState) => boolean;
  recording?: RecordingConfig;
  reducers?: Record<string, SignalReducer<TState>>;
  timeout?: number;
}

agents: {
  analyzer,
  reviewer,
  fixer,
}

state: {
  input: "data to analyze",
  analysis: null,
  review: null,
}

harness: new ClaudeHarness({ model: "claude-sonnet-4-20250514" })

endWhen: (state) => state.result !== null

recording: {
  mode: "record",           // "record" | "replay"
  store: new MemorySignalStore(),
  recordingId?: "rec_123",  // Required for replay
  name?: "my-workflow",     // Recording name
  tags?: ["test"],          // Recording tags
}

reducers: {
  "trade:proposed": (state, signal) => ({
    ...state,
    trades: [...state.trades, signal.payload],
  }),
}

timeout: 30000  // 30 seconds

interface WorkflowResult<TState> {
  state: TState;              // Final state
  signals: Signal[];          // Full signal trace
  metrics: {
    durationMs: number;       // Execution time
    activations: number;      // Agent activation count
  };
  terminatedEarly: boolean;   // endWhen triggered
  recordingId?: string;       // If recording
}

console.log(result.state.analysis);

result.signals.forEach(s => {
  console.log(`[${s.timestamp}] ${s.name}`, s.payload);
});

console.log(`Duration: ${result.metrics.durationMs}ms`);
console.log(`Activations: ${result.metrics.activations}`);

if (result.terminatedEarly) {
  console.log("Workflow completed via endWhen condition");
}

if (result.recordingId) {
  console.log(`Saved recording: ${result.recordingId}`);
}

const result = await runReactive({
  agents: { analyzer },
  state: { input: "Hello", result: null },
  harness: new ClaudeHarness(),
  endWhen: (s) => s.result !== null,
});

const result = await runReactive({
  agents: { planner, coder, reviewer },
  state: { task: "Build a TODO app", plan: null, code: null, review: null },
  harness: new ClaudeHarness(),
  endWhen: (s) => s.review?.passed === true,
});

const store = new MemorySignalStore();

// Record
const result = await runReactive({
  agents: { analyzer },
  state: initialState,
  harness: new ClaudeHarness(),
  recording: { mode: "record", store, name: "test-run" },
});

// Replay
const replay = await runReactive({
  agents: { analyzer },
  state: initialState,
  harness: new ClaudeHarness(), // Not called
  recording: { mode: "replay", store, recordingId: result.recordingId! },
});

const result = await runReactive({
  agents: { analyzer, trader },
  state: { analysis: null, trades: [] },
  harness,
  reducers: {
    "trade:proposed": (state, signal) => ({
      ...state,
      trades: [...state.trades, signal.payload.trade],
    }),
  },
});

try {
  const result = await runReactive({ /* ... */ });
} catch (error) {
  if (error instanceof TimeoutError) {
    console.error("Workflow timed out");
  } else if (error instanceof HarnessError) {
    console.error("Harness failed:", error.message);
  }
}