import * as path from 'path';
import { IEnvironment, Service } from '../types';
import { IPlugin, IPluginManifest, Plugin } from './plugin';

import { PluginConfiguration } from '../types';
import { PluginConfigurator } from './config';

import { ScopedEventEmitter } from '../util/events';

import { NPMExecutor } from '../npm/executor';

import { logger } from '../core/logger';

export function requireNoCache(file: string): object | null {
  const fullPath = path.resolve(file);
  const mod = require(fullPath);
  if (require.cache && require.cache[fullPath]) {
    delete require.cache[fullPath];
  }
  return mod;
}

export class PluginManager {
  private plugins: Map<string, IPlugin> = new Map();
  private configs: PluginConfigurator = new PluginConfigurator(this.environment);

  constructor(
    public availablePlugins: IPluginManifest[],
    private stream: ScopedEventEmitter,
    private environment: IEnvironment,
    private npm: NPMExecutor) {
    this.addEvents();
  }

  public getAvailableByName(name: string): IPluginManifest | null {
    for (const pl of this.availablePlugins) {
      if (pl.name === name) {
        return pl;
      }
    }
    return null;
  }

  public getLoadedByName(name: string): IPlugin | null {
    if (this.plugins.has(name)) {
      return this.plugins.get(name) as IPlugin;
    }
    return null;
  }

  public getLoaded(): IPlugin[] {
    const list = []
    for (const pl of this.plugins.values()) {
      list.push(pl);
    }
    return list;
  }

  public addAvailable(manifest: IPluginManifest | IPluginManifest[]): boolean {
    // Automatically add arrays of manifests
    if (Array.isArray(manifest)) {
      let returnValue = true;
      for (const mf of manifest) {
        if (!this.addAvailable(mf)) {
          returnValue = false;
        }
      }
      return returnValue;
    }

    if (this.getAvailableByName(manifest.name)) {
      return false;
    }

    this.availablePlugins.push(manifest);
    return true;
  }

  public removeAvailable(plugin: IPluginManifest | IPluginManifest[] | string | string[]): boolean {
    let returnValue = false;
    if (Array.isArray(plugin)) {
      returnValue = true;
      for (const mf of plugin) {
        if (!this.removeAvailable(mf)) {
          returnValue = false;
        }
      }
      return returnValue;
    }

    // By name
    if (typeof plugin === 'string') {
      const p = this.getAvailableByName(plugin);
      if (!p) {
        return false;
      }
      plugin = p;
    }

    const result: IPluginManifest[] = [];
    for (const mf of this.availablePlugins) {
      if (mf === plugin) {
        returnValue = true;
        this.stream.emit('pluginUnload', mf);
        continue;
      }
      result.push(mf);
    }
    this.availablePlugins = result;

    return returnValue;
  }

  public async load(plugin: IPluginManifest): Promise<IPlugin> {
    // Don't load plugins twice
    const ready = this.getLoadedByName(plugin.name);
    if (ready) {
      return ready;
    }

    // Check dependencies
    const requires = [];
    logger.debug('Loading plugin', plugin.name);
    for (const dep of plugin.dependencies) {
      if (dep === plugin.name) {
        throw new Error(`Plugin "${plugin.name}" cannot depend on itself.`);
      }

      const existing = this.getLoadedByName(dep);
      if (!existing) {
        const available = this.getAvailableByName(dep);
        if (!available) {
          throw new Error(`Plugin dependency "${dep}" resolution failed for "${plugin.name}"`);
        }
        requires.push(available);
      }
    }

    // Load dependencies
    logger.debug('Loading plugin %s dependencies', plugin.name);
    for (const manifest of requires) {
      try {
        await this.load(manifest);
      } catch (e) {
        logger.error(e.stack);
        throw new Error(`Plugin dependency "${manifest.name}" loading failed for "${plugin.name}"`);
      }
    }

    // Load npm modules
    logger.debug('Loading plugin %s npm modules', plugin.name);
    for (const depm of plugin.npmDependencies) {
      try {
        await this.npm.installPackage(depm);
      } catch (e) {
        logger.error(e.stack);
        throw new Error(`Plugin dependency "${depm}" installation failed for "${plugin.name}"`);
      }
    }

    // Load the configuration
    const config: PluginConfiguration = await this.configs.loadConfig(plugin);

    // Ensure plugin has a full path
    if (!plugin.fullPath) {
      plugin.fullPath = path.join(this.environment.pluginsPath, plugin.name);
    }

    // Load the module
    logger.debug('Loading plugin %s module', plugin.name);
    const PluginModule = requireNoCache(path.resolve(plugin.fullPath, plugin.main)) as any;
    if (!PluginModule) {
      throw new Error(`Plugin "${plugin.name}" loading failed.`);
    }

    // Find default configuration, if it's configured, load the configuration
    if (PluginModule.prototype.__defconf && config) {
      config.setDefaults(PluginModule.prototype.__defconf);
      await config.load();
    }

    // Construct an instance of the module
    logger.debug('Instancing plugin %s', plugin.name);
    const loaded = new PluginModule(plugin, this.stream, config);
    try {
      // Give the plugin a service
      if (PluginModule.prototype.__service) {
        loaded.service = new Service(PluginModule.prototype.__service);
      }

      // Call the initializer
      if (loaded.initialize) {
        loaded.initialize.call(loaded);
      }

      // Call methods that are supposed to be executed automatically on load.
      // This is really nasty and probably shouldn't be done, but I don't care!
      for (const name of Object.getOwnPropertyNames(PluginModule.prototype)) {
        // Prevent double initialization
        if (name === 'initialize') {
          continue;
        }

        if (PluginModule.prototype[name] &&
            PluginModule.prototype[name].prototype &&
            PluginModule.prototype[name].prototype.__autoexec) {
          loaded[name].call(loaded);
        }
      }
    } catch (e) {
      logger.error(e.stack);
      throw new Error(`Plugin "${plugin.name}" initialization failed.`);
    }

    this.plugins.set(plugin.name, loaded);
    this.stream.emit('pluginLoaded', loaded);

    // Inform the new plugin that it's dependencies are available
    for (const depn of plugin.dependencies) {
      this.stream.emitTo(plugin.name, 'pluginLoaded', this.plugins.get(depn));
    }

    return loaded;
  }

  private addEvents(): void {
    this.stream.on('core', 'pluginLoad', (mf: IPluginManifest | string) => {
      if (typeof mf === 'string') {
        const manifest = this.getAvailableByName(mf);
        if (manifest) {
          return this.load(manifest).catch((e) => logger.error(e.stack));
        }
      }
    });

    this.stream.on('core', 'pluginUnloaded', (mf: IPlugin | string) => {
      if (typeof mf !== 'string') {
        if (mf.manifest && mf.service != null) {
          mf.service.die();
        }
        mf = mf.manifest.name;
      } else {
        const st = this.getLoadedByName(mf);
        if (st && st.manifest && st.service != null) {
          st.service.die();
        }
      }

      logger.debug('%s has unloaded.', mf);

      // Delete plugin from the list of loaded plugins
      this.plugins.delete(mf);

      // Remove all listeners created by the plugin
      this.stream.removeName(mf);
    });

    this.stream.on('core', 'pluginKill', (mf: IPlugin | string) => {
      const pluginName = (typeof mf === 'string' ? mf : mf.manifest.name);
      logger.debug('Killing plugin %s', pluginName);

      this.stream.emitTo(pluginName, 'pluginUnload', pluginName);
      this.stream.emit('pluginUnloaded', mf);
    });

    this.stream.on('core', 'shutdown', (state: number) => {
      // When the shutdown is initiated, this state will be zero.
      // We will be re-emitting this event with a higher state when
      // all the plugins have finished shutting down.
      if (state !== 0) {
        return;
      }

      logger.debug('Shutdown has been received by plugin manager');

      // Shutting down all the plugins
      for (const [name, plugin] of this.plugins) {
        this.stream.emitTo(name, 'pluginUnload', name);
      }

      // Every second check for plugins
      let testCount = 0;
      const testInterval = setInterval(() => {
        // There's still plugins loaded..
        if (this.plugins.size > 0 && testCount < 5) {
          testCount++;
          return;
        }

        // Shut down when there are no more plugins active or
        // after 5 seconds we just force shutdown
        clearInterval(testInterval);
        this.stream.emitTo('core', 'shutdown', 1);
      }, 1000);
    });
  }
}