// performance-benchmark.mjs
//
// From directory containing React DevTools Profiler JSON results,
// reads each JSON profile, summarizes, and writes summary stats to file.

import { argv } from 'node:process';
import { join } from 'node:path';
import { existsSync, promises as fsPromises } from 'node:fs';
import { parseArgs } from 'node:util';

const args = argv.slice(2);

const options = {
  input: {
    type: 'string',
    short: 'i',
    isRequired: true,
  },
  output: {
    type: 'string',
    short: 'o',
    isRequired: true,
  },
};

const { values } = parseArgs({
  args,
  options,
  tokens: true,
});

const inputDirectory = values.input;
// Get parts from the input directory path
const inputDirectoryParts = inputDirectory
  .split('/')
  .filter((part) => part !== '');
const inputDirectoryName = inputDirectoryParts[inputDirectoryParts.length - 1];

const outputFile = values.output || `${inputDirectoryName}-results.json`;
const outputDirectory = join(inputDirectory, 'output');

// Check if the input directory exists
if (!existsSync(inputDirectory)) {
  console.error(`Input directory "${inputDirectory}" does not exist.`);
  process.exit(1);
}

// Read each file in the input directory
const files = await fsPromises.readdir(inputDirectory, { withFileTypes: true });
const inputFiles = files
  .filter((file) => file.isFile() && file.name.endsWith('.json'))
  .map((file) => file.name);

// Read each file and parse the JSON
const snapshots = await Promise.all(
  inputFiles.map(async (file) => {
    const adjFile = join(inputDirectory, file);
    try {
      const data = await fsPromises.readFile(adjFile, 'utf8');
      const jsonObject = JSON.parse(data);
      return jsonObject;
    } catch (err) {
      console.error(`Error processing file "${file}":`, err);
      return null;
    }
  }),
);

const stats = snapshots
  .map((snapshot) => {
    const { timelineData } = snapshot;
    const { duration, reactVersion } = timelineData[0];
    return {
      duration,
      reactVersion,
    };
  })
  .sort((a, b) => a.duration - b.duration)
  .reduce(
    (acc, curr) => {
      acc.total += curr.duration;
      acc.durations.push(curr.duration);
      acc.reactVersion = curr.reactVersion;
      return acc;
    },
    {
      total: 0,
      reactVersion: '',
      durations: [],
    },
  );

stats.min = Math.min(...stats.durations);
stats.max = Math.max(...stats.durations);
stats.mean = stats.total / stats.durations.length;
stats.median = stats.durations[Math.floor(stats.durations.length / 2)];
stats.variance =
  stats.durations.reduce((acc, curr) => acc + (curr - stats.mean) ** 2, 0) /
  stats.durations.length;
stats.stdDev = Math.sqrt(stats.variance);
stats.range = stats.max - stats.min;
stats.mode = stats.durations.reduce((acc, curr) => {
  const roundCurr = Math.round(curr / 10) * 10;
  acc[roundCurr] = (acc[roundCurr] || 0) + 1;
  return acc;
}, {});
stats.mode = Object.entries(stats.mode).reduce(
  (acc, curr) => {
    if (curr[1] > acc[1]) {
      return curr;
    }
    return acc;
  },
  [0, 0],
);

console.log('Stats:', stats);

// Write the stats to the output file
const outputData = {
  stats,
};
const outputDirectoryExists = existsSync(outputDirectory);
if (!outputDirectoryExists) {
  await fsPromises.mkdir(outputDirectory, { recursive: true });
}

const outputFilePath = join(outputDirectory, outputFile);
const outputFileExists = existsSync(outputFilePath);
if (outputFileExists) {
  console.log(`Output file "${outputFilePath}" already exists. Overwriting...`);
}
await fsPromises.writeFile(
  outputFilePath,
  JSON.stringify(outputData, null, 2),
  'utf8',
);
console.log(`Output written to "${outputFilePath}"`);
console.log('Done!');
console.log('Performance benchmark completed.');