export const workflow1 = workflow("worfklow1", () => ..);
export const workflow2 = workflow("worfklow2", () => ..);

const myService = new eventual.Service(stack, "myService", {
  entry: require.resolve("test-app-runtime/lib/my-workflow.js"),
});

new eventual.EventualApi(stack, "api", {
  services: [myWorkflow, openAccount],
});

api.any(async () => {
   // or event handler or workflow
   await cancelActivity(activityToken, reason);
   await failActivity(activityToken, error, message);
   await completeActivity(activityToken, result);
})

const myAct = activity(...);
workflow(() => {
   // start activity
   const actInstance = myAct();
   
   // cancel, error, or complete the workflow
   await actInstance.cancel(reason);
   await actInstance.fail(new Error()); // or actInstance.fail(error, message);
   await actInstance.complete(result);

  await actInstance; 
});

workflow(() => {
	const result = await act1();
});

act1 = activity<{ result: string }>({
   heartbeat: { seconds: number },
   timeout: { seconds: number }
}, (context: Context): { result: string } | AsyncToken => {
   ...doSomeWork...

   await sendToQueue({ token: context.activity.token });

   return makeAsync();
})

// lambda function consuming the queue
const workflowClient = new WorkflowClient();
export const handler = async (event) => {
    Promise.all(event.Records.map(async (record) => {
        const payload = JSON.parse(record.body);
        
        // complete the activity with a payload
	    await workflowClient.completeActivity<typeof act1>(
		    payload.token,
		    { result: "done"}
		);

		// or fail
		await workflowClient.failActivity(payload.token, {result: "done"});
    }));
}

workflow(() => {
	const result = await act1();
});

act1 = activity<{ result: string }>({
   heartbeat: { seconds: 20 },
   timeout: { seconds: 160 }
}, (context: Context): { result: string } | AsyncToken => {
   ...doSomeWork...

   await sendToQueue({ token: context.activity.token });

   await sendHeartbeat();

   return makeAsync();
})

// lambda function consuming the queue
const workflowClient = new WorkflowClient();
export const handler = async (event) => {
    Promise.all(event.Records.map(async (record) => {
        const payload = JSON.parse(record.body);

		while(true) {
		   // some long process
		   await workflowClient.heartbeatActivity(payload.token);
		}
        
        // complete the activity with a payload
	    await workflowClient.completeActivity<typeof act1>(
		    payload.token,
		    { result: "done"}
		);
    }));
}

workflow(() => {
	const act = act1();

    act.onHeartbeat(async ({ i: 100 }) => {
	    await reportProgress(i);
    });
});

const reportProceess = activity(...);

const act1 = activity<{ result: string }, { i: 100 } | undefined>({
   heartbeat: { seconds: 20 },
   timeout: { seconds: 160 }
}, (context: Context): { result: string } | AsyncToken => {
   ...doSomeWork...

   await sendToQueue({ token: context.activity.token, start: context.checkpoint });

	// should this be on the context to be typed?
   await sendHeartbeat();

   return makeAsync();
})

// lambda function consuming the queue
const workflowClient = new WorkflowClient();
export const handler = async (event) => {
    Promise.all(event.Records.map(async (record) => {
        const payload = JSON.parse(record.body);

		const items = [...];

		const start = event.start ?? 0;

		for(const i of items.slice()) {
		   // some long process
		   await workflowClient.heartbeatActivity<typeof act1>(
			   payload.token,
			   { i }
		   );
		}
        
        // complete the activity with a payload
	    await workflowClient.completeActivity<typeof act1>(
		    payload.token,
		    { result: "done"}
		);
    }));
}

const complexThing = chain(async () => {
    await act1();
    await act2();
});
Promise.race(complexThing(), sleepFor()); // or Promise.any()

const act1 = activity("act1", { timeoutSeconds: 1000 }, () => {}); // times out after 1000 seconds

// times out after 1000 seconds
const wf1 = workflow("wf1", { timeoutSeconds: 1000 }, () => {
    
     await expectSignal("mySignal", { timeoutSeconds: 100 }); // times out after 100 seconds if signal is not recieved
     await condition({ timeoutSeconds: 100 }}, () => x === y); // times out after 100 seconds if the condition has yet to be met
     await act1() // times out after 1000 seconds if does not return.
     await act1.withOptions({ timeoutSeconds: 100 })(); // overrides the timeout to 100 seconds if the activity has not completed
});

// runs until completion or error, no timeout
const wf2 = workflow("wf2", () => {
    const child = await wf1(); // will fail after 1000 seconds
    const child2  = await wf1.withOptions({ childTimeoutSeconds: 100 })(); // will fail after 100 seconds
});

const childWf = workflow("childWf", () => { ... long running things... });
const parentWf = workflow("parentWf", () => {
    await childWf.withOptions({ timeoutSeconds: 100 })(); // throw an error to the parent after 100 seconds, child will continue
});

const childWf = workflow("childWf", { timeoutSeconds: 100 }, () => { ... long running things... });
const parentWf = workflow("parentWf", () => {
    await childWf(); // throw an error to the parent after 100 seconds, child will is failed with timeout
});

const childWf = workflow("childWf", { timeoutSeconds: 100 }, () => { ... long running things... });
const parentWf = workflow("parentWf", () => {
    const child = childWf(); // child times out after 100 seconds, nothing happens here

   ...doOtherWork...

   await child; // throws
});

const childWf = workflow("childWf", { timeoutSeconds: 1000 }, () => { ... long running things... });
const parentWf = workflow("parentWf", () => {
    await childWf(); // the execution will timeout after 1000 seconds
    await childWf.withOptions({ executionTimeoutSeconds: 100 })(); // the execution will timeout after 100 seconds
    await childWf.withOptions({ childTimeoutSeconds: 100 })(); // the execution will timeout after 1000 seconds, but the parent will fail the eventual after 100 seconds
});

export interface WorkflowTask {
  executionId: string;
  id: string;
  events: HistoryStateEvents[];
}

const RequestApprovalEvent =
  event<RequestApprovalEventPayload>("RequestApproval");

// auto approval for the human request approval event.
RequestApprovalEvent.on(async (event) => {
  await requestApproval.complete({
    activityToken: event.token,
    result: { approve: true },
  });
});

workflow(async () => {
  await requestApproval({
    price,
    recommendation: decision,
    symbol,
  });
});

const requestApproval = activity(
  "requestApproval",
  async (event: Omit<RequestApprovalEventPayload, "token">) => {
    return asyncResult<{ approve: boolean }>(async (token) => {
      await RequestApprovalEvent.publish({ ...event, token });
    });
  }
);

const requestApprovalEventActivity = asyncEventActivity((token, data: Omit<RequestApprovalEventPayload, "token">) => ({ 
   ...data, 
   token
}));

workflow(async () => {
  await requestApprovalEventActivity({
    price,
    recommendation: decision,
    symbol,
  });
});

public configureRecordHistory(func: Function) {
  this.grantRecordHistory(func);
  addEnvironment(func, {
    [ENV_NAMES.EXECUTION_HISTORY_BUCKET]: this.history.bucketName,
  });
}

const wf = workflow("wf1", () => {});

const wf2 = workflow("wf2", () => {
   const child = wf();

   child.sendSignal("MySignal"); // error: how does send signal know the ID?

   sendSignal(child.executionId, "MySignal"); // error: executionId property cannot be known here as scheduleWorkflow and sendSignal are executed in parallel

   await child();
})

ScheduleWorkflow
SendSignal // how do I get the execution id?
SendSignal // how do I get the execution id?

const wf2 = workflow("wf2", () => {
   const childHandle = await wf.startExecution(); // returns a execution handle with the ID.
   const child = childHandle.result() // returns a promise related to the end of the workflow.

   childHandle.sendSignal("MySignal");
   sendSignal(childHandle.executionId, "MySignal");

   return await child; //waits for completion and returns result
})

const wf2 = workflow("wf2", () => {
   const child = wf(); // returns a execution handle with the ID and a "Promise/Eventual"

   child.sendSignal("MySignal"); 
   sendSignal(child.executionId, "MySignal");

   console.log(child.executionId) // { ref: "ExecutionId", seq: 0 }

   return await child; // returns result
})

import { workflow, WorkflowHandler } from "@eventual/core";

declare class Event<Payload = void> {
  constructor(public readonly id: string) {}
  on(handler: (payload: Payload) => Promise<void> | void): Promise<void>;
}

type EventPayload<E extends Event<any>> = E extends Event<infer P> ? P : never;

declare function waitForEvent<E extends Event<any>>(
  event: E,
  opts: { timeoutSeconds: number }
): Promise<EventPayload<E>>;
declare function condition(
  predicate: () => boolean,
  opts: { timeoutSeconds: number }
): Promise<void>;

const event = new Event<number>("event");
const doneEvent = new Event("done");

declare module "@eventual/core" {
  interface Workflow<F extends WorkflowHandler = WorkflowHandler> {
    ref(executionId: string): ExecutionRef;
    startExecution(input: Parameters<F>[0]): Promise<ExecutionRef>;
  }

  interface ExecutionRef {
    send<E extends Event<any>>(event: E, payload: EventPayload<E>): void;
  }
}

/**
 * the parent workflow uses thr `waitForEvent` function to block and wait for events from it's child workflow.
 */
export const workflow1 = workflow("workflow1", async () => {
  const child = await workflow2.startExecution({ name: "child" });
  while (true) {
    const n = await waitForEvent(event);

    console.log(n);

    if (n > 10) {
      child.send(doneEvent, undefined);
      break;
    }

    child.send(event, n + 1);
  }

  return "done";
});

/**
 * The child workflow shows a different way of having events using handlers, conditions, and local state.
 */
export const workflow2 = workflow(
  "workflow2",
  async (input: { name: string }, { execution: { parentId } }) => {
    let block = false;
    let done = false;
    let last = 0;

    if (!parentId) {
      throw new Error("I need an adult");
    }

    console.log(`Hi, I am ${input.name}`);
    const parent = workflow1.ref(parentId);

    await event.on((n) => {
      last = n;
      block = false;
    });
    await doneEvent.on(() => {
      done = true;
      block = false;
    });

    while (!done) {
      parent.send(event, last + 1);
      block = true;
      await condition(() => !block);
    }

    return "done";
  }
);

const groups = groupBy(events.filter(isHistoryEvent), event => event.seq);
const eventuals = Object.keys(groups).map(seq => {
    const started = groups[seq].find(isScheduledEvent);
    const ended = groups[seq].find(or(isCompletedEvent, isFailedEvent, isWorkflowTimedOut));
    const other = groups[seq].filter(event => event !== started && event !== ended);
    return { started, ended, other };
});
const otherEvents = events.filter(or(isSignalReceived, isWorkflowStarted, isWorkflowFailed, isWorkflowCompleted, isWorkflowTimedOut));

await cancelWorkflow(executionId, reason);

// cancels itself (?)
throw new CancelWorkflow(reason);

const execution = workflow.startExecution();
await execution.cancel(reason);

const execution = workflow();
await execution.cancel(reason);

async function finishActivity(event: ActivityCompleted | ActivityFailed) {
  await timed(metrics, ActivityMetrics.EmitEventDuration, () =>
    executionHistoryClient.putEvent(request.executionId, event)
  );

  await timed(metrics, ActivityMetrics.SubmitWorkflowTaskDuration, () =>
    workflowClient.submitWorkflowTask(request.executionId, event)
  );

  logActivityCompleteMetrics(isWorkflowFailed(event), event.duration);
}

workflow(() => {
   const state = new State<"IN_PROGRESS" | "SUCCESS">("IN_PROGRESS");

   signal.on(() => {
      state.update("SUCCESS");
   });

   await condition(() => state.value === "IN_PROGRESS");

   return "DONE";
})

const ping = new Event<string>("ping");
const pong = new Event<string>("pong");

const worker = workflow(({ id: number }, { execution: { parentId } }) => {
    const parent = controller.ref(parentId);
    const sub = event.on(() => {
         parent.send(pong, { ack: 1 });
    });

   await sleep(3 * 60);

   if(id === 1) {
       sub.dispose(); // unsubscribe;
   }
})

const controller = workflow(() => {
    const workers = [1,2,3].map((i) => worker.startWorkflow());

    let resposnes = 0;

    pong.on(() => { response++ });

    // send to specific executions
    ping.sendMany(workers, "hello");

    await condition(() => responses === workers.len);

    // send to anyone listening
    ping.broadcast("hello");
})

let x = 0;

const cond1 = condition(() => x === 1);

event.on(() => {
   eventual.reject(cond1);
});

if(await cond1) {
   x = 2;
}

let x = 0;

const cond1 = condition(() => x === 1);

 // when reject is called, cond1 returns a false response, even if the condition is met later.
event.on(() => {
   eventual.resolve(cond1);
});

if(await cond1) {
   x = 2; // when resolve is called, cond1 returns a true response, even if the condition is not met.
}

let cancel = false;

event.on(() => {
   eventual.resolve(cond1);
});

const cond1 = race(
   condition(() => x === 1), 
   condtion(() => cancel === true).then(() => false)
);

if(await cond1) {
    x = 2;
}

sussmans@SurfacePro8:~/eventual$ AWS_PROFILE=sussman ./packages/@eventual/cli/bin/eventual.js start test-runner test-runner ./examples/lambda-test-runner/runtime/test-files/test-cases.json --tail
✔ Execution id: test-runner/01GM6TS7P83T039M83J69WKSFB
✖ No events at all. Check your execution id

sussmans@SurfacePro8:~/eventual$ AWS_PROFILE=sussman ./packages/@eventual/cli/bin/eventual.js start test-runner test-runner ./examples/lambda-test-runner/runtime/test-files/test-cases.json --tail
✔ Execution id: test-runner/01GM6TSRFJ0SMCMDSYM13QY87E
ℹ 2022-12-13T22:48:32.032Z - WorkflowStarted- {
  target: {
    name: 'arn:aws:lambda:us-east-1:983725774087:function:example-test-runner-testFunction483F4CBE-nQBI88y30Jfk',
    type: 'lambda'
  },
  testCases: [ { input: [Object], expected: 3 } ]
}
ℹ 2022-12-13T22:48:32.146Z - TaskStarted
ℹ 2022-12-13T22:48:32.220Z - TaskCompleted
ℹ 2022-12-13T22:48:32.220Z - ActivityScheduled- runTestCase
ℹ 2022-12-13T22:48:32.392Z - ActivityCompleted- [object Object]
ℹ 2022-12-13T22:48:32.434Z - TaskStarted
ℹ 2022-12-13T22:48:32.453Z - WorkflowCompleted
ℹ 2022-12-13T22:48:32.453Z - TaskCompleted
✔ Workflow complete
{"passed":0,"failed":1,"errored":0,"results":[{"status":"fail","actual":{"0":51},"expected":3}]}