/**
 * Shared message definitions for the middleware example
 */

import { DefineMessages } from 'isolated-workers';

/**
 * Message types for the middleware example
 */
export type Messages = DefineMessages<{
  greet: {
    payload: { name: string };
    result: { greeting: string };
  };
  compute: {
    payload: { values: number[] };
    result: { sum: number; count: number };
  };
}>;

/**
 * Middleware Example - Host (Client) Side
 *
 * This example demonstrates how to use middleware to:
 * - Log all outgoing and incoming messages
 * - Add timestamps to messages
 * - Validate message structure
 */

import { createWorker, type Middleware } from 'isolated-workers';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
import type { Messages } from './messages.js';

const __dirname = dirname(fileURLToPath(import.meta.url));

/**
 * Logging middleware - logs all messages with direction
 */
const loggingMiddleware: Middleware<Messages> = (message, direction) => {
  const arrow = direction === 'outgoing' ? '>>>' : '<<<';
  console.log(
    `[${direction.toUpperCase()}] ${arrow} ${message.type}`,
    message.payload
  );
  return message;
};

/**
 * Timing middleware - tracks how long messages take
 * Note: This is a simplified example; real timing would need request correlation
 */
const timingMiddleware: Middleware<Messages> = (message, direction) => {
  if (direction === 'outgoing') {
    console.log(`[TIMING] Request sent at: ${new Date().toISOString()}`);
  } else {
    console.log(`[TIMING] Response received at: ${new Date().toISOString()}`);
  }
  return message;
};

async function main() {
  console.log('Starting middleware example...\n');

  // Create worker with middleware pipeline
  // Middleware is applied in order: logging -> timing
  const worker = await createWorker<Messages>({
    script: join(__dirname, 'worker.ts'),
    timeout: 10000,
    middleware: [loggingMiddleware, timingMiddleware],
  });

  console.log(`Worker spawned with PID: ${worker.pid}\n`);

  try {
    // Send a greet message
    console.log('--- Sending greet message ---');
    const greetResult = await worker.send('greet', { name: 'World' });
    console.log('Greeting result:', greetResult.greeting, '\n');

    // Send a compute message
    console.log('--- Sending compute message ---');
    const computeResult = await worker.send('compute', {
      values: [1, 2, 3, 4, 5],
    });
    console.log('Compute result:', computeResult, '\n');
  } finally {
    await worker.close();
    console.log('Worker closed successfully');
  }
}

main().catch((err) => {
  console.error('Error:', err);
  process.exit(1);
});

/**
 * Middleware Example - Worker (Server) Side
 *
 * The worker also supports middleware for processing messages.
 */

import { startWorkerServer, Handlers, type Middleware } from 'isolated-workers';
import type { Messages } from './messages.js';

/**
 * Worker-side logging middleware
 */
const workerLoggingMiddleware: Middleware<Messages> = (message, direction) => {
  console.log(`[WORKER ${direction}] Processing: ${message.type}`);
  return message;
};

// Define handlers
const handlers: Handlers<Messages> = {
  greet: ({ name }) => {
    console.log(`Worker: Creating greeting for "${name}"`);
    return { greeting: `Hello, ${name}!` };
  },

  compute: ({ values }) => {
    console.log(`Worker: Computing sum of ${values.length} values`);
    const sum = values.reduce((a, b) => a + b, 0);
    return { sum, count: values.length };
  },
};

async function main() {
  console.log('Worker starting with middleware...');

  const server = await startWorkerServer(handlers, {
    middleware: [workerLoggingMiddleware],
  });

  console.log('Worker ready');

  process.on('SIGTERM', async () => {
    await server.stop();
    process.exit(0);
  });
}

main().catch((err) => {
  console.error('Worker error:', err);
  process.exit(1);
});