;(function()
{
  /**
   * Namespace for Yesco library
   */
  if (typeof yesco == 'undefined')
  {
    yesco =
    {
      config: {},

      REGEX_EMAIL_ADDRESS: /(\W|^|<)([^@\s<>]+?@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,4})(>|\W|$)/i,

      /**
       * Method enableDebugMode which will enable logging of non critical events
       *
       * @param {Void}
       * @return {Void}
       */
      enableDebugMode: function()
      {
        yesco.config.enableDebugMode = true;
      },

      /**
       * Method that adds this function to the window onload event
       *
       * @param {Function} func
       * @return {Void}
       */
      addOnLoad: function(func)
      {
        var oldonload = window.onload;

	      if (typeof window.onload != 'function')
        {
		      window.onload = func;
	      }
        else
        {
		      window.onload = function()
		      {
			      oldonload();
			      func();
		      }
	      }
      },

      /**
       * Method log which will log the provided value
       *
       * @param {Mixed}
       * @param {String} type
       * @return {Void}
       */
      log: function(value, type)
      {
        if (typeof console != 'undefined')
        {
          if (type == 'error')
            console.error(value);
          else if (yesco.config.enableDebugMode === true)
            console.log(value);

        }
      },

      /**
       * Method connect which connects an event to an element
       *
       * @param {Object} object
       * @param {String} event (without on infront of it)
       * @param {Object} scope
       * @param {Object} func
       * @return {Object} EventHandle
       */
      connect: function(object, event, scope, func)
      {
        // No Scope provided
        if (arguments.length == 3)
          func = scope;
        else
          func = this._changeScope(scope, func);

        if (object.addEventListener)
          return object.addEventListener(event, func, false);
        else if (object.attachEvent)
          return object.attachEvent('on' + event, func);

      },

      /**
       * Method that allows to fire a certain function within a certain scope
       *
       * @param {Object} scope
       * @param {Object} method
       * @return {Void}
       */
      _changeScope: function(scope, method)
      {
        return function() { method.apply(scope, arguments) };
      },

      /**
       * Method stopEvent which prevents an event from performing it's default behavior
       *
       * @param {HTMLDomEvent} event
       * @return {Void}
       */
      stopEvent: function(event)
      {
        if (event)
        {
          if (event.preventDefault)
          {
            event.preventDefault();
            event.stopPropagation();
          }
          else // IE doesn't support the above
          {
            event.returnValue = false;
          }

        }
      },

      /**
       * Method hasClass which checks if the provided element has a class
       *
       * @param {HTMLDomElement} elem
       * @param {String} className
       * @return {Boolean}
       */
      hasClass: function(elem, className)
      {
        if (!elem || !elem.className || !elem.className.split)
          return false;

        var classes = elem.className.split(' ');

        for (var i = 0; i < classes.length; i++)
        {
          if (classes[i] == className)
            return true;

        }

        return false;
      },

      /**
       * Method addClass which adds a certain class to an element in case it hasn't got it yet
       *
       * @param {HTMLDomElement} elem
       * @param {String} className
       * @return {Boolean}
       */
      addClass: function(elem, className)
      {
        if (!elem || !elem.className || !elem.className.split)
          return false;

        if (yesco.hasClass(elem, className))
          return false;

        if (className.trim) // Not supported in old browsers
          className = className.trim();

        var classes = elem.className.split(' ');
        classes.push(className);
        elem.className  = classes.join(' ');
      },

      /**
       * Method removeClass which removes a certain class from an element in case it has it
       *
       * @param {HTMLDomElement} elem
       * @param {String} className
       * @return {Boolean}
       */
      removeClass: function(elem, className)
      {
        if (!elem || !elem.className || !elem.className.split)
          return false;

        if (!yesco.hasClass(elem, className))
          return false;

        if (className.trim) // Not supported in old browsers
          className      = className.trim();

        var classes    = [];
        var oldClasses = elem.className.split(' ');

        for (var i = 0; i < oldClasses.length; i++)
        {
          if (oldClasses[i] != className)
            classes.push(oldClasses[i]);

        }

        elem.className  = classes.join(' ');
      },

      /**
       * Method getComputedStyle which returns the actual style set using javascript inline css or embedded css
       *
       * @param {HTMLDomElement} elem
       * @param {String} style
       * @return {String}
       */
      getComputedStyle: function(elem, style)
      {
        var computedStyle;

        if (typeof elem.currentStyle != 'undefined')
          computedStyle = elem.currentStyle;
        else
          computedStyle = document.defaultView.getComputedStyle(elem, null);

        return computedStyle[style];
      },

      /**
       * Method which adds an embedded style to the page
       *
       * @param {String} newStyle
       * @param {String} referenceName
       * @return {Void}
       */
      setStyle: function(newStyle, referenceName)
      {
        if (!yesco.styles)
          yesco.styles = [];

        var style = false;

        if (yesco.styles[referenceName])
        {
          style = yesco.styles[referenceName];
        }
        else
        {
          style = document.createElement('style');
          style.type = 'text/css';
          yesco.styles[referenceName] = style;
        }

        if (style.styleSheet) // IE
          style.styleSheet.cssText = newStyle;
        else if (style.innerText) // Chrome / Safari
          style.innerText = newStyle;
        else // Opera / FireFox
          style.innerHTML = newStyle;

        document.body.appendChild(style);
      },

      EventTarget: function()
      {
        this._listeners = {};
      }

    };

    // Copyright (c) 2010 Nicholas C. Zakas. All rights reserved.
    // MIT License
    yesco.EventTarget.prototype =
    {
      constructor: yesco.EventTarget,

      addEventListener: function(type, listener)
      {
        if (typeof this._listeners[type] == "undefined")
          this._listeners[type] = [];

        this._listeners[type].push(listener);
      },

      fire: function(event)
      {
        if (typeof event == "string")
          event = { type: event };

        if (!event.target)
          event.target = this;

        if (!event.type)
          throw new Error("Event object missing 'type' property.");

        if (this._listeners[event.type] instanceof Array)
        {
          var listeners = this._listeners[event.type];

          for (var i = 0, len = listeners.length; i < len; i++)
          {
            // @TODO: Write so it can call with dynamic parameters given by an array
            if (event.param2)
              listeners[i].call(this, event.param1, event.param2);
            else if (event.param1)
              listeners[i].call(this, event.param1);
            else
              listeners[i].call(this, event);

          }
        }
      },

      removeListener: function(type, listener)
      {
        if (this._listeners[type] instanceof Array)
        {
          var listeners = this._listeners[type];

          for (var i=0, len=listeners.length; i < len; i++)
          {
            if (listeners[i] === listener)
            {
              listeners.splice(i, 1);
              break;
            }
          }
        }
      }
    };

  }
})();
if (!yesco.Form)
{
  yesco.Form = function(elem)
  {
    this._ERROR_INVALID_FIELDS                = 'Formulier bevat incorrecte gegevens of niet ingevulde velden.';
    this._INVALID_FIELD_CLASSNAME             = 'y-invalid';
    this._REQUIRED_FIELD_CLASSNAME            = 'required';
    this._DISABLE_DEFAULT_STYLING_CLASSNAME   = 'y-disable-default-styling';
    this._PLACEHOLDER_SET_CLASSNAME           = 'y-placeholder-set';
    
    this._placeholderSupport                  = false;

    /**
     * Constructor of the form object
     */
    this._constructor = function(elem)
    {
      this._elem                      = elem;
      this._validatedOnce             = false;
      this._defaultFieldBorderStyling = '';

      // Check if the form tag has a certain class so they can style the form as they want for themselfs
      if (!yesco.hasClass(this._elem, this._DISABLE_DEFAULT_STYLING_CLASSNAME))
      {
        var newStyle = '.' + this._INVALID_FIELD_CLASSNAME + ' { border: 1px solid #993233!important; }';
        newStyle += ' .y-messagebox-holder { background-color: #993233; color: #FFF; }';
        newStyle += ' .y-messagebox-holder p { margin: 0!important; padding: 5px!important; } ';

        yesco.setStyle(newStyle, 'y-form-fields');
      }

      // Initialize the fields within this form
      this._requiredFields  = [];
      this._emailFields     = [];

      var fieldElem;
      var placeholder;
			var charsetUsed	= false;
      
      this._placeholderSupport = yesco.browser.can.Placeholder();

      // Loop though fields
      for (field = 0; field < this._elem.elements.length; field++)
      {
        fieldElem = this._elem.elements[field];
        
        // BEGIN PLACE HOLDER
        if (!this._placeholderSupport)
        {
          this._togglePlaceholder(fieldElem, true);
        }
        // END PLACE HOLDER

        // BEGIN PLACE HOLDER
        if (!this._placeholderSupport)
        {
          yesco.connect(fieldElem, 'focus', this, function(event)
          {
            var elem = event.target ? event.target: event.srcElement;
            
            this._togglePlaceholder(elem, false);            
          });
        }
        // END PLACE HOLDER

        
        yesco.connect(fieldElem, 'blur', this, function(event)
        {
          var elem = event.target ? event.target: event.srcElement;
          
          // BEGIN PLACE HOLDER
          if (!this._placeholderSupport)
          {
            this._togglePlaceholder(elem, true);
          }
          // END PLACE HOLDER
          
          if (yesco.hasClass(elem, this._REQUIRED_FIELD_CLASSNAME))
          {
            if (this._validatedOnce)
            {
              if (this._isValid())
                this._hideMessageBox();
              else
                this._showMessageBox(this._ERROR_INVALID_FIELDS, 'error');
  
            }
          }
        });

        if (yesco.hasClass(fieldElem, this._REQUIRED_FIELD_CLASSNAME))
        {
          this._requiredFields.push(fieldElem);
        }

        if (fieldElem.name)
        {
          if (fieldElem.name.indexOf('email') !== -1)
            this._emailFields.push(fieldElem);

					if (fieldElem.name === 'charset')
						charsetUsed = true;
        }
      }
			
			// Place a charset hidden input field if not set
			if (charsetUsed === false && (document['querySelector'] !== null) && Element.prototype.hasOwnProperty('prepend'))
			{
				var headCharsetElem = document.head.querySelector("meta[charset]");
				if (headCharsetElem)
				{
					var headCharset =	headCharsetElem.getAttribute('charset');
					
					if (['UTF-8', 'utf-8', 'ISO-8859-1', 'iso-8859-1', 'ISO-8859-15', 'iso-8859-15'].indexOf(headCharset) !== -1)
					{
						var formCharsetElem = document.createElement("input");
						formCharsetElem.setAttribute('type', 'hidden');
						formCharsetElem.setAttribute('name', 'charset');
						formCharsetElem.setAttribute('value', headCharsetElem.getAttribute('charset'));

						this._elem.prepend(formCharsetElem);
					}
				}
			}

      // Connect to the onSubmit event of the form object
      yesco.connect(this._elem, 'submit', this, function(event)
      {
        this._hideMessageBox();
        
        // BEGIN PLACE HOLDER
        if (!this._placeholderSupport)
        {
          var fieldElem;

          // Loop though fields to remove placeholder values
          for (field = 0; field < this._elem.elements.length; field++)
          {
            fieldElem = this._elem.elements[field];
            
            this._togglePlaceholder(fieldElem, false);
          }
        }
        // END PLACE HOLDER

        if (!this._isValid())
        {
          yesco.stopEvent(event);
          this._showMessageBox(this._ERROR_INVALID_FIELDS, 'error');
        }

        this._validatedOnce = true;
        
        // BEGIN PLACE HOLDER
        if (!this._placeholderSupport)
        {
          var fieldElem;
          var placeholder;

          // Loop though fields to remove placeholder values
          for (field = 0; field < this._elem.elements.length; field++)
          {
            fieldElem = this._elem.elements[field];
            
            this._togglePlaceholder(fieldElem, true);
          }
        }
        // END PLACE HOLDER
      });
    },
    
    /**
     * Method _togglePlaceholder
     * 
     * @param {HTMLDOMElement} elem
     * @param {Boolean} show
     * @return {Void}
     */
    this._togglePlaceholder = function(elem, show)
    {
      if (elem.placeholder)
      {
        if (show == true)
        {
          if (!elem.value)
          {
            placeholder = elem.placeholder;
            
            elem.value = placeholder;
            
            yesco.addClass(elem, this._PLACEHOLDER_SET_CLASSNAME);
          }
        }
        else
        {
          if (elem.value && elem.value == elem.placeholder)
          {
            elem.value = '';
            
            yesco.removeClass(elem, this._PLACEHOLDER_SET_CLASSNAME);
          }
        }
      }
    },

    /**
     * Method _showMessageBox which hides the current messagebox
     *
     * @param {String} message
     * @param {String} messageType
     * @return {Void}
     */
    this._showMessageBox = function(message, messageType)
    {
      if (!this._messageBox)
      {
        this._messageBoxHolder = document.createElement('div');
        this._messageBoxHolder.className = 'y-messagebox-holder';

        this._messageBox       = document.createElement('div');
        this._messageBox.className  = 'y-messagebox ' + messageType;

        this._message          = document.createElement('p');

        this._messageBox.appendChild(this._message);
        this._messageBoxHolder.appendChild(this._messageBox);

        if (this._elem.childNodes[0])
          this._elem.insertBefore(this._messageBoxHolder, this._elem.childNodes[0]);
        else
          this._elem.appendChild(this._messageBoxHolder);

      }

      this._message.innerHTML = message;

      this._messageBoxHolder.style.display = 'block';
    }

    /**
     * Method _hideMessageBox which hides the current messagebox
     *
     * @param {Void}
     * @return {Void}
     */
    this._hideMessageBox = function()
    {
      if (this._messageBoxHolder)
        this._messageBoxHolder.style.display = 'none';

    }

    /**
     * Method _isValid
     */
    this._isValid = function()
    {
      yesco.log('Form: validating the user input');

      var valid = true;
      var requiredField;

      for (var i = 0; i < this._requiredFields.length; i++)
      {
        requiredField = this._requiredFields[i];

        // Required field is empty
        if (!requiredField.value)
        {
          yesco.addClass(requiredField, this._INVALID_FIELD_CLASSNAME);
          valid = false;
        }
        else
        {
          yesco.removeClass(requiredField, this._INVALID_FIELD_CLASSNAME);
        }

      }

      for (var i = 0; i < this._emailFields.length; i++)
      {
        emailField = this._emailFields[i];

        // Required field is empty
        if (emailField.value)
        {
          if (emailField.value.match(yesco.REGEX_EMAIL_ADDRESS) == null)
          {
            yesco.addClass(emailField, this._INVALID_FIELD_CLASSNAME);
            valid = false;
          }
          else
          {
            yesco.removeClass(emailField, this._INVALID_FIELD_CLASSNAME);
          }
        }
      }

      return valid;
    }

    this._constructor(elem);
  }
}

if (!yesco.responseForms)
{
  yesco.responseForms = function()
  {
    /**
     * Setup of response forms
     */
    this._setup = function()
    {
      this._forms = [];

      var forms = document.getElementsByTagName('form');
      for (var i=0; i < forms.length; i++)
      {
        if (forms[i].elements['yesco_key'])
        {
          this._forms = new yesco.Form(forms[i]);
        }
      }
    }

    this._setup();
  }

  yesco.addOnLoad(function()
    {
      yesco.enableDebugMode();
      new yesco.responseForms();
    });
}

if (!yesco.browser)
{
  yesco.browser = {
      can: {
        Placeholder: function () {
          return 'placeholder' in document.createElement('input'); 
        }
      }
    }
}