const path = require(`path`);

/**
 * return source path given a locator
 * @param {*} sourceLocator 
 * @returns 
 */
function getSourceLocation(sourceLocator, pnpapi) {
  if (!sourceLocator) return null;

  const sourceInformation = pnpapi.getPackageInformation(sourceLocator);

  if (!sourceInformation)
    throw new Error(`Couldn't find the package to use as resolution source`);

  if (!sourceInformation.packageLocation)
    throw new Error(
      `The package to use as resolution source seem to not have been installed - maybe it's a devDependency not installed in prod?`
    );

  return sourceInformation.packageLocation.replace(/\/?$/, `/`);
}

/**
 *
 * @param {*} sourceLocator
 * @param {*} filter
 * @returns
 */
function makeResolver(opts) {
  const { sourceLocator, filter, pnpapi } = opts || {};
  const sourceLocation = getSourceLocation(sourceLocator, pnpapi);
  return (resolver) => {
    const BACKWARD_PATH = /^\.\.([\\\/]|$)/;

    const resolvedHook = resolver.ensureHook(`resolve`);

    // Prevents the SymlinkPlugin from kicking in. We need the symlinks to be preserved because that's how we deal with peer dependencies ambiguities.
    resolver.getHook(`file`).intercept({
      register: (tapInfo) => {
        return tapInfo.name !== `SymlinkPlugin`
          ? tapInfo
          : Object.assign({}, tapInfo, {
              fn: (request, resolveContext, callback) => {
                callback();
              },
            });
      },
    });

    resolver
      .getHook(`after-module`)
      .tapAsync(`PnpResolver`, (request, resolveContext, callback) => {
        // rethrow pnp errors if we have any for this request
        return callback(
          resolveContext.pnpErrors &&
            resolveContext.pnpErrors.get(request.context.issuer)
        );
      });

    // Register a plugin that will resolve bare imports into the package location on the filesystem before leaving the rest of the resolution to Webpack
    resolver
      .getHook(`before-module`)
      .tapAsync(`PnpResolver`, (requestContext, resolveContext, callback) => {
        let request = requestContext.request;
        let issuer = requestContext.context.issuer;

        // When using require.context, issuer seems to be false (cf https://github.com/webpack/webpack-dev-server/blob/d0725c98fb752d8c0b1e8c9067e526e22b5f5134/client-src/default/index.js#L94)
        if (!issuer) {
          issuer = `${requestContext.path}/`;
          // We only support issuer when they're absolute paths. I'm not sure the opposite can ever happen, but better check here.
        } else if (!path.isAbsolute(issuer)) {
          throw new Error(
            `Cannot successfully resolve this dependency - issuer not supported (${issuer})`
          );
        }

        if (filter) {
          const relative = path.relative(filter, issuer);
          if (path.isAbsolute(relative) || BACKWARD_PATH.test(relative)) {
            return callback(null);
          }
        }

        let resolutionIssuer = sourceLocation || issuer;
        let resolution;

        try {
          resolution = pnpapi.resolveToUnqualified(request, resolutionIssuer, {
            considerBuiltins: false,
          });
        } catch (error) {
          if (resolveContext.missingDependencies)
            resolveContext.missingDependencies.add(requestContext.path);

          if (resolveContext.log) resolveContext.log(error.message);

          resolveContext.pnpErrors = resolveContext.pnpErrors || new Map();
          resolveContext.pnpErrors.set(issuer, error);

          return callback();
        }

        resolver.doResolve(
          resolvedHook,
          Object.assign({}, requestContext, {
            request: resolution,
          }),
          null,
          resolveContext,
          callback
        );
      });
  };
}

module.exports.makeResolver = makeResolver;