const fs = require('graceful-fs');
const path = require('path');

const cachePrefix = require('./util').cachePrefix;
const pluginCompat = require('./util/plugin-compat');
const relateContext = require('./util/relate-context');

let NS;

NS = path.dirname(fs.realpathSync(__dirname));

class NormalModuleFactoryPlugin {
  apply(compiler) {
    const compilerHooks = pluginCompat.hooks(compiler);

    let fetch;

    compilerHooks._hardSourceMethods.tap(
      'HardSource - TransformNormalModuleFactoryPlugin',
      methods => {
        fetch = methods.fetch;
      },
    );

    compilerHooks.compilation.tap(
      'HardSource - TransformNormalModuleFactoryPlugin',
      (compilation, { normalModuleFactory, contextModuleFactory }) => {
        // if (!active) {return;}

        // compilation.fileTimestamps = fileTimestamps;
        // compilation.contextTimestamps = contextTimestamps;

        // compilation.__hardSourceFileMd5s = fileMd5s;
        // compilation.__hardSourceCachedMd5s = cachedMd5s;

        const compilationHooks = pluginCompat.hooks(compilation);
        compilationHooks.buildModule.tap(
          'HardSource - TransformNormalModuleFactoryPlugin',
          module => {
            if (module.constructor.name === 'NormalModule') {
              module.__originalCreateLoaderContext =
                module.__originalCreateLoaderContext ||
                module.createLoaderContext;
              module.__hardSource_resolved = {};
              module.createLoaderContext = (...args) => {
                const loaderContext = module.__originalCreateLoaderContext(
                  ...args,
                );
                const _resolve = loaderContext.resolve;
                loaderContext.resolve = (context, request, callback) => {
                  _resolve.call(
                    loaderContext,
                    context,
                    request,
                    (err, result) => {
                      if (err) {
                        callback(err, result);
                      } else {
                        module.__hardSource_resolved[
                          JSON.stringify({ context, request })
                        ] = {
                          resource: result,
                          resolveOptions: module.resolveOptions,
                        };
                        callback(err, result);
                      }
                    },
                  );
                };
                return loaderContext;
              };
            }
          },
        );

        const normalModuleFactoryHooks = pluginCompat.hooks(
          normalModuleFactory,
        );

        // Webpack 2 can use different parsers based on config rule sets.
        normalModuleFactoryHooks.parser
          .for('javascript/auto')
          .tap(
            'HardSource - TransformNormalModuleFactoryPlugin',
            (parser, options) => {
              // Store the options somewhere that can not conflict with another plugin
              // on the parser so we can look it up and store those options with a
              // cached module resolution.
              parser[`${NS}/parser-options`] = options;
            },
          );

        normalModuleFactoryHooks.resolver.tap(
          'HardSource - TransformNormalModuleFactoryPlugin',
          fn => (request, cb) => {
            const identifierPrefix = cachePrefix(compilation);
            if (identifierPrefix === null) {
              return fn.call(null, request, cb);
            }

            const cacheId = JSON.stringify([
              identifierPrefix,
              request.context,
              request.request,
            ]);
            const absCacheId = JSON.stringify([
              identifierPrefix,
              request.context,
              relateContext.relateAbsoluteRequest(
                request.context,
                request.request,
              ),
            ]);

            request.contextInfo.resolveOptions = request.resolveOptions;

            const next = () => {
              const originalRequest = request;
              return fn.call(null, request, function(err, request) {
                if (err) {
                  return cb(err);
                }
                if (!request.source) {
                  compilation.__hardSourceModuleResolveCacheChange.push(
                    cacheId,
                  );
                  compilation.__hardSourceModuleResolveCache[
                    cacheId
                  ] = Object.assign({}, request, {
                    parser: null,
                    generator: null,
                    parserOptions: request.parser[`${NS}/parser-options`],
                    type: request.settings && request.settings.type,
                    settings: request.settings,
                    resourceResolveData: request.resourceResolveData,
                    dependencies: null,
                  });
                }
                cb(...arguments);
              });
            };

            const fromCache = () => {
              const result = Object.assign(
                {},
                compilation.__hardSourceModuleResolveCache[cacheId] ||
                  compilation.__hardSourceModuleResolveCache[absCacheId],
              );
              result.dependencies = request.dependencies;

              if (!result.parser || !result.parser.parse) {
                result.parser = result.settings
                  ? normalModuleFactory.getParser(
                      result.type,
                      result.settings.parser,
                    )
                  : normalModuleFactory.getParser(result.parserOptions);
              }
              if (!result.generator && normalModuleFactory.getGenerator) {
                result.generator = normalModuleFactory.getGenerator(
                  result.type,
                  result.settings.generator,
                );
              }

              result.loaders = result.loaders.map(loader => {
                if (typeof loader === 'object' && loader.ident) {
                  const ruleSet = normalModuleFactory.ruleSet;
                  return {
                    loader: loader.loader,
                    ident: loader.ident,
                    options: ruleSet.references[loader.ident],
                  };
                }
                return loader;
              });

              return cb(null, result);
            };

            if (
              (compilation.__hardSourceModuleResolveCache[cacheId] &&
                !compilation.__hardSourceModuleResolveCache[cacheId].invalid) ||
              (compilation.__hardSourceModuleResolveCache[absCacheId] &&
                !compilation.__hardSourceModuleResolveCache[absCacheId].invalid)
            ) {
              return fromCache();
            }

            next();
          },
        );

        normalModuleFactoryHooks.createModule.tap(
          'HardSourceWebpackPlugin',
          ({ request }) => {
            if (
              compilation.cache &&
              compilation.cache[`m${request}`] &&
              compilation.cache[`m${request}`].cacheItem &&
              !compilation.cache[`m${request}`].cacheItem.invalid
            ) {
              return compilation.cache[`m${request}`];
            }

            const identifierPrefix = cachePrefix(compilation);
            if (identifierPrefix === null) {
              return;
            }

            const identifier = identifierPrefix + request;

            const module = fetch('Module', identifier, {
              compilation,
              normalModuleFactory: normalModuleFactory,
              contextModuleFactory: contextModuleFactory,
            });

            if (module) {
              return module;
            }
          },
        );
      },
    );
  }
}

module.exports = NormalModuleFactoryPlugin;