import React from 'react';
import { renderToString } from 'react-dom/server';

export default async (_props, _railsContext) => {
  console.log('Console log from SetTimeoutLoggingApp.server.jsx');

  const delayedValue = await new Promise((resolve) => {
    setTimeout(() => {
      console.log('Console log from setTimeout in SetTimeoutLoggingApp.server.jsx');
    }, 1);

    setTimeout(() => {
      console.log('Console log from setTimeout100 in SetTimeoutLoggingApp.server.jsx');
      resolve('this value is set by setTimeout during SSR');
    }, 100);
  });

  const element = <div>Disable javascript in your browser options to confirm {delayedValue}.</div>;
  return renderToString(element);
};

const store = { id: 2 };
try {
  asyncLocalStorage.run(store, () => {
    asyncLocalStorage.getStore(); // Returns the store object
    setTimeout(() => {
      asyncLocalStorage.getStore(); // Returns the store object
    }, 200);
    throw new Error();
  });
} catch (e) {
  asyncLocalStorage.getStore(); // Returns undefined
  // The error will be caught here
} 

const { AsyncLocalStorage } = require('async_hooks');
const asyncLocalStorage = new AsyncLocalStorage();
const fs = require('fs').promises;

let ioBoundTask = async () => {
  const data = 'a'.repeat(1024 * 1024); // 1 MB of data
  await fs.writeFile('/tmp/test.txt', data);
  await fs.readFile('/tmp/test.txt');
};

let runWithExpiry = async (expiry, fn) => {
  let iterations = 0;
  while (Date.now() < expiry) {
    await fn();
    iterations++;
  }
  return iterations;
};

(async () => {
  console.log(`Warming up...`);
  await runWithExpiry(Date.now() + 1000, ioBoundTask);

  let withoutAls = await runWithExpiry(Date.now() + 1000, ioBoundTask);
  console.log(`I/O-bound task without ALS: ${withoutAls} iterations`);

  let withAls = await asyncLocalStorage.run({}, () => runWithExpiry(Date.now() + 1000, ioBoundTask));
  console.log(`I/O-bound task with ALS: ${withAls} iterations`);

  console.log(
    'ALS penalty (I/O-bound): ' +
      Math.round((1 - withAls / withoutAls) * 10000) / 100 +
      '%'
  );
})();

const { AsyncLocalStorage } = require('async_hooks');

const fib = (n) => (n <= 1 ? n : fib(n - 1) + fib(n - 2));

let cpuBoundTask = async () => fib(25);

let runWithExpiry = async (expiry, fn) => {
  let iterations = 0;
  while (Date.now() < expiry) {
    await fn();
    iterations++;
  }
  return iterations;
};

(async () => {
  console.log(`Warming up...`);
  await runWithExpiry(Date.now() + 200, cpuBoundTask);

  let withoutAls = await runWithExpiry(Date.now() + 2000, cpuBoundTask);
  console.log(`CPU-bound task without ALS: ${withoutAls} iterations`);

  const asyncLocalStorage = new AsyncLocalStorage();
  let withAls = await asyncLocalStorage.run({}, () => runWithExpiry(Date.now() + 2000, cpuBoundTask));
  console.log(`CPU-bound task with ALS: ${withAls} iterations`);

  console.log(
    'ALS penalty (CPU-bound): ' +
      Math.round((1 - withAls / withoutAls) * 10000) / 100 +
      '%'
  );
})();

const { AsyncLocalStorage } = require('async_hooks');
const asyncLocalStorage = new AsyncLocalStorage();
const http = require('http');

const PORT = 3000;
let requestCount = 0;

const server = http.createServer((req, res) => {
  asyncLocalStorage.run({}, () => {
    res.end('Hello World');
    requestCount++;
  });
});

server.listen(PORT, async () => {
  console.log(`Server is listening on port ${PORT}`);

  const makeRequests = async (duration) => {
    let iterations = 0;
    const expiry = Date.now() + duration;
    while (Date.now() < expiry) {
      await new Promise((resolve, reject) => {
        http.get(`http://0.0.0.0:${PORT}`, (res) => {
          res.on('data', () => {});
          res.on('end', () => resolve());
          res.on('error', (error) => reject(error));
        }).on('error', (error) => reject(error));
      });
      iterations++;
    }
    return iterations;
  };

  // Warm-up
  await makeRequests(1000);

  // With ALS
  requestCount = 0;
  let withAlsIterations = await asyncLocalStorage.run({}, () => makeRequests(1000));
  console.log(
    `HTTP requests with ALS: ${withAlsIterations} iterations, ${requestCount} requests handled`
  );

  // Without ALS
  asyncLocalStorage.disable();
  requestCount = 0;
  let withoutAlsIterations = await makeRequests(1000);
  console.log(
    `HTTP requests without ALS: ${withoutAlsIterations} iterations, ${requestCount} requests handled`
  );

  console.log(
    'ALS penalty (HTTP server): ' +
      Math.round(
        (1 - withAlsIterations / withoutAlsIterations) * 10000
      ) /
        100 +
      '%'
  );

  server.close(() => {
    console.log('Server closed');
  });
});

const { AsyncLocalStorage } = require('async_hooks');
const fs = require('fs').promises;

let mixedTask = async () => {
  // CPU-bound operation
  fib(20);

  // I/O-bound operation
  const data = 'a'.repeat(200 * 1024); // 200 KB of data
  await fs.writeFile('/tmp/test.txt', data);
  await fs.readFile('/tmp/test.txt');
};

const fib = (n) => (n <= 1 ? n : fib(n - 1) + fib(n - 2));

let runWithExpiry = async (expiry, fn) => {
  let iterations = 0;
  while (Date.now() < expiry) {
    await fn();
    iterations++;
  }
  return iterations;
};

(async () => {
  console.log(`Warming up...`);
  await runWithExpiry(Date.now() + 1000, mixedTask);

  let withoutAls = await runWithExpiry(Date.now() + 1000, mixedTask);
  console.log(`Mixed task without ALS: ${withoutAls} iterations`);

  const asyncLocalStorage = new AsyncLocalStorage();
  let withAls = await asyncLocalStorage.run({}, () => runWithExpiry(Date.now() + 1000, mixedTask));
  console.log(`Mixed task with ALS: ${withAls} iterations`);

  console.log(
    'ALS penalty (Mixed workload): ' +
      Math.round((1 - withAls / withoutAls) * 10000) / 100 +
      '%'
  );
})();