/**
 * @license
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {BaseUrlBehavior} from '../../../behaviors/base-url-behavior/base-url-behavior.js';

/**
 * Pattern describing URLs with supported protocols.
 *
 * @type {RegExp}
 */
const URL_PROTOCOL_PATTERN = /^(.*)(https?:\/\/|mailto:)/;

/**
 * Construct a parser for linkifying text. Will linkify plain URLs that appear
 * in the text as well as custom links if any are specified in the linkConfig
 * parameter.
 *
 * @constructor
 * @param {Object|null|undefined} linkConfig Comment links as specified by the
 *     commentlinks field on a project config.
 * @param {Function} callback The callback to be fired when an intermediate
 *     parse result is emitted. The callback is passed text and href strings
 *     if a link is to be created, or a document fragment otherwise.
 * @param {boolean|undefined} opt_removeZeroWidthSpace If true, zero-width
 *     spaces will be removed from R=<email> and CC=<email> expressions.
 */
export function GrLinkTextParser(linkConfig, callback,
    opt_removeZeroWidthSpace) {
  this.linkConfig = linkConfig;
  this.callback = callback;
  this.removeZeroWidthSpace = opt_removeZeroWidthSpace;
  this.baseUrl = BaseUrlBehavior.getBaseUrl();
  Object.preventExtensions(this);
}

/**
 * Emit a callback to create a link element.
 *
 * @param {string} text The text of the link.
 * @param {string} href The URL to use as the href of the link.
 */
GrLinkTextParser.prototype.addText = function(text, href) {
  if (!text) { return; }
  this.callback(text, href);
};

/**
 * Given the source text and a list of CommentLinkItem objects that were
 * generated by the commentlinks config, emit parsing callbacks.
 *
 * @param {string} text The chuml of source text over which the outputArray
 *     items range.
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray The list of items to add
 *     resulting from commentlink matches.
 */
GrLinkTextParser.prototype.processLinks = function(text, outputArray) {
  this.sortArrayReverse(outputArray);
  const fragment = document.createDocumentFragment();
  let cursor = text.length;

  // Start inserting linkified URLs from the end of the String. That way, the
  // string positions of the items don't change as we iterate through.
  outputArray.forEach(item => {
    // Add any text between the current linkified item and the item added
    // before if it exists.
    if (item.position + item.length !== cursor) {
      fragment.insertBefore(
          document.createTextNode(
              text.slice(item.position + item.length, cursor)),
          fragment.firstChild);
    }
    fragment.insertBefore(item.html, fragment.firstChild);
    cursor = item.position;
  });

  // Add the beginning portion at the end.
  if (cursor !== 0) {
    fragment.insertBefore(
        document.createTextNode(text.slice(0, cursor)), fragment.firstChild);
  }

  this.callback(null, null, fragment);
};

/**
 * Sort the given array of CommentLinkItems such that the positions are in
 * reverse order.
 *
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray
 */
GrLinkTextParser.prototype.sortArrayReverse = function(outputArray) {
  outputArray.sort((a, b) => b.position - a.position);
};

/**
 * Create a CommentLinkItem and append it to the given output array. This
 * method can be called in either of two ways:
 * - With `text` and `href` parameters provided, and the `html` parameter
 *   passed as `null`. In this case, the new CommentLinkItem will be a link
 *   element with the given text and href value.
 * - With the `html` paremeter provided, and the `text` and `href` parameters
 *   passed as `null`. In this case, the string of HTML will be parsed and the
 *   first resulting node will be used as the resulting content.
 *
 * @param {string|null} text The text to use if creating a link.
 * @param {string|null} href The href to use as the URL if creating a link.
 * @param {string|null} html The html to parse and use as the result.
 * @param {number} position The position inside the source text where the item
 *     starts.
 * @param {number} length The number of characters in the source text
 *     represented by the item.
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray The array to which the
 *     new item is to be appended.
 */
GrLinkTextParser.prototype.addItem =
    function(text, href, html, position, length, outputArray) {
      let htmlOutput = '';

      if (href) {
        const a = document.createElement('a');
        a.href = href;
        a.textContent = text;
        a.target = '_blank';
        a.rel = 'noopener';
        htmlOutput = a;
      } else if (html) {
        const fragment = document.createDocumentFragment();
        // Create temporary div to hold the nodes in.
        const div = document.createElement('div');
        div.innerHTML = html;
        while (div.firstChild) {
          fragment.appendChild(div.firstChild);
        }
        htmlOutput = fragment;
      }

      outputArray.push({
        html: htmlOutput,
        position,
        length,
      });
    };

/**
 * Create a CommentLinkItem for a link and append it to the given output
 * array.
 *
 * @param {string|null} text The text for the link.
 * @param {string|null} href The href to use as the URL of the link.
 * @param {number} position The position inside the source text where the link
 *     starts.
 * @param {number} length The number of characters in the source text
 *     represented by the link.
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray The array to which the
 *     new item is to be appended.
 */
GrLinkTextParser.prototype.addLink =
    function(text, href, position, length, outputArray) {
      if (!text || this.hasOverlap(position, length, outputArray)) { return; }
      if (!!this.baseUrl && href.startsWith('/') &&
           !href.startsWith(this.baseUrl)) {
        href = this.baseUrl + href;
      }
      this.addItem(text, href, null, position, length, outputArray);
    };

/**
 * Create a CommentLinkItem specified by an HTMl string and append it to the
 * given output array.
 *
 * @param {string|null} html The html to parse and use as the result.
 * @param {number} position The position inside the source text where the item
 *     starts.
 * @param {number} length The number of characters in the source text
 *     represented by the item.
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray The array to which the
 *     new item is to be appended.
 */
GrLinkTextParser.prototype.addHTML =
    function(html, position, length, outputArray) {
      if (this.hasOverlap(position, length, outputArray)) { return; }
      if (!!this.baseUrl && html.match(/<a href=\"\//g) &&
           !new RegExp(`<a href="${this.baseUrl}`, 'g').test(html)) {
        html = html.replace(/<a href=\"\//g, `<a href=\"${this.baseUrl}\/`);
      }
      this.addItem(null, null, html, position, length, outputArray);
    };

/**
 * Does the given range overlap with anything already in the item list.
 *
 * @param {number} position
 * @param {number} length
 * @param {!Array<Gerrit.CommentLinkItem>} outputArray
 */
GrLinkTextParser.prototype.hasOverlap =
    function(position, length, outputArray) {
      const endPosition = position + length;
      for (let i = 0; i < outputArray.length; i++) {
        const arrayItemStart = outputArray[i].position;
        const arrayItemEnd = outputArray[i].position + outputArray[i].length;
        if ((position >= arrayItemStart && position < arrayItemEnd) ||
      (endPosition > arrayItemStart && endPosition <= arrayItemEnd) ||
      (position === arrayItemStart && position === arrayItemEnd)) {
          return true;
        }
      }
      return false;
    };

/**
 * Parse the given source text and emit callbacks for the items that are
 * parsed.
 *
 * @param {string} text
 */
GrLinkTextParser.prototype.parse = function(text) {
  if (text) {
    linkify(text, {
      callback: this.parseChunk.bind(this),
    });
  }
};

/**
 * Callback that is pased into the linkify function. ba-linkify will call this
 * method in either of two ways:
 * - With both a `text` and `href` parameter provided: this indicates that
 *   ba-linkify has found a plain URL and wants it linkified.
 * - With only a `text` parameter provided: this represents the non-link
 *   content that lies between the links the library has found.
 *
 * @param {string} text
 * @param {string|null|undefined} href
 */
GrLinkTextParser.prototype.parseChunk = function(text, href) {
  // TODO(wyatta) switch linkify sequence, see issue 5526.
  if (this.removeZeroWidthSpace) {
    // Remove the zero-width space added in gr-change-view.
    text = text.replace(/^(CC|R)=\u200B/gm, '$1=');
  }

  // If the href is provided then ba-linkify has recognized it as a URL. If
  // the source text does not include a protocol, the protocol will be added
  // by ba-linkify. Create the link if the href is provided and its protocol
  // matches the expected pattern.
  if (href) {
    const result = URL_PROTOCOL_PATTERN.exec(href);
    if (result) {
      const prefixText = result[1];
      if (prefixText.length > 0) {
        // Fix for simple cases from
        // https://bugs.chromium.org/p/gerrit/issues/detail?id=11697
        // When leading whitespace is missed before link,
        // linkify add this text before link as a schema name to href.
        // We suppose, that prefixText just a single word
        // before link and add this word as is, without processing
        // any patterns in it.
        this.parseLinks(prefixText, []);
        text = text.substring(prefixText.length);
        href = href.substring(prefixText.length);
      }
      this.addText(text, href);
      return;
    }
  }
  // For the sections of text that lie between the links found by
  // ba-linkify, we search for the project-config-specified link patterns.
  this.parseLinks(text, this.linkConfig);
};

/**
 * Walk over the given source text to find matches for comemntlink patterns
 * and emit parse result callbacks.
 *
 * @param {string} text The raw source text.
 * @param {Object|null|undefined} patterns A comment links specification
 *   object.
 */
GrLinkTextParser.prototype.parseLinks = function(text, patterns) {
  // The outputArray is used to store all of the matches found for all
  // patterns.
  const outputArray = [];
  for (const p in patterns) {
    if (patterns[p].enabled != null && patterns[p].enabled == false) {
      continue;
    }
    // PolyGerrit doesn't use hash-based navigation like the GWT UI.
    // Account for this.
    if (patterns[p].html) {
      patterns[p].html =
          patterns[p].html.replace(/<a href=\"#\//g, '<a href="/');
    } else if (patterns[p].link) {
      if (patterns[p].link[0] == '#') {
        patterns[p].link = patterns[p].link.substr(1);
      }
    }

    const pattern = new RegExp(patterns[p].match, 'g');

    let match;
    let textToCheck = text;
    let susbtrIndex = 0;

    while ((match = pattern.exec(textToCheck)) != null) {
      textToCheck = textToCheck.substr(match.index + match[0].length);
      let result = match[0].replace(pattern,
          patterns[p].html || patterns[p].link);

      if (patterns[p].html) {
        let i;
        // Skip portion of replacement string that is equal to original to
        // allow overlapping patterns.
        for (i = 0; i < result.length; i++) {
          if (result[i] !== match[0][i]) { break; }
        }
        result = result.slice(i);

        this.addHTML(
            result,
            susbtrIndex + match.index + i,
            match[0].length - i,
            outputArray);
      } else if (patterns[p].link) {
        this.addLink(
            match[0],
            result,
            susbtrIndex + match.index,
            match[0].length,
            outputArray);
      } else {
        throw Error('linkconfig entry ' + p +
            ' doesn’t contain a link or html attribute.');
      }

      // Update the substring location so we know where we are in relation to
      // the initial full text string.
      susbtrIndex = susbtrIndex + match.index + match[0].length;
    }
  }
  this.processLinks(text, outputArray);
};