/**
 * This file is part of JIM <https://github.com/fiddlerwoaroof/jim/> (c) 2016 Edward Langley
 *
 * See the COPYING document in the root of the source distribution for licensing information.
 */
PresentationType = (function () {
  var presentationTypes = {};

  // TODO: think through selector better: right now, I think we assume that it
  //       is a class selector and things will break if it isn't we should,
  //       however, probably let it be more general.
  function PresentationType(name, selector) {
    if (this instanceof PresentationType) {
      this.name = name;
      if (selector === undefined) {
        selector = '.'+this.name;
      }
      this.selector = selector;
      this.receivers = [];
    } else {
      var result = presentationTypes[name];
      if (result === undefined) {
        result = new PresentationType(name);
        presentationTypes[result.name] = result;
      }
      return result;
    }
  }

  PresentationType.prototype = {
    presentationsTypes: presentationTypes,

    isOfType(name) {
      var type = presentationTypes[name];
      //console.log(name);
      //console.log(type);
      return type.isPrototypeOf(this);
    },

    addReceiver(receiver) {
      this.receivers.push(receiver);
      return this.receivers.length - 1;
    },

    removeReceiver(el) {
      var elIdx = this.receivers.indexOf(el);
      var result = elIdx !== -1;
      if (result) {
        this.receivers.splice(elIdx,1);
      }
      return result;
    },

    notifyReceivers(theEvent, self) {
      if (self === undefined) {
        self = this;
      }

      var outerArgs = Array.prototype.slice.call(arguments);
      outerArgs.unshift(theEvent, self, self.value);

      this.receivers.forEach((function (theReceiver) {
        theReceiver.receive.apply(theReceiver, outerArgs);
      }));

      var parent = Object.getPrototypeOf(this);
      if (parent instanceof PresentationType && parent.receivers !== undefined && parent.receivers !== []) {
        parent.notifyReceivers(theEvent, self);
      }
    },

    selectAllTags() {
      return Array.prototype.slice.call(
        document.querySelectorAll(this.selector)
      );
    },

    selectAll() {
      var allTags = this.selectAllTags();
      return Array.prototype.map.call(allTags, function (el) {
        return el.ptObject;
      });
    },

    bindTags() {
      var els = this.selectAllTags().filter(function (theEl) {
        return theEl.ptObject === undefined;
      });

      els.forEach(this.bindEl, this);

      return this;
    },

    bindEl(theEl) {
      var content = theEl.textContent.trim();
      var value = theEl.value;

      var bindTypes = theEl.dataset.bind;
      if (bindTypes !== undefined) {
        bindTypes = bindTypes.split(',');
      } else {
        bindTypes = ['click'];
      }

      //console.log('bt',bindTypes);

      if (! theEl.hasAttribute('value') ) {
        var tmpVal = theEl.dataset.value;
        value = tmpVal === undefined ? content : theEl.dataset.value;
      }

      return this.wrapTag(theEl, value, bindTypes, content);
    },

    wrapTag(tag, value, bindTypes, content) {
      var result = Object.assign(
        Object.create(this), {
          tag: tag,
          value: value,
          display: content,
        }
      );
      tag.ptObject = result;

      this.classes.forEach(function (cls) {
        tag.classList.add(cls);
      });

      bindTypes.forEach(function (event) {
        //console.log(event);
        tag.addEventListener(event, result, false);
      });

      if (result.validate()) {
        return result;
      } else {
        this.doError(result);
      }
    },

    get classes() {
      var current = this,
          classes = new Set();
      while (current instanceof PresentationType) {
        if (current.name !== undefined) {
          classes.add(current.name);
        }
        current = Object.getPrototypeOf(current);
      }

      return classes;
    },

    extend(name, props) {
      if (this.children === undefined) {
        this.children = [];
      }

      if (props === undefined) {
        props = {};
      }

      props.name = name;
      if (props.selector === undefined) {
        props.selector = '.' + name;
      }
      props.receivers = [];
      var newType = Object.assign(Object.create(this), props);
      presentationTypes[name] = newType;
      this.children.push(newType);
      return newType;
    },

    makeTag(value, tagName, bindTypes, content) {
      var newTag = document.createElement(tagName);

      this.classes.forEach(function (cls) { newTag.classList.add(cls); });

      if (bindTypes === undefined) {
        bindTypes = [];
      } else if (!(bindTypes instanceof Array)) {
        content = bindTypes;
        bindTypes = [];
      }

      if (content === undefined) {
        content = value;
      }

      newTag.textContent = content;
      return this.wrapTag(newTag, value, bindTypes, content);
    },

    handleEvent(theEvent) {
      //console.log('handling: ',theEvent);
      var handler = this[theEvent.type];
      var result = true;
      if (handler !== undefined) {
        result = handler.bind(this)(theEvent);
      }
      this.notifyReceivers(theEvent);

      return result;
    },

    doError(object) {
      return;
    },

    validate() {
      return true;
    },

    toggleAll() {
      var els = this.selectAllTags();

      els.forEach(function (el) {
        el.classList.toggle('activated');
      });
    },

    deactivateAll() {
      var els = this.selectAllTags();

      els.forEach(function (el) {
        el.classList.remove('activated');
      });
    },

    activateAll() {
      this.bindTags();
      var els = this.selectAllTags();

      els.forEach(function (el) {
        el.classList.add('activated');
      });

      return els;
    },


  };

  var typeType = PresentationType('type');
  typeType.generateTags = function (tagName) {
    if (tagName === undefined) {
      tagName = 'span';
    }

    return Object.keys(presentationTypes).map(
      function (type) {
        var tag = document.createElement(tagName);
        return this.wrapTag(tag, type, ['click'], type);
      }, this
    );
  };
  return PresentationType;
})();