const { resolve, relative, sep } = require('path');
const {
  readdirSync,
  existsSync,
  unlinkSync,
  readFileSync,
  createWriteStream
} = require('fs');
var zlib = require('zlib');
var mime = require('mime-types');

const ARDUINO_INCLUDES = '#include <Arduino.h>\n\n';

function getFilesSync(dir, files = []) {
  readdirSync(dir, { withFileTypes: true }).forEach((entry) => {
    const entryPath = resolve(dir, entry.name);
    if (entry.isDirectory()) {
      getFilesSync(entryPath, files);
    } else {
      files.push(entryPath);
    }
  });
  return files;
}

function coherseToBuffer(input) {
  return Buffer.isBuffer(input) ? input : Buffer.from(input);
}

function cleanAndOpen(path) {
  if (existsSync(path)) {
    unlinkSync(path);
  }
  return createWriteStream(path, { flags: 'w+' });
}

class ProgmemGenerator {
  constructor(options = {}) {
    const {
      outputPath,
      bytesPerLine = 20,
      indent = '  ',
      includes = ARDUINO_INCLUDES
    } = options;
    this.options = { outputPath, bytesPerLine, indent, includes };
  }

  apply(compiler) {
    compiler.hooks.emit.tapAsync(
      { name: 'ProgmemGenerator' },
      (compilation, callback) => {
        const { outputPath, bytesPerLine, indent, includes } = this.options;
        const fileInfo = [];
        const writeStream = cleanAndOpen(
          resolve(compilation.options.context, outputPath)
        );
        try {
          const writeIncludes = () => {
            writeStream.write(includes);
          };

          const writeFile = (relativeFilePath, buffer) => {
            const variable = 'ESP_REACT_DATA_' + fileInfo.length;
            const mimeType = mime.lookup(relativeFilePath);
            var size = 0;
            writeStream.write('const uint8_t ' + variable + '[] PROGMEM = {');
            const zipBuffer = zlib.gzipSync(buffer);
            zipBuffer.forEach((b) => {
              if (!(size % bytesPerLine)) {
                writeStream.write('\n');
                writeStream.write(indent);
              }
              writeStream.write(
                '0x' + ('00' + b.toString(16).toUpperCase()).substr(-2) + ','
              );
              size++;
            });
            if (size % bytesPerLine) {
              writeStream.write('\n');
            }
            writeStream.write('};\n\n');
            fileInfo.push({
              uri: '/' + relativeFilePath.replace(sep, '/'),
              mimeType,
              variable,
              size
            });
          };

          const writeFiles = () => {
            // process static files
            const buildPath = compilation.options.output.path;
            for (const filePath of getFilesSync(buildPath)) {
              const readStream = readFileSync(filePath);
              const relativeFilePath = relative(buildPath, filePath);
              writeFile(relativeFilePath, readStream);
            }
            // process assets
            const { assets } = compilation;
            Object.keys(assets).forEach((relativeFilePath) => {
              writeFile(
                relativeFilePath,
                coherseToBuffer(assets[relativeFilePath].source())
              );
            });
          };

          const generateWWWClass = () => {
            return `typedef std::function<void(const String& uri, const String& contentType, const uint8_t * content, size_t len)> RouteRegistrationHandler;          

class WWWData {
${indent}public:
${indent.repeat(
  2
)}static void registerRoutes(RouteRegistrationHandler handler) {
${fileInfo
  .map(
    (file) =>
      `${indent.repeat(3)}handler("${file.uri}", "${file.mimeType}", ${
        file.variable
      }, ${file.size});`
  )
  .join('\n')}
${indent.repeat(2)}}
};
`;
          };

          const writeWWWClass = () => {
            writeStream.write(generateWWWClass());
          };

          writeIncludes();
          writeFiles();
          writeWWWClass();

          writeStream.on('finish', () => {
            callback();
          });
        } finally {
          writeStream.end();
        }
      }
    );
  }
}

module.exports = ProgmemGenerator;