const pluginCompat = require('./util/plugin-compat');
const relateContext = require('./util/relate-context');
const { parityCacheFromCache, pushParityWriteOps } = require('./util/parity');

const relateNormalPath = relateContext.relateNormalPath;

function relateNormalRequest(compiler, key) {
  return key
    .split('!')
    .map(subkey => relateNormalPath(compiler, subkey))
    .join('!');
}

function relateNormalModuleId(compiler, id) {
  return id.substring(0, 24) + relateNormalRequest(compiler, id.substring(24));
}

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

    let moduleCache = {};
    let parityCache = {};

    const moduleArchetypeCache = {
      _ops: [],

      get(id) {
        if (moduleCache[id] && !moduleCache[id].invalid) {
          if (typeof moduleCache[id] === 'string') {
            moduleCache[id] = JSON.parse(moduleCache[id]);
          }
          return moduleCache[id];
        }
      },

      set(id, item) {
        moduleCache[id] = item;
        if (item) {
          this._ops.push(id);
        } else if (moduleCache[id]) {
          if (typeof moduleCache[id] === 'string') {
            moduleCache[id] = JSON.parse(moduleCache[id]);
          }
          moduleCache[id].invalid = true;
          moduleCache[id].invalidReason = 'overwritten';

          this._ops.push(id);
        }
      },

      operations() {
        const _this = this;
        const ops = this._ops.map(id => ({
          key: relateNormalModuleId(compiler, id),
          value: _this.get(id) || null,
        }));
        this._ops.length = 0;
        return ops;
      },
    };

    compilerHooks._hardSourceArchetypeRegister.call(
      'Module',
      moduleArchetypeCache,
    );

    let moduleCacheSerializer;

    compilerHooks._hardSourceCreateSerializer.tap(
      'HardSource - ModuleCache',
      (cacheSerializerFactory, cacheDirPath) => {
        moduleCacheSerializer = cacheSerializerFactory.create({
          name: 'module',
          type: 'data',
          cacheDirPath,
          autoParse: true,
        });
      },
    );

    compilerHooks._hardSourceResetCache.tap('HardSource - ModuleCache', () => {
      moduleCache = {};
    });

    compilerHooks._hardSourceReadCache.tapPromise(
      'HardSource - ModuleCache',
      ({ contextKeys, contextNormalModuleId, copyWithDeser }) =>
        moduleCacheSerializer
          .read()
          .then(_moduleCache => {
            Object.keys(_moduleCache).forEach(key => {
              if (key.startsWith('__hardSource_parityToken')) {
                parityCache[key] = _moduleCache[key];
                delete _moduleCache[key];
              }
            });
            return _moduleCache;
          })
          .then(contextKeys(compiler, contextNormalModuleId))
          .then(copyWithDeser.bind(null, moduleCache)),
    );

    compilerHooks._hardSourceParityCache.tap(
      'HardSource - ModuleCache',
      parityRoot => {
        parityCacheFromCache('Module', parityRoot, parityCache);
      },
    );

    compilerHooks.compilation.tap('HardSource - ModuleCache', compilation => {
      compilation.__hardSourceModuleCache = moduleCache;
    });

    compilerHooks._hardSourceWriteCache.tapPromise(
      'HardSource - ModuleCache',
      compilation => {
        const moduleOps = moduleArchetypeCache.operations();

        if (!compilation.compiler.parentCompilation) {
          // Add ops to remove no longer valid modules. If they were replaced with a
          // up to date module, they will already have replaced this item so we
          // won't accidentally delete up to date modules.
          Object.keys(moduleCache).forEach(key => {
            const cacheItem = moduleCache[key];
            if (cacheItem && cacheItem.invalid) {
              // console.log('invalid', cacheItem.invalidReason);
              moduleCache[key] = null;
              moduleOps.push({
                key,
                value: null,
              });
            }
          });
        }

        pushParityWriteOps(compilation, moduleOps);

        return moduleCacheSerializer.write(moduleOps);
      },
    );
  }
}

module.exports = ModuleCache;