import Service, { inject as service } from '@ember/service';
import { proxy } from 'consul-ui/utils/dom/event-source';

import MultiMap from 'mnemonist/multi-map';

// TODO: Expose sizes of things via env vars

// caches cursors and previous events when the EventSources are destroyed
let cache = null;
// keeps a record of currently in use EventSources
let sources = null;
// keeps a count of currently in use EventSources
let usage = null;
export default class DataSourceService extends Service {
  @service('dom')
  dom;

  @service('encoder')
  encoder;

  @service('data-source/protocols/http')
  consul;

  @service('data-source/protocols/local-storage')
  settings;

  init() {
    super.init(...arguments);
    cache = new Map();
    sources = new Map();
    usage = new MultiMap(Set);
    this._listeners = this.dom.listeners();
  }

  resetCache() {
    cache = new Map();
  }

  willDestroy() {
    this._listeners.remove();
    sources.forEach(function(item) {
      item.close();
    });
    cache = null;
    sources = null;
    usage.clear();
    usage = null;
  }

  source(cb, attrs) {
    const src = cb(this.encoder.uriTag());
    return new Promise((resolve, reject) => {
      const ref = {};
      const source = this.open(src, ref, true);
      source.configuration.ref = ref;
      const remove = this._listeners.add(source, {
        message: e => {
          remove();
          // the source only gets wrapped in the proxy
          // after the first message
          // but the proxy itself is resolve to the route
          resolve(proxy(e.target, e.data));
        },
        error: e => {
          remove();
          this.close(source, ref);
          reject(e.error);
        },
      });
      if (typeof source.getCurrentEvent() !== 'undefined') {
        source.dispatchEvent(source.getCurrentEvent());
      }
    });
  }

  unwrap(src, ref) {
    const source = src._source;
    usage.set(source, ref);
    usage.remove(source, source.configuration.ref);
    delete source.configuration.ref;
    return source;
  }

  open(uri, ref, open = false) {
    if (typeof uri !== 'string') {
      return this.unwrap(uri, ref);
    }
    let source;
    // Check the cache for an EventSource that is already being used
    // for this uri. If we don't have one, set one up.
    if (uri.indexOf('://') === -1) {
      uri = `consul://${uri}`;
    }
    let [providerName, pathname] = uri.split('://');
    const provider = this[providerName];
    if (!sources.has(uri)) {
      let configuration = {};
      if (cache.has(uri)) {
        configuration = cache.get(uri);
      }
      configuration.uri = uri;
      source = provider.source(pathname, configuration);
      const remove = this._listeners.add(source, {
        close: e => {
          // a close could be fired either by:
          // 1. A non-blocking query leaving the page
          // 2. A non-blocking query responding
          // 3. A blocking query responding when is in a closing state
          // 3. A non-blocking query or a blocking query being cancelled
          const source = e.target;
          const event = source.getCurrentEvent();
          const cursor = source.configuration.cursor;
          // only cache data if we have any
          if (typeof event !== 'undefined' && typeof cursor !== 'undefined') {
            cache.set(uri, {
              currentEvent: event,
              cursor: cursor,
            });
          }
          // the data is cached delete the EventSource
          if (!usage.has(source)) {
            // A non-blocking query could close but still be on the page
            sources.delete(uri);
          }
          remove();
        },
      });
      sources.set(uri, source);
    } else {
      source = sources.get(uri);
      // bump to the end of the list
      sources.delete(uri);
      sources.set(uri, source);
    }
    // only open if its not already being used
    // in the case of blocking queries being disabled
    // you may want to specifically force an open
    // if blocking queries are enabled then opening an already
    // open blocking query does nothing
    if (!usage.has(source) || source.readyState > 1 || open) {
      source.open();
    }
    // set/increase the usage counter
    usage.set(source, ref);
    return source;
  }

  close(source, ref) {
    // this close is called when the source has either left the page
    // or in the case of a proxied source, it errors
    if (source) {
      // decrease the usage counter
      usage.remove(source, ref);
      // if the EventSource is no longer being used
      // close it (data caching is dealt with by the above 'close' event listener)
      if (!usage.has(source)) {
        source.close();
        if (source.readyState === 2) {
          // in the case that a non-blocking query is on the page
          // and it has already responded and has therefore been cached
          // but not removed itself from sources
          // delete from sources
          sources.delete(source.configuration.uri);
        }
      }
    }
  }

  closed() {
    // anything that is closed or closing
    return [...sources.entries()]
      .filter(([key, item]) => {
        return item.readyState > 1;
      })
      .map(item => item[0]);
  }
}