import { SERVICES } from '../constants.js';

/**
 * @constant DEFAULT_SERVICES
 * @private
 */

const DEFAULT_SERVICES = {
  [SERVICES.AMPLITUDE]: true,
  [SERVICES.DOODLE_DATA_LAYER]: false,
  [SERVICES.GA]: true
};
/**
 * Helper function to parse data tracking attributes into a trackingIntent
 *
 * @param {HTMLElement} el - An HTML element to inspect
 * @return {Object}
 */

const getTrackingIntentFromDOM = el => {
  const {
    dataset: {
      trackingOptions,
      track,
      identify,
      page
    }
  } = el;
  const trackingIntent = { ...(trackingOptions && {
      options: JSON.parse(trackingOptions)
    }),
    ...(track && {
      track: JSON.parse(track)
    }),
    ...(page && {
      page: JSON.parse(page)
    }),
    ...(identify && {
      identify: JSON.parse(identify)
    })
  };
  return trackingIntent;
};
/**
 * Helper function that returns an object that knows about the link behavior
 * and return them mapped to a trackingElBehavior object
 *
 * @param {HTMLElement} el - An HTML element to inspect
 * @return {{href: string, isSameTabLink: boolean}} - A representation of the element's click behavior
 */


const getTrackingElBehavior = el => {
  const href = el.getAttribute('href');
  const target = el.getAttribute('target');
  const trackingElBehavior = {
    href,
    isSameTabLink: Boolean(href ? target !== '_blank' : true)
  };
  return trackingElBehavior;
};
/**
 * Function to enhance a trackingIntent with defaults (e.g. destination services) and link behavior information
 *
 * It may be called either with a trackingIntent or with a trackingEl which carries tracking data attributes
 * In case both are passed trackingIntent is preferred
 *
 * Returns an empty object for absent input otherwise a trackingDefinition
 *
 * @param {Object} payload - A storage from where to extract the tracking definition
 * @param {TrackingIntent} [payload.trackingIntent] - The tracking intent passed to the API client
 * @param {HTMLElement} [payload.trackingEl] - An HTML element with tracking data attributes
 * @param {TrackingApiOptions} [options] - The API client's options
 * @return {?TrackingDefinition} - The tracking definition needed by handlers to dispatch calls
 */


const getTrackingDefinition = ({
  trackingIntent = {},
  trackingEl = null
} = {}, options = {}) => {
  const hasTrackingData = Object.keys(trackingIntent).length > 0;
  const {
    services: defaultServices = DEFAULT_SERVICES,
    env: {
      doodleEnv,
      nodeEnv,
      svcDataLayerApi
    } = {}
  } = options;

  if (hasTrackingData) {
    const {
      options: intentTrackingOptions = {},
      ...intentTrackingData
    } = trackingIntent;
    const services = { ...defaultServices,
      ...intentTrackingOptions.services
    };
    const trackingDefinition = {
      trackingData: intentTrackingData,
      trackingOptions: {
        services,
        env: { ...(doodleEnv && {
            doodleEnv
          }),
          ...(nodeEnv && {
            nodeEnv
          }),
          ...(svcDataLayerApi && {
            svcDataLayerApi
          })
        },
        ...intentTrackingOptions,
        ...(trackingEl && getTrackingElBehavior(trackingEl))
      }
    };
    return trackingDefinition;
  }

  if (trackingEl) {
    const trackingIntentFromDataset = getTrackingIntentFromDOM(trackingEl);
    const {
      options: intentTrackingOptions = {},
      ...intentTrackingData
    } = trackingIntentFromDataset;
    const services = { ...defaultServices,
      ...intentTrackingOptions.services
    }; // eslint-disable-next-line no-unused-vars

    const {
      services: _,
      ...intentOptionsWithoutServices
    } = intentTrackingOptions;
    const trackingDefinition = {
      trackingData: intentTrackingData,
      trackingOptions: {
        services: { ...intentTrackingOptions.services,
          ...services
        },
        ...intentOptionsWithoutServices,
        ...getTrackingElBehavior(trackingEl)
      }
    };
    return trackingDefinition;
  }

  return null;
};

export { getTrackingDefinition, getTrackingElBehavior, getTrackingIntentFromDOM };
//# sourceMappingURL=getTrackingDefinition.js.map