// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/** @typedef {{eventListeners:!Array<!SDK.EventListener>, internalHandlers:?SDK.RemoteArray}} */
EventListeners.FrameworkEventListenersObject;

/** @typedef {{type: string, useCapture: boolean, passive: boolean, once: boolean, handler: function()}} */
EventListeners.EventListenerObjectInInspectedPage;

/**
 * @param {!SDK.RemoteObject} object
 * @return {!Promise<!EventListeners.FrameworkEventListenersObject>}
 */
EventListeners.frameworkEventListeners = function(object) {
  const domDebuggerModel = object.runtimeModel().target().model(SDK.DOMDebuggerModel);
  if (!domDebuggerModel) {
    // TODO(kozyatinskiy): figure out how this should work for |window|.
    return Promise.resolve(
        /** @type {!EventListeners.FrameworkEventListenersObject} */ ({eventListeners: [], internalHandlers: null}));
  }

  const listenersResult = /** @type {!EventListeners.FrameworkEventListenersObject} */ ({eventListeners: []});
  return object.callFunctionPromise(frameworkEventListeners, undefined)
      .then(assertCallFunctionResult)
      .then(getOwnProperties)
      .then(createEventListeners)
      .then(returnResult)
      .catchException(listenersResult);

  /**
   * @param {!SDK.RemoteObject} object
   * @return {!Promise<!{properties: ?Array.<!SDK.RemoteObjectProperty>, internalProperties: ?Array.<!SDK.RemoteObjectProperty>}>}
   */
  function getOwnProperties(object) {
    return object.getOwnPropertiesPromise(false /* generatePreview */);
  }

  /**
   * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} result
   * @return {!Promise<undefined>}
   */
  function createEventListeners(result) {
    if (!result.properties)
      throw new Error('Object properties is empty');
    const promises = [];
    for (const property of result.properties) {
      if (property.name === 'eventListeners' && property.value)
        promises.push(convertToEventListeners(property.value).then(storeEventListeners));
      if (property.name === 'internalHandlers' && property.value)
        promises.push(convertToInternalHandlers(property.value).then(storeInternalHandlers));
      if (property.name === 'errorString' && property.value)
        printErrorString(property.value);
    }
    return /** @type {!Promise<undefined>} */ (Promise.all(promises));
  }

  /**
   * @param {!SDK.RemoteObject} pageEventListenersObject
   * @return {!Promise<!Array<!SDK.EventListener>>}
   */
  function convertToEventListeners(pageEventListenersObject) {
    return SDK.RemoteArray.objectAsArray(pageEventListenersObject).map(toEventListener).then(filterOutEmptyObjects);

    /**
     * @param {!SDK.RemoteObject} listenerObject
     * @return {!Promise<?SDK.EventListener>}
     */
    function toEventListener(listenerObject) {
      /** @type {string} */
      let type;
      /** @type {boolean} */
      let useCapture;
      /** @type {boolean} */
      let passive;
      /** @type {boolean} */
      let once;
      /** @type {?SDK.RemoteObject} */
      let handler = null;
      /** @type {?SDK.RemoteObject} */
      let originalHandler = null;
      /** @type {?SDK.DebuggerModel.Location} */
      let location = null;
      /** @type {?SDK.RemoteObject} */
      let removeFunctionObject = null;

      const promises = [];
      promises.push(
          listenerObject.callFunctionJSONPromise(truncatePageEventListener, undefined).then(storeTruncatedListener));

      /**
       * @suppressReceiverCheck
       * @this {EventListeners.EventListenerObjectInInspectedPage}
       * @return {!{type:string, useCapture:boolean, passive:boolean, once:boolean}}
       */
      function truncatePageEventListener() {
        return {type: this.type, useCapture: this.useCapture, passive: this.passive, once: this.once};
      }

      /**
       * @param {!{type:string, useCapture: boolean, passive: boolean, once: boolean}} truncatedListener
       */
      function storeTruncatedListener(truncatedListener) {
        type = truncatedListener.type;
        useCapture = truncatedListener.useCapture;
        passive = truncatedListener.passive;
        once = truncatedListener.once;
      }

      promises.push(listenerObject.callFunctionPromise(handlerFunction)
                        .then(assertCallFunctionResult)
                        .then(storeOriginalHandler)
                        .then(toTargetFunction)
                        .then(storeFunctionWithDetails));

      /**
       * @suppressReceiverCheck
       * @return {function()}
       * @this {EventListeners.EventListenerObjectInInspectedPage}
       */
      function handlerFunction() {
        return this.handler;
      }

      /**
       * @param {!SDK.RemoteObject} functionObject
       * @return {!SDK.RemoteObject}
       */
      function storeOriginalHandler(functionObject) {
        originalHandler = functionObject;
        return originalHandler;
      }

      /**
       * @param {!SDK.RemoteObject} functionObject
       * @return {!Promise<undefined>}
       */
      function storeFunctionWithDetails(functionObject) {
        handler = functionObject;
        return /** @type {!Promise<undefined>} */ (
            functionObject.debuggerModel().functionDetailsPromise(functionObject).then(storeFunctionDetails));
      }

      /**
       * @param {?SDK.DebuggerModel.FunctionDetails} functionDetails
       */
      function storeFunctionDetails(functionDetails) {
        location = functionDetails ? functionDetails.location : null;
      }

      promises.push(listenerObject.callFunctionPromise(getRemoveFunction)
                        .then(assertCallFunctionResult)
                        .then(storeRemoveFunction));

      /**
       * @suppressReceiverCheck
       * @return {function()}
       * @this {EventListeners.EventListenerObjectInInspectedPage}
       */
      function getRemoveFunction() {
        return this.remove;
      }

      /**
       * @param {!SDK.RemoteObject} functionObject
       */
      function storeRemoveFunction(functionObject) {
        if (functionObject.type !== 'function')
          return;
        removeFunctionObject = functionObject;
      }

      return Promise.all(promises).then(createEventListener).catchException(/** @type {?SDK.EventListener} */ (null));

      /**
       * @return {!SDK.EventListener}
       */
      function createEventListener() {
        if (!location)
          throw new Error('Empty event listener\'s location');
        return new SDK.EventListener(
            /** @type {!SDK.DOMDebuggerModel} */ (domDebuggerModel), object, type, useCapture, passive, once, handler,
            originalHandler, location, removeFunctionObject, SDK.EventListener.Origin.FrameworkUser);
      }
    }
  }

  /**
   * @param {!SDK.RemoteObject} pageInternalHandlersObject
   * @return {!Promise<!SDK.RemoteArray>}
   */
  function convertToInternalHandlers(pageInternalHandlersObject) {
    return SDK.RemoteArray.objectAsArray(pageInternalHandlersObject)
        .map(toTargetFunction)
        .then(SDK.RemoteArray.createFromRemoteObjects);
  }

  /**
   * @param {!SDK.RemoteObject} functionObject
   * @return {!Promise<!SDK.RemoteObject>}
   */
  function toTargetFunction(functionObject) {
    return SDK.RemoteFunction.objectAsFunction(functionObject).targetFunction();
  }

  /**
   * @param {!Array<!SDK.EventListener>} eventListeners
   */
  function storeEventListeners(eventListeners) {
    listenersResult.eventListeners = eventListeners;
  }

  /**
   * @param {!SDK.RemoteArray} internalHandlers
   */
  function storeInternalHandlers(internalHandlers) {
    listenersResult.internalHandlers = internalHandlers;
  }

  /**
   * @param {!SDK.RemoteObject} errorString
   */
  function printErrorString(errorString) {
    Common.console.error(String(errorString.value));
  }

  /**
   * @return {!EventListeners.FrameworkEventListenersObject}
   */
  function returnResult() {
    return listenersResult;
  }

  /**
   * @param {!SDK.CallFunctionResult} result
   * @return {!SDK.RemoteObject}
   */
  function assertCallFunctionResult(result) {
    if (result.wasThrown || !result.object)
      throw new Error('Exception in callFunction or empty result');
    return result.object;
  }

  /**
   * @param {!Array<?T>} objects
   * @return {!Array<!T>}
   * @template T
   */
  function filterOutEmptyObjects(objects) {
    return objects.filter(filterOutEmpty);

    /**
     * @param {?T} object
     * @return {boolean}
     * @template T
     */
    function filterOutEmpty(object) {
      return !!object;
    }
  }

  /*
    frameworkEventListeners fetcher functions should produce following output:
        {
          // framework event listeners
          "eventListeners": [
            {
              "handler": function(),
              "useCapture": true,
              "passive": false,
              "once": false,
              "type": "change",
              "remove": function(type, handler, useCapture, passive)
            },
            ...
          ],
          // internal framework event handlers
          "internalHandlers": [
            function(),
            function(),
            ...
          ]
        }
    */
  /**
   * @suppressReceiverCheck
   * @return {!{eventListeners:!Array<!EventListeners.EventListenerObjectInInspectedPage>, internalHandlers:?Array<function()>}}
   * @this {Object}
   */
  function frameworkEventListeners() {
    const errorLines = [];
    let eventListeners = [];
    let internalHandlers = [];
    let fetchers = [jQueryFetcher];
    try {
      if (self.devtoolsFrameworkEventListeners && isArrayLike(self.devtoolsFrameworkEventListeners))
        fetchers = fetchers.concat(self.devtoolsFrameworkEventListeners);
    } catch (e) {
      errorLines.push('devtoolsFrameworkEventListeners call produced error: ' + toString(e));
    }

    for (let i = 0; i < fetchers.length; ++i) {
      try {
        const fetcherResult = fetchers[i](this);
        if (fetcherResult.eventListeners && isArrayLike(fetcherResult.eventListeners)) {
          eventListeners =
              eventListeners.concat(fetcherResult.eventListeners.map(checkEventListener).filter(nonEmptyObject));
        }
        if (fetcherResult.internalHandlers && isArrayLike(fetcherResult.internalHandlers)) {
          internalHandlers =
              internalHandlers.concat(fetcherResult.internalHandlers.map(checkInternalHandler).filter(nonEmptyObject));
        }
      } catch (e) {
        errorLines.push('fetcher call produced error: ' + toString(e));
      }
    }
    const result = {eventListeners: eventListeners};
    if (internalHandlers.length)
      result.internalHandlers = internalHandlers;
    if (errorLines.length) {
      let errorString = 'Framework Event Listeners API Errors:\n\t' + errorLines.join('\n\t');
      errorString = errorString.substr(0, errorString.length - 1);
      result.errorString = errorString;
    }
    return result;

    /**
     * @param {?Object} obj
     * @return {boolean}
     */
    function isArrayLike(obj) {
      if (!obj || typeof obj !== 'object')
        return false;
      try {
        if (typeof obj.splice === 'function') {
          const len = obj.length;
          return typeof len === 'number' && (len >>> 0 === len && (len > 0 || 1 / len > 0));
        }
      } catch (e) {
      }
      return false;
    }

    /**
     * @param {*} eventListener
     * @return {?EventListeners.EventListenerObjectInInspectedPage}
     */
    function checkEventListener(eventListener) {
      try {
        let errorString = '';
        if (!eventListener)
          errorString += 'empty event listener, ';
        const type = eventListener.type;
        if (!type || (typeof type !== 'string'))
          errorString += 'event listener\'s type isn\'t string or empty, ';
        const useCapture = eventListener.useCapture;
        if (typeof useCapture !== 'boolean')
          errorString += 'event listener\'s useCapture isn\'t boolean or undefined, ';
        const passive = eventListener.passive;
        if (typeof passive !== 'boolean')
          errorString += 'event listener\'s passive isn\'t boolean or undefined, ';
        const once = eventListener.once;
        if (typeof once !== 'boolean')
          errorString += 'event listener\'s once isn\'t boolean or undefined, ';
        const handler = eventListener.handler;
        if (!handler || (typeof handler !== 'function'))
          errorString += 'event listener\'s handler isn\'t a function or empty, ';
        const remove = eventListener.remove;
        if (remove && (typeof remove !== 'function'))
          errorString += 'event listener\'s remove isn\'t a function, ';
        if (!errorString) {
          return {type: type, useCapture: useCapture, passive: passive, once: once, handler: handler, remove: remove};
        } else {
          errorLines.push(errorString.substr(0, errorString.length - 2));
          return null;
        }
      } catch (e) {
        errorLines.push(toString(e));
        return null;
      }
    }

    /**
     * @param {*} handler
     * @return {function()|null}
     */
    function checkInternalHandler(handler) {
      if (handler && (typeof handler === 'function'))
        return handler;
      errorLines.push('internal handler isn\'t a function or empty');
      return null;
    }

    /**
     * @param {*} obj
     * @return {string}
     * @suppress {uselessCode}
     */
    function toString(obj) {
      try {
        return '' + obj;
      } catch (e) {
        return '<error>';
      }
    }

    /**
     * @param {*} obj
     * @return {boolean}
     */
    function nonEmptyObject(obj) {
      return !!obj;
    }

    function jQueryFetcher(node) {
      if (!node || !(node instanceof Node))
        return {eventListeners: []};
      const jQuery = /** @type {?{fn,data,_data}}*/ (window['jQuery']);
      if (!jQuery || !jQuery.fn)
        return {eventListeners: []};
      const jQueryFunction = /** @type {function(!Node)} */ (jQuery);
      const data = jQuery._data || jQuery.data;

      const eventListeners = [];
      const internalHandlers = [];

      if (typeof data === 'function') {
        const events = data(node, 'events');
        for (const type in events) {
          for (const key in events[type]) {
            const frameworkListener = events[type][key];
            if (typeof frameworkListener === 'object' || typeof frameworkListener === 'function') {
              const listener = {
                handler: frameworkListener.handler || frameworkListener,
                useCapture: true,
                passive: false,
                once: false,
                type: type
              };
              listener.remove = jQueryRemove.bind(node, frameworkListener.selector);
              eventListeners.push(listener);
            }
          }
        }
        const nodeData = data(node);
        if (nodeData && typeof nodeData.handle === 'function')
          internalHandlers.push(nodeData.handle);
      }
      const entry = jQueryFunction(node)[0];
      if (entry) {
        const entryEvents = entry['$events'];
        for (const type in entryEvents) {
          const events = entryEvents[type];
          for (const key in events) {
            if (typeof events[key] === 'function') {
              const listener = {handler: events[key], useCapture: true, passive: false, once: false, type: type};
              // We don't support removing for old version < 1.4 of jQuery because it doesn't provide API for getting "selector".
              eventListeners.push(listener);
            }
          }
        }
        if (entry && entry['$handle'])
          internalHandlers.push(entry['$handle']);
      }
      return {eventListeners: eventListeners, internalHandlers: internalHandlers};
    }

    /**
     * @param {string} selector
     * @param {string} type
     * @param {function()} handler
     * @this {?Object}
     */
    function jQueryRemove(selector, type, handler) {
      if (!this || !(this instanceof Node))
        return;
      const node = /** @type {!Node} */ (this);
      const jQuery = /** @type {?{fn,data,_data}}*/ (window['jQuery']);
      if (!jQuery || !jQuery.fn)
        return;
      const jQueryFunction = /** @type {function(!Node)} */ (jQuery);
      jQueryFunction(node).off(type, selector, handler);
    }
  }
};