/**
 * The reveal.js markdown plugin. Handles parsing of
 * markdown inside of presentations as well as loading
 * of external markdown documents.
 */
(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    root.marked = require('./marked');
    root.RevealMarkdown = factory(root.marked);
    root.RevealMarkdown.initialize();
  } else if (typeof exports === 'object') {
    module.exports = factory(require('./marked'));
  } else {
    // Browser globals (root is window)
    root.RevealMarkdown = factory(root.marked);
    root.RevealMarkdown.initialize();
  }
}(this, function (marked) {

  var DEFAULT_SLIDE_SEPARATOR = '^\r?\n---\r?\n$',
    DEFAULT_NOTES_SEPARATOR = 'notes?:',
    DEFAULT_ELEMENT_ATTRIBUTES_SEPARATOR = '\\\.element\\\s*?(.+?)$',
    DEFAULT_SLIDE_ATTRIBUTES_SEPARATOR = '\\\.slide:\\\s*?(\\\S.+?)$';

  var SCRIPT_END_PLACEHOLDER = '__SCRIPT_END__';


  /**
   * Retrieves the markdown contents of a slide section
   * element. Normalizes leading tabs/whitespace.
   */
  function getMarkdownFromSlide(section) {

    // look for a <script> or <textarea data-template> wrapper
    var template = section.querySelector('[data-template]') || section.querySelector('script');

    // strip leading whitespace so it isn't evaluated as code
    var text = (template || section).textContent;

    // restore script end tags
    text = text.replace(new RegExp(SCRIPT_END_PLACEHOLDER, 'g'), '</script>');

    var leadingWs = text.match(/^\n?(\s*)/)[1].length,
      leadingTabs = text.match(/^\n?(\t*)/)[1].length;

    if (leadingTabs > 0) {
      text = text.replace(new RegExp('\\n?\\t{' + leadingTabs + '}', 'g'), '\n');
    } else if (leadingWs > 1) {
      text = text.replace(new RegExp('\\n? {' + leadingWs + '}', 'g'), '\n');
    }

    return text;

  }

  /**
   * Given a markdown slide section element, this will
   * return all arguments that aren't related to markdown
   * parsing. Used to forward any other user-defined arguments
   * to the output markdown slide.
   */
  function getForwardedAttributes(section) {

    var attributes = section.attributes;
    var result = [];

    for (var i = 0, len = attributes.length; i < len; i++) {
      var name = attributes[i].name,
        value = attributes[i].value;

      // disregard attributes that are used for markdown loading/parsing
      if (/data\-(markdown|separator|vertical|notes)/gi.test(name)) continue;

      if (value) {
        result.push(name + '="' + value + '"');
      } else {
        result.push(name);
      }
    }

    return result.join(' ');

  }

  /**
   * Inspects the given options and fills out default
   * values for what's not defined.
   */
  function getSlidifyOptions(options) {

    options = options || {};
    options.separator = options.separator || DEFAULT_SLIDE_SEPARATOR;
    options.notesSeparator = options.notesSeparator || DEFAULT_NOTES_SEPARATOR;
    options.attributes = options.attributes || '';

    return options;

  }

  /**
   * Helper function for constructing a markdown slide.
   */
  function createMarkdownSlide(content, options) {

    options = getSlidifyOptions(options);

    var notesMatch = content.split(new RegExp(options.notesSeparator, 'mgi'));

    if (notesMatch.length === 2) {
      content = notesMatch[0] + '<aside class="notes">' + marked(notesMatch[1].trim()) + '</aside>';
    }

    // prevent script end tags in the content from interfering
    // with parsing
    content = content.replace(/<\/script>/g, SCRIPT_END_PLACEHOLDER);

    return '<script type="text/template">' + content + '</script>';

  }

  /**
   * Parses a data string into multiple slides based
   * on the passed in separator arguments.
   */
  function slidify(markdown, options) {

    options = getSlidifyOptions(options);

    var separatorRegex = new RegExp(options.separator + (options.verticalSeparator ? '|' + options.verticalSeparator : ''), 'mg'),
      horizontalSeparatorRegex = new RegExp(options.separator);

    var matches,
      lastIndex = 0,
      isHorizontal,
      wasHorizontal = true,
      content,
      sectionStack = [];

    // iterate until all blocks between separators are stacked up
    while (matches = separatorRegex.exec(markdown)) {
      notes = null;

      // determine direction (horizontal by default)
      isHorizontal = horizontalSeparatorRegex.test(matches[0]);

      if (!isHorizontal && wasHorizontal) {
        // create vertical stack
        sectionStack.push([]);
      }

      // pluck slide content from markdown input
      content = markdown.substring(lastIndex, matches.index);

      if (isHorizontal && wasHorizontal) {
        // add to horizontal stack
        sectionStack.push(content);
      } else {
        // add to vertical stack
        sectionStack[sectionStack.length - 1].push(content);
      }

      lastIndex = separatorRegex.lastIndex;
      wasHorizontal = isHorizontal;
    }

    // add the remaining slide
    (wasHorizontal ? sectionStack : sectionStack[sectionStack.length - 1]).push(markdown.substring(lastIndex));

    var markdownSections = '';

    // flatten the hierarchical stack, and insert <section data-markdown> tags
    for (var i = 0, len = sectionStack.length; i < len; i++) {
      // vertical
      if (sectionStack[i] instanceof Array) {
        markdownSections += '<section ' + options.attributes + '>';

        sectionStack[i].forEach(function (child) {
          markdownSections += '<section data-markdown>' + createMarkdownSlide(child, options) + '</section>';
        });

        markdownSections += '</section>';
      } else {
        markdownSections += '<section ' + options.attributes + ' data-markdown>' + createMarkdownSlide(sectionStack[i], options) + '</section>';
      }
    }

    return markdownSections;

  }

  /**
   * Parses any current data-markdown slides, splits
   * multi-slide markdown into separate sections and
   * handles loading of external markdown.
   */
  function processSlides() {

    var sections = document.querySelectorAll('[data-markdown]'),
      section;

    for (var i = 0, len = sections.length; i < len; i++) {

      section = sections[i];

      if (section.getAttribute('data-markdown').length) {

        var xhr = new XMLHttpRequest(),
          url = section.getAttribute('data-markdown');

        datacharset = section.getAttribute('data-charset');

        // see https://developer.mozilla.org/en-US/docs/Web/API/element.getAttribute#Notes
        if (datacharset != null && datacharset != '') {
          xhr.overrideMimeType('text/html; charset=' + datacharset);
        }

        xhr.onreadystatechange = function () {
          if (xhr.readyState === 4) {
            // file protocol yields status code 0 (useful for local debug, mobile applications etc.)
            if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 0) {

              section.outerHTML = slidify(xhr.responseText, {
                separator: section.getAttribute('data-separator'),
                verticalSeparator: section.getAttribute('data-separator-vertical'),
                notesSeparator: section.getAttribute('data-separator-notes'),
                attributes: getForwardedAttributes(section)
              });

            } else {

              section.outerHTML = '<section data-state="alert">' +
                'ERROR: The attempt to fetch ' + url + ' failed with HTTP status ' + xhr.status + '.' +
                'Check your browser\'s JavaScript console for more details.' +
                '<p>Remember that you need to serve the presentation HTML from a HTTP server.</p>' +
                '</section>';

            }
          }
        };

        xhr.open('GET', url, false);

        try {
          xhr.send();
        } catch (e) {
          alert('Failed to get the Markdown file ' + url + '. Make sure that the presentation and the file are served by a HTTP server and the file can be found there. ' + e);
        }

      } else if (section.getAttribute('data-separator') || section.getAttribute('data-separator-vertical') || section.getAttribute('data-separator-notes')) {

        section.outerHTML = slidify(getMarkdownFromSlide(section), {
          separator: section.getAttribute('data-separator'),
          verticalSeparator: section.getAttribute('data-separator-vertical'),
          notesSeparator: section.getAttribute('data-separator-notes'),
          attributes: getForwardedAttributes(section)
        });

      } else {
        section.innerHTML = createMarkdownSlide(getMarkdownFromSlide(section));
      }
    }

  }

  /**
   * Check if a node value has the attributes pattern.
   * If yes, extract it and add that value as one or several attributes
   * the the terget element.
   *
   * You need Cache Killer on Chrome to see the effect on any FOM transformation
   * directly on refresh (F5)
   * http://stackoverflow.com/questions/5690269/disabling-chrome-cache-for-website-development/7000899#answer-11786277
   */
  function addAttributeInElement(node, elementTarget, separator) {

    var mardownClassesInElementsRegex = new RegExp(separator, 'mg');
    var mardownClassRegex = new RegExp("([^\"= ]+?)=\"([^\"=]+?)\"", 'mg');
    var nodeValue = node.nodeValue;
    if (matches = mardownClassesInElementsRegex.exec(nodeValue)) {

      var classes = matches[1];
      nodeValue = nodeValue.substring(0, matches.index) + nodeValue.substring(mardownClassesInElementsRegex.lastIndex);
      node.nodeValue = nodeValue;
      while (matchesClass = mardownClassRegex.exec(classes)) {
        elementTarget.setAttribute(matchesClass[1], matchesClass[2]);
      }
      return true;
    }
    return false;
  }

  /**
   * Add attributes to the parent element of a text node,
   * or the element of an attribute node.
   */
  function addAttributes(section, element, previousElement, separatorElementAttributes, separatorSectionAttributes) {

    if (element != null && element.childNodes != undefined && element.childNodes.length > 0) {
      previousParentElement = element;
      for (var i = 0; i < element.childNodes.length; i++) {
        childElement = element.childNodes[i];
        if (i > 0) {
          j = i - 1;
          while (j >= 0) {
            aPreviousChildElement = element.childNodes[j];
            if (typeof aPreviousChildElement.setAttribute == 'function' && aPreviousChildElement.tagName != "BR") {
              previousParentElement = aPreviousChildElement;
              break;
            }
            j = j - 1;
          }
        }
        parentSection = section;
        if (childElement.nodeName == "section") {
          parentSection = childElement;
          previousParentElement = childElement;
        }
        if (typeof childElement.setAttribute == 'function' || childElement.nodeType == Node.COMMENT_NODE) {
          addAttributes(parentSection, childElement, previousParentElement, separatorElementAttributes, separatorSectionAttributes);
        }
      }
    }

    if (element.nodeType == Node.COMMENT_NODE) {
      if (addAttributeInElement(element, previousElement, separatorElementAttributes) == false) {
        addAttributeInElement(element, section, separatorSectionAttributes);
      }
    }
  }

  /**
   * Converts any current data-markdown slides in the
   * DOM to HTML.
   */
  function convertSlides() {

    var sections = document.querySelectorAll('[data-markdown]');

    for (var i = 0, len = sections.length; i < len; i++) {

      var section = sections[i];

      // Only parse the same slide once
      if (!section.getAttribute('data-markdown-parsed')) {

        section.setAttribute('data-markdown-parsed', true);

        var notes = section.querySelector('aside.notes');
        var markdown = getMarkdownFromSlide(section);

        section.innerHTML = marked(markdown);
        addAttributes(section, section, null, section.getAttribute('data-element-attributes') ||
          section.parentNode.getAttribute('data-element-attributes') ||
          DEFAULT_ELEMENT_ATTRIBUTES_SEPARATOR,
          section.getAttribute('data-attributes') ||
          section.parentNode.getAttribute('data-attributes') ||
          DEFAULT_SLIDE_ATTRIBUTES_SEPARATOR);

        // If there were notes, we need to re-add them after
        // having overwritten the section's HTML
        if (notes) {
          section.appendChild(notes);
        }

      }

    }

  }

  // API
  return {

    initialize: function () {
      if (typeof marked === 'undefined') {
        throw 'The reveal.js Markdown plugin requires marked to be loaded';
      }

      if (typeof hljs !== 'undefined') {
        marked.setOptions({
          highlight: function (code, lang) {
            return hljs.highlightAuto(code, [lang]).value;
          }
        });
      }

      var options = Reveal.getConfig().markdown;

      if (options) {
        marked.setOptions(options);
      }

      processSlides();
      convertSlides();
    },

    // TODO: Do these belong in the API?
    processSlides: processSlides,
    convertSlides: convertSlides,
    slidify: slidify

  };

}));