import { workflow, simpleTask, httpTask, switchTask } from '@io-orkes/conductor-javascript';

const wf = workflow('order_flow', [
  httpTask('fetch_order', {
    method: 'GET',
    uri: '${workflow.input.url}',
  }),
  switchTask('check_status', '${fetch_order.output.response.statusCode}', {
    '200': [simpleTask('process', 'process_order', {})],
  }, [simpleTask('error', 'handle_error', {})]),
]);

// Registration and execution are separate concerns
await executor.registerWorkflow(true, wf);
const id = await executor.startWorkflow({ name: 'order_flow', input: { order_id: '123' } });

switchTask('evaluate', '${task.output.status}', {
  'SUCCESS': [simpleTask(...)],
  'FAILURE': [simpleTask(...)],
}, [simpleTask(...)])  // default case

// Basic fork (no auto-join)
forkTask('parallel', [task1, task2])

// Fork with auto-join (returns tuple)
const [fork, join] = forkTaskJoin('parallel', [task1, task2])

// Explicit join
joinTask('custom_join', ['task1_ref', 'task2_ref'])

// Conditional loop
doWhileTask('retry', 'if ($.retry.iteration < 5) { true; } else { false; }', [task1, task2])

// Fixed iterations
newLoopTask('repeat_5', 5, [task])

// No ForEachTask

// Separate concerns
const wf = workflow('order_flow', [...tasks]);
await executor.registerWorkflow(true, wf);
const id = await executor.startWorkflow({ name: 'order_flow', input: { order_id: '123' } });

// Synchronous execution
const run = await executor.executeWorkflow(request, 'order_flow', 1, 'req-id', 'final_task');

const http = httpTask('fetch_order', { method: 'GET', uri: '...' });

// Instead of: '${fetch_order.output.response.body.order_id}'
// Could be:
http.output.response.body.order_id  // Returns typed reference string
http.output.response.statusCode     // Returns typed reference string

function createRef(basePath: string): any {
  return new Proxy({}, {
    get(_, prop: string) {
      if (prop === 'toString' || prop === Symbol.toPrimitive)
        return () => `\${${basePath}}`;
      return createRef(`${basePath}.${prop}`);
    }
  });
}

// Usage:
const task = simpleTask('my_ref', 'my_task', {});
task.ref.output.someField  // → '${my_ref.output.someField}'

// Instead of: '${workflow.input.url}/api/${fetch_order.output.response.body.id}'
// Could be:
const url = ref`${workflow.input.url}/api/${fetchOrder.output.id}`;

// Or for switch conditions:
const condition = ref`${httpTask.output.response.statusCode}`;

const wf = new WorkflowBuilder('order_flow')
  .version(2)
  .timeout(300)
  .ownerEmail('team@company.com')
  .failureWorkflow('compensation')
  .add(httpTask('fetch', { method: 'GET', uri: '...' }))
  .add(switchTask('check', '${fetch.output.status}', {
    '200': [processTask],
  }, [errorTask]))
  .outputParam('result', '${process.output.data}')
  .build();

// Register and execute
await wf.register(executor, { overwrite: true });
const result = await wf.execute(executor, { order_id: '123' });

// Using pipe operator (TC39 proposal, or polyfill)
const wf = pipe(
  workflow('order_flow'),
  addTask(httpTask('fetch', { ... })),
  addTask(switchTask('check', '${fetch.output.status}', { ... })),
  withTimeout(300),
  withOwner('team@company.com'),
);

// Pythonic fork via array syntax
const wf = workflow('parallel_flow', [
  httpTask('fetch1', { ... }),
  // Fork: array of arrays = parallel branches
  fork('parallel', [
    [processA, transformA],  // Branch 1
    [processB, transformB],  // Branch 2
  ]),
  // Auto-join implied
  simpleTask('merge', 'merge_results', { ... }),
]);

// Define input/output types
interface OrderInput { orderId: string; amount: number }
interface OrderOutput { status: string; receipt: string }

const wf = workflow<OrderInput, OrderOutput>('order_flow', [
  simpleTask('validate', 'validate_order', {
    orderId: ref.input.orderId,  // TypeScript autocomplete!
    amount: ref.input.amount,    // Type checked!
  }),
]);

// Type-safe execution
const result = await wf.execute(executor, {
  orderId: '123',   // ✅ TypeScript validates
  amount: 99.99,    // ✅ TypeScript validates
  invalid: true,    // ❌ TypeScript error!
});

// Workers define their interface
@worker({ taskDefName: 'process_order' })
async function processOrder(task: Task): Promise<TaskResult> { ... }

// Workflow builder can reference workers directly
const wf = workflow('order_flow', [
  processOrder.asTask('process_ref', {
    orderId: '${workflow.input.orderId}'
  }),
]);
// Task name, type info, and input schema all derived from the worker

// Express workflow logic as async function (compiled to Conductor definition)
const orderFlow = defineWorkflow('order_flow', async (input: OrderInput) => {
  const order = await httpTask.call({ method: 'GET', uri: `/orders/${input.orderId}` });

  if (order.status === 'valid') {
    const payment = await simpleTask.call('charge', { amount: input.amount });
    return { receipt: payment.receiptId };
  } else {
    throw new TerminateError('Invalid order');
  }
});

const wf = workflow('order_flow', [task1, task2], {
  version: 2,
  timeoutSeconds: 300,
  timeoutPolicy: 'TIME_OUT_WF',
  ownerEmail: 'team@company.com',
  failureWorkflow: 'compensation_wf',
  outputParameters: { result: '${task2.output.data}' },
  inputParameters: ['orderId', 'amount'],
  variables: { counter: 0 },
  restartable: true,
});

const wf = new WorkflowBuilder('order_flow')
  .version(2)
  .timeout(300)
  .add(httpTask('fetch', { ... }))
  .add(switchTask('check', '${fetch.output.status}', { ... }))
  .output('result', '${process.output.data}')
  .build();

const fetch = httpTask('fetch_order', { ... });
const ref = taskRef(fetch);  // Returns Proxy

simpleTask('process', 'process_order', {
  statusCode: ref.output.response.statusCode,   // Type-safe!
  body: ref.output.response.body,               // Autocomplete!
});

@worker({ taskDefName: 'process_order' })
function processOrder(task: Task): Promise<TaskResult> { ... }

// Use in workflow
processOrder.task('ref', { orderId: '${workflow.input.orderId}' });