/*

MIT License http://www.opensource.org/licenses/mit-license.php

Author Tobias Koppers @sokra

*/

"use strict";

const ModuleGraphConnection = require("./ModuleGraphConnection");

/** @typedef {import("./DependenciesBlock")} DependenciesBlock */

/** @typedef {import("./Dependency")} Dependency */

/** @typedef {import("./Module")} Module */

class ModuleGraph {

constructor() {

/** @type {Map<Dependency, ModuleGraphConnection>} */

this._dependencyMap = new Map();

/** @type {Map<Module, Set<ModuleGraphConnection>>} */

this._moduleMap = new Map();

/** @type {Map<Module, Set<ModuleGraphConnection>>} */

this._originMap = new Map();

/** @type {Map<any, Object>} */

this._metaMap = new Map();

/** @type {Map<Dependency, {module: Module, block: DependenciesBlock}>} */

this._parentsMap = new Map();

}

_getModuleSet(module) {

let connections = this._moduleMap.get(module);

if (connections === undefined) {

connections = new Set();

this._moduleMap.set(module, connections);

}

return connections;

}

_getOriginSet(module) {

let connections = this._originMap.get(module);

if (connections === undefined) {

connections = new Set();

this._originMap.set(module, connections);

}

return connections;

}

/**

* @param {Dependency} dependency the dependency

* @param {DependenciesBlock} block parent block

* @param {Module} module parent module

* @returns {void}

*/

setParents(dependency, block, module) {

this._parentsMap.set(dependency, { module, block });

}

/**

* @param {Dependency} dependency the dependency

* @returns {Module} parent module

*/

getParentModule(dependency) {

const entry = this._parentsMap.get(dependency);

return entry !== undefined ? entry.module : null;

}

/**

* @param {Dependency} dependency the dependency

* @returns {DependenciesBlock} parent block

*/

getParentBlock(dependency) {

const entry = this._parentsMap.get(dependency);

return entry !== undefined ? entry.block : null;

}

/**

* @param {Module} originModule the referencing module

* @param {Dependency} dependency the referencing dependency

* @param {Module} module the referenced module

* @returns {void}}

*/

setResolvedModule(originModule, dependency, module) {

const connection = new ModuleGraphConnection(

originModule,

dependency,

module

);

this._dependencyMap.set(dependency, connection);

const connections = this._getModuleSet(module);

connections.add(connection);

const originConnections = this._getOriginSet(originModule);

originConnections.add(connection);

}

/**

* @param {Dependency} dependency the referencing dependency

* @param {Module} module the referenced module

* @returns {void}

*/

updateModule(dependency, module) {

const connection = this._dependencyMap.get(dependency);

if (connection.module === module) return;

const oldSet = this._moduleMap.get(connection.module);

oldSet.delete(connection);

connection.module = module;

const newSet = this._moduleMap.get(module);

newSet.add(connection);

}

/**

* @param {Dependency} dependency the referencing dependency

* @param {string} explanation an explanation

* @returns {void}

*/

addExplanation(dependency, explanation) {

const connection = this._dependencyMap.get(dependency);

connection.addExplanation(explanation);

}

/**

* @param {Module} oldModule the old referencing module

* @param {Module} newModule the new referencing module

* @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement

* @returns {void}

*/

replaceModule(oldModule, newModule, filterConnection) {

if (oldModule === newModule) return;

const oldConnections = this._getOriginSet(oldModule);

const newConnections = this._getOriginSet(newModule);

for (const connection of oldConnections) {

if (filterConnection(connection)) {

connection.originModule = newModule;

newConnections.add(connection);

oldConnections.delete(connection);

}

}

const oldConnections2 = this._getModuleSet(oldModule);

const newConnections2 = this._getModuleSet(newModule);

for (const connection of oldConnections2) {

if (filterConnection(connection)) {

connection.module = newModule;

newConnections2.add(connection);

oldConnections2.delete(connection);

}

}

}

/**

* @param {Module} module the referenced module

* @param {string} explanation an explanation why it's referenced

* @returns {void}

*/

addExtraReason(module, explanation) {

const connections = this._getModuleSet(module);

connections.add(new ModuleGraphConnection(null, null, module, explanation));

}

/**

* @param {Dependency} dependency the dependency to look for a referenced module

* @returns {Module} the referenced module

*/

getResolvedModule(dependency) {

const connection = this._dependencyMap.get(dependency);

return connection !== undefined ? connection.resolvedModule : null;

}

/**

* @param {Dependency} dependency the dependency to look for a referenced module

* @returns {ModuleGraphConnection | undefined} the connection

*/

getConnection(dependency) {

const connection = this._dependencyMap.get(dependency);

return connection;

}

/**

* @param {Dependency} dependency the dependency to look for a referenced module

* @returns {Module} the referenced module

*/

getModule(dependency) {

const connection = this._dependencyMap.get(dependency);

return connection !== undefined ? connection.module : null;

}

/**

* @param {Dependency} dependency the dependency to look for a referencing module

* @returns {Module} the referencing module

*/

getOrigin(dependency) {

const connection = this._dependencyMap.get(dependency);

return connection !== undefined ? connection.originModule : null;

}

/**

* @param {Dependency} dependency the dependency to look for a referencing module

* @returns {Module} the original referencing module

*/

getResolvedOrigin(dependency) {

const connection = this._dependencyMap.get(dependency);

return connection !== undefined ? connection.resolvedOriginModule : null;

}

/**

* @param {Module} module the module

* @returns {ModuleGraphConnection[]} reasons why a module is included

*/

getIncomingConnections(module) {

const connections = this._getModuleSet(module);

return Array.from(connections);

}

/**

* @param {Module} module the module

* @returns {ModuleGraphConnection[]} list of outgoing connections

*/

getOutgoingConnection(module) {

const connections = this._getOriginSet(module);

return Array.from(connections);

}

/**

* @param {any} thing any thing

* @returns {Object} metadata

*/

getMeta(thing) {

let meta = this._metaMap.get(thing);

if (meta === undefined) {

meta = Object.create(null);

this._metaMap.set(thing, meta);

}

return meta;

}

}

module.exports = ModuleGraph;

module.exports.ModuleGraphConnection = ModuleGraphConnection;