/**
 * Copyright (c) 2010 Maxim Vasiliev
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * @author Maxim Vasiliev
 * Date: 09.09.2010
 * Time: 19:02:33
 */

(function (root, factory) {
  if (
    typeof exports !== 'undefined' &&
    typeof module !== 'undefined' &&
    module.exports
  ) {
    // NodeJS
    module.exports = factory();
  } else if (typeof define === 'function' && define.amd) {
    // AMD. Register as an anonymous module.
    define(factory);
  } else {
    // Browser globals
    root.form2js = factory();
  }
})(this, function () {
  'use strict';

  /**
   * Returns form values represented as Javascript object
   * "name" attribute defines structure of resulting object
   *
   * @param rootNode {Element|String} root form element (or it's id) or array of root elements
   * @param delimiter {String} structure parts delimiter defaults to '.'
   * @param skipEmpty {Boolean} should skip empty text values, defaults to true
   * @param nodeCallback {Function} custom function to get node value
   * @param useIdIfEmptyName {Boolean} if true value of id attribute of field will be used if name of field is empty
   */
  function form2js(
    rootNode,
    delimiter,
    skipEmpty,
    nodeCallback,
    useIdIfEmptyName,
    getDisabled
  ) {
    getDisabled = getDisabled ? true : false;
    if (typeof skipEmpty === 'undefined' || skipEmpty == null) skipEmpty = true;
    if (typeof delimiter === 'undefined' || delimiter == null) delimiter = '.';
    if (arguments.length < 5) useIdIfEmptyName = false;

    rootNode =
      typeof rootNode == 'string'
        ? document.getElementById(rootNode)
        : rootNode;

    var formValues = [],
      currNode,
      i = 0;

    /* If rootNode is array - combine values */
    if (
      rootNode.constructor == Array ||
      (typeof NodeList !== 'undefined' && rootNode.constructor == NodeList)
    ) {
      while ((currNode = rootNode[i++])) {
        formValues = formValues.concat(
          getFormValues(currNode, nodeCallback, useIdIfEmptyName, getDisabled)
        );
      }
    } else {
      formValues = getFormValues(
        rootNode,
        nodeCallback,
        useIdIfEmptyName,
        getDisabled
      );
    }

    return processNameValues(formValues, skipEmpty, delimiter);
  }

  /**
   * Processes collection of { name: 'name', value: 'value' } objects.
   * @param nameValues
   * @param skipEmpty if true skips elements with value == '' or value == null
   * @param delimiter
   */
  function processNameValues(nameValues, skipEmpty, delimiter) {
    var result = {},
      arrays = {},
      i,
      j,
      k,
      l,
      value,
      nameParts,
      currResult,
      arrNameFull,
      arrName,
      arrIdx,
      namePart,
      name,
      _nameParts;

    for (i = 0; i < nameValues.length; i++) {
      value = nameValues[i].value;

      if (skipEmpty && (value === '' || value === null)) continue;

      name = nameValues[i].name;
      _nameParts = name.split(delimiter);
      nameParts = [];
      currResult = result;
      arrNameFull = '';

      for (j = 0; j < _nameParts.length; j++) {
        namePart = _nameParts[j].split('][');
        if (namePart.length > 1) {
          for (k = 0; k < namePart.length; k++) {
            if (k == 0) {
              namePart[k] = namePart[k] + ']';
            } else if (k == namePart.length - 1) {
              namePart[k] = '[' + namePart[k];
            } else {
              namePart[k] = '[' + namePart[k] + ']';
            }

            arrIdx = namePart[k].match(/([a-z_]+)?\[([a-z_][a-z0-9_]+?)\]/i);
            if (arrIdx) {
              for (l = 1; l < arrIdx.length; l++) {
                if (arrIdx[l]) nameParts.push(arrIdx[l]);
              }
            } else {
              nameParts.push(namePart[k]);
            }
          }
        } else nameParts = nameParts.concat(namePart);
      }

      for (j = 0; j < nameParts.length; j++) {
        namePart = nameParts[j];

        if (namePart.indexOf('[]') > -1 && j == nameParts.length - 1) {
          arrName = namePart.substr(0, namePart.indexOf('['));
          arrNameFull += arrName;

          if (!currResult[arrName]) currResult[arrName] = [];
          currResult[arrName].push(value);
        } else if (namePart.indexOf('[') > -1) {
          arrName = namePart.substr(0, namePart.indexOf('['));
          arrIdx = namePart.replace(/(^([a-z_]+)?\[)|(\]$)/gi, '');

          /* Unique array name */
          arrNameFull += '_' + arrName + '_' + arrIdx;

          /*
           * Because arrIdx in field name can be not zero-based and step can be
           * other than 1, we can't use them in target array directly.
           * Instead we're making a hash where key is arrIdx and value is a reference to
           * added array element
           */

          if (!arrays[arrNameFull]) arrays[arrNameFull] = {};
          if (arrName != '' && !currResult[arrName]) currResult[arrName] = [];

          if (j == nameParts.length - 1) {
            if (arrName == '') {
              currResult.push(value);
              arrays[arrNameFull][arrIdx] = currResult[currResult.length - 1];
            } else {
              currResult[arrName].push(value);
              arrays[arrNameFull][arrIdx] =
                currResult[arrName][currResult[arrName].length - 1];
            }
          } else {
            if (!arrays[arrNameFull][arrIdx]) {
              if (/^[0-9a-z_]+\[?/i.test(nameParts[j + 1]))
                currResult[arrName].push({});
              else currResult[arrName].push([]);

              arrays[arrNameFull][arrIdx] =
                currResult[arrName][currResult[arrName].length - 1];
            }
          }

          currResult = arrays[arrNameFull][arrIdx];
        } else {
          arrNameFull += namePart;

          if (j < nameParts.length - 1) {
            /* Not the last part of name - means object */ if (
              !currResult[namePart]
            )
              currResult[namePart] = {};
            currResult = currResult[namePart];
          } else {
            currResult[namePart] = value;
          }
        }
      }
    }

    return result;
  }

  function getFormValues(
    rootNode,
    nodeCallback,
    useIdIfEmptyName,
    getDisabled
  ) {
    var result = extractNodeValues(
      rootNode,
      nodeCallback,
      useIdIfEmptyName,
      getDisabled
    );
    return result.length > 0
      ? result
      : getSubFormValues(rootNode, nodeCallback, useIdIfEmptyName, getDisabled);
  }

  function getSubFormValues(
    rootNode,
    nodeCallback,
    useIdIfEmptyName,
    getDisabled
  ) {
    var result = [],
      currentNode = rootNode.firstChild;

    while (currentNode) {
      result = result.concat(
        extractNodeValues(
          currentNode,
          nodeCallback,
          useIdIfEmptyName,
          getDisabled
        )
      );
      currentNode = currentNode.nextSibling;
    }

    return result;
  }

  function extractNodeValues(
    node,
    nodeCallback,
    useIdIfEmptyName,
    getDisabled
  ) {
    if (node.disabled && !getDisabled) return [];

    var callbackResult,
      fieldValue,
      result,
      fieldName = getFieldName(node, useIdIfEmptyName);

    callbackResult = nodeCallback && nodeCallback(node);

    if (callbackResult && callbackResult.name) {
      result = [callbackResult];
    } else if (fieldName != '' && node.nodeName.match(/INPUT|TEXTAREA/i)) {
      fieldValue = getFieldValue(node, getDisabled);
      if (null === fieldValue) {
        result = [];
      } else {
        result = [{ name: fieldName, value: fieldValue }];
      }
    } else if (fieldName != '' && node.nodeName.match(/SELECT/i)) {
      fieldValue = getFieldValue(node, getDisabled);
      result = [{ name: fieldName.replace(/\[\]$/, ''), value: fieldValue }];
    } else {
      result = getSubFormValues(
        node,
        nodeCallback,
        useIdIfEmptyName,
        getDisabled
      );
    }

    return result;
  }

  function getFieldName(node, useIdIfEmptyName) {
    if (node.name && node.name != '') return node.name;
    else if (useIdIfEmptyName && node.id && node.id != '') return node.id;
    else return '';
  }

  function htmlEscape(text) {
    if (!text) {
      return text;
    }

    // Matching minden elemre, ami < és > között van.
    // Capture groupba a < és > közötti tartalom kerül, így csak a relációs jelek cserélődnek le.
    return text.replace(/<([\w\W]+?)>/g, '$lt;$1$gt;');
  }

  function getFieldValue(fieldNode, getDisabled) {
    if (fieldNode.disabled && !getDisabled) return null;

    switch (fieldNode.nodeName) {
      case 'INPUT':
      case 'TEXTAREA':
        switch (fieldNode.type.toLowerCase()) {
          case 'radio':
            if (fieldNode.checked && fieldNode.value === 'false') return false;
          case 'checkbox':
            if (fieldNode.checked && fieldNode.value === 'true') return true;
            if (!fieldNode.checked && fieldNode.value === 'true') return false;
            if (fieldNode.checked) return fieldNode.value;
            break;
          case 'hidden':
            var chk = $(
              'form input[type=checkbox][name="' + fieldNode.name + '"]'
            );
            if (chk.length > 0) {
              return chk.prop('checked');
            } else {
              return fieldNode.value;
            }
            break;
          case 'button':
          case 'reset':
          case 'submit':
          case 'image':
            return '';
            break;
          case 'textarea':
            if ($.inArray('htmlEditor', fieldNode.classList) !== -1) {
              return fieldNode.value;
            } else {
              return htmlEscape(fieldNode.value);
            }
            break;
          default:
            return htmlEscape(fieldNode.value);
            break;
        }
        break;

      case 'SELECT':
        return getSelectedOptionValue(fieldNode);
        break;

      default:
        break;
    }

    return null;
  }

  function getSelectedOptionValue(selectNode) {
    var multiple = selectNode.multiple,
      result = [],
      options,
      i,
      l;

    if (!multiple) return selectNode.value;

    for (
      options = selectNode.getElementsByTagName('option'),
        i = 0,
        l = options.length;
      i < l;
      i++
    ) {
      if (options[i].selected) result.push(options[i].value);
    }

    return result;
  }

  return form2js;
});

/**
 * Copyright (c) 2010 Maxim Vasiliev
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * @author Maxim Vasiliev
 * Date: 29.06.11
 * Time: 20:09
 */

(function ($) {
  /**
   * jQuery wrapper for form2object()
   * Extracts data from child inputs into javascript object
   */
  $.fn.toObject = function (options) {
    var result = [],
      settings = {
        mode: 'first', // what to convert: 'all' or 'first' matched node
        delimiter: '.',
        skipEmpty: true,
        nodeCallback: null,
        useIdIfEmptyName: false,
        getDisabled: false
      };

    if (options) {
      $.extend(settings, options);
    }

    switch (settings.mode) {
      case 'first':
        return form2js(
          this.get(0),
          settings.delimiter,
          settings.skipEmpty,
          settings.nodeCallback,
          settings.useIdIfEmptyName,
          settings.getDisabled
        );
        break;
      case 'all':
        this.each(function () {
          result.push(
            form2js(
              this,
              settings.delimiter,
              settings.skipEmpty,
              settings.nodeCallback,
              settings.useIdIfEmptyName,
              settings.getDisabled
            )
          );
        });
        return result;
        break;
      case 'combine':
        return form2js(
          Array.prototype.slice.call(this),
          settings.delimiter,
          settings.skipEmpty,
          settings.nodeCallback,
          settings.useIdIfEmptyName,
          settings.getDisabled
        );
        break;
    }
  };
})(jQuery);

//Json sorosítani lehet vele a form-t
$.fn.serializeObject = function () {
  var o = {};
  var a = this.find('input, textarea')
    .filter(function () {
      if ($(this).attr('type') == 'hidden') {
        // filter out those with checked checkboxes
        var name = $(this).attr('name');
        return !$('form input[type=checkbox][name="' + name + '"]').prop(
          'checked'
        );
      } else {
        // include all other input
        return true;
      }
    })
    .serializeArray();
  $.each(a, function () {
    if (typeof o[this.name] !== 'undefined') {
      if (!o[this.name].push) {
        o[this.name] = [o[this.name]];
      }
      o[this.name].push(this.value || '');
    } else {
      o[this.name] = this.value || '';
    }
  });
  return o;
};