// Contributors:

//  Richard Livsey

//  Rahul Bhargava

//  Rob Wills

// script.aculo.us is freely distributable under the terms of an MIT-style license.

// For details, see the script.aculo.us web site: http://script.aculo.us/

// that's independent of the data source for autocompletion. This

// includes drawing the autocompletion menu, observing keyboard

// and mouse events, and similar.

//

// a getUpdatedChoices function that will be invoked every time

// should get the text for which to provide autocompletion by

// invoking this.getToken(), NOT by directly accessing

// this.element.value. This is to allow incremental tokenized

// autocompletion. Specific auto-completion logic (AJAX, etc)

// belongs in getUpdatedChoices.

//

// Tokenized incremental autocompletion is enabled automatically

// when an autocompleter is instantiated with the 'tokens' option

// in the options parameter, e.g.:

// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });

// will incrementally autocomplete with a comma as the token.

// Additionally, ',' in the above example can be replaced with

// a token array, e.g. { tokens: [',', '\n'] } which

// allows smart autocompletion after linebreaks.

if(typeof Effect == 'undefined')

  throw("controls.js requires including script.aculo.us' effects.js library");

Autocompleter.Base = Class.create({

  baseInitialize: function(element, update, options) {

    this.entryCount  = 0;

    this.oldElementValue = this.element.value;

    if(this.setOptions)

      this.setOptions(options);

    else

      this.options = options || { };

    this.options.paramName    = this.options.paramName || this.element.name;

    this.options.tokens       = this.options.tokens || [];

    this.options.frequency    = this.options.frequency || 0.4;

    this.options.minChars     = this.options.minChars || 1;

        if(!update.style.position || update.style.position=='absolute') {

          update.style.position = 'absolute';

          Position.clone(element, update, {

            offsetTop: element.offsetHeight

          });

        }

        Effect.Appear(update,{duration:0.15});

      };

      function(element, update){ new Effect.Fade(update,{duration:0.15}) };

      this.options.tokens = new Array(this.options.tokens);

    // Force carriage returns as token delimiters anyway

    if (!this.options.tokens.include('\n'))

      this.options.tokens.push('\n');

    this.observer = null;

    this.element.setAttribute('autocomplete','off');

    Element.hide(this.update);

    Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));

  },

  show: function() {

    if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);

      (Prototype.Browser.IE) &&

      (Element.getStyle(this.update, 'position')=='absolute')) {

       '<iframe id="' + this.update.id + '_iefix" '+

       'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +

       'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');

      this.iefix = $(this.update.id+'_iefix');

    }

    if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);

  },

  fixIEOverlapping: function() {

    Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});

    this.iefix.style.zIndex = 1;

    this.update.style.zIndex = 2;

    Element.show(this.iefix);

  },

  hide: function() {

    this.stopIndicator();

    if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);

    if(this.iefix) Element.hide(this.iefix);

  },

  startIndicator: function() {

    if(this.options.indicator) Element.show(this.options.indicator);

  },

  stopIndicator: function() {

    if(this.options.indicator) Element.hide(this.options.indicator);

  },

  onKeyPress: function(event) {

    if(this.active)

      switch(event.keyCode) {

       case Event.KEY_TAB:

       case Event.KEY_RETURN:

         this.selectEntry();

         Event.stop(event);

       case Event.KEY_ESC:

         this.hide();

         this.active = false;

         Event.stop(event);

         return;

       case Event.KEY_LEFT:

       case Event.KEY_RIGHT:

         return;

       case Event.KEY_UP:

         this.markPrevious();

         this.render();

         return;

       case Event.KEY_DOWN:

         this.markNext();

         this.render();

         return;

      }

         (Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;

    this.changed = true;

    this.hasFocus = true;

    if(this.observer) clearTimeout(this.observer);

        setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);

  },

  activate: function() {

    this.changed = false;

    this.hasFocus = true;

    this.getUpdatedChoices();

  },

  onHover: function(event) {

    var element = Event.findElement(event, 'LI');

    {

        this.index = element.autocompleteIndex;

        this.render();

    }

    Event.stop(event);

  },

  onClick: function(event) {

    var element = Event.findElement(event, 'LI');

    this.index = element.autocompleteIndex;

    this.selectEntry();

    this.hide();

  },

  onBlur: function(event) {

    // needed to make click events working

    setTimeout(this.hide.bind(this), 250);

    this.hasFocus = false;

  render: function() {

    if(this.entryCount > 0) {

      for (var i = 0; i < this.entryCount; i++)

          Element.removeClassName(this.getEntry(i),"selected");

        this.show();

        this.active = true;

      }

    } else {

      this.active = false;

      this.hide();

    }

  },

  markPrevious: function() {

      else this.index = this.entryCount-1;

    this.getEntry(this.index).scrollIntoView(true);

  },

  markNext: function() {

      else this.index = 0;

    this.getEntry(this.index).scrollIntoView(false);

  },

  getEntry: function(index) {

    return this.update.firstChild.childNodes[index];

  },

  getCurrentEntry: function() {

    return this.getEntry(this.index);

  },

  selectEntry: function() {

    this.active = false;

    this.updateElement(this.getCurrentEntry());

  },

  updateElement: function(selectedElement) {

    if (this.options.updateElement) {

      this.options.updateElement(selectedElement);

      return;

    }

    var value = '';

    if (this.options.select) {

      var nodes = $(selectedElement).select('.' + this.options.select) || [];

      if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);

    } else

      value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');

    var bounds = this.getTokenBounds();

    if (bounds[0] != -1) {

      var newValue = this.element.value.substr(0, bounds[0]);

      var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);

      if (whitespace)

        newValue += whitespace[0];

      this.element.value = newValue + value + this.element.value.substr(bounds[1]);

    } else {

      this.element.value = value;

    }

    this.oldElementValue = this.element.value;

    this.element.focus();

    if (this.options.afterUpdateElement)

      this.options.afterUpdateElement(this.element, selectedElement);

  },

  updateChoices: function(choices) {

    if(!this.changed && this.hasFocus) {

      this.update.innerHTML = choices;

      Element.cleanWhitespace(this.update);

      Element.cleanWhitespace(this.update.down());

      if(this.update.firstChild && this.update.down().childNodes) {

          this.update.down().childNodes.length;

        for (var i = 0; i < this.entryCount; i++) {

          var entry = this.getEntry(i);

          entry.autocompleteIndex = i;

          this.addObservers(entry);

        }

        this.entryCount = 0;

      }

      this.stopIndicator();

      this.index = 0;

      if(this.entryCount==1 && this.options.autoSelect) {

        this.selectEntry();

        this.hide();

      } else {

        this.render();

      }

    }

  },

  addObservers: function(element) {

    Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));

    Event.observe(element, "click", this.onClick.bindAsEventListener(this));

  },

  onObserverEvent: function() {

    this.tokenBounds = null;

    if(this.getToken().length>=this.options.minChars) {

      this.getUpdatedChoices();

    } else {

      this.active = false;

      this.hide();

    }

    this.oldElementValue = this.element.value;

  },

  getToken: function() {

    var bounds = this.getTokenBounds();

    return this.element.value.substring(bounds[0], bounds[1]).strip();

  },

  getTokenBounds: function() {

    if (null != this.tokenBounds) return this.tokenBounds;

    var value = this.element.value;

    if (value.strip().empty()) return [-1, 0];

    var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);

    var offset = (diff == this.oldElementValue.length ? 1 : 0);

    var prevTokenPos = -1, nextTokenPos = value.length;

    var tp;

    for (var index = 0, l = this.options.tokens.length; index < l; ++index) {

      tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);

      if (tp > prevTokenPos) prevTokenPos = tp;

      tp = value.indexOf(this.options.tokens[index], diff + offset);

      if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;

    }

    return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);

  }

});

Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function(newS, oldS) {

  var boundary = Math.min(newS.length, oldS.length);