export interface AutoTrackConfig {
  bindEvent?: boolean;
  pageTitleProp?: string;
  pages?: AutoTrackPage[];
  elements?: AutoTrackElement[];
  ignorePages?: string[];
  ignoreElements?: string[];
  ignoreElementProp?: string;
  elementIdProp?: string;
  elementCustomProp?: string;
  reactNavigation?: AutoTrackReactNavigation;
}

export interface AutoTrackPage {
  appKey: string;
  pageID?: string;
  pagePath?: string;
  ignore?: boolean;
}

export interface AutoTrackElement {
  elementName: string;
  elementID?: string;
  ignore?: boolean;
}

export interface AutoTrackReactNavigation {
  screens: AutoTrackReactNavigationScreen[];
  combineApp?: boolean;
  disableApp?: boolean;
  beforeRemove?: (route: any, eventData: any) => void;
}

export interface AutoTrackReactNavigationScreen {
  screenName: string;
  pageID?: string;
  pagePath?: string;
  ignore?: boolean;
}

const listeners: Function[] = [];
let _config: AutoTrackConfig = {
  bindEvent: false,
  pageTitleProp: 'rangers-app-log-title',
  ignoreElementProp: 'rangers-app-log-ignore',
  elementIdProp: 'rangers-app-log-id',
  elementCustomProp: 'rangers-app-log-custom',
};

let _pageConfigMap = new Map<string, AutoTrackPage>();
let _ignorePageSet = new Set<string>();

let _elementConfigMap = new Map<String, AutoTrackElement>();
let _ignoreElementSet = new Set<string>();

export default {
  getConfig: () => _config,

  getPageTitleProp: () => _config.pageTitleProp,

  getPageConfig(appKey: string): AutoTrackPage | undefined {
    if (!_pageConfigMap.has(appKey)) {
      return undefined;
    }

    return _pageConfigMap.get(appKey);
  },

  getElementConfig(elementName: string): AutoTrackElement | undefined {
    if (!_elementConfigMap.has(elementName)) {
      return undefined;
    }

    return _elementConfigMap.get(elementName);
  },

  getIgnorePageSet(): Set<string> {
    return _ignorePageSet;
  },

  getIgnoreElementSet(): Set<string> {
    return _ignoreElementSet;
  },

  updateConfig(config: AutoTrackConfig) {
    _config = Object.assign(_config, config);
    _pageConfigMap = new Map<string, AutoTrackPage>();
    _elementConfigMap = new Map<string, AutoTrackElement>();

    const ignorePages = _config.ignorePages || [];
    const ignoreElements = _config.ignoreElements || [];
    if (_config.pages) {
      _config.pages.forEach((pageConfig) => {
        _pageConfigMap.set(pageConfig.appKey, pageConfig);
        if (pageConfig.ignore) {
          ignorePages.push(pageConfig.appKey);
        }
      });
    }
    if (_config.elements) {
      _config.elements.forEach((elementConfig) => {
        _elementConfigMap.set(elementConfig.elementName, elementConfig);
        if (elementConfig.ignore) {
          ignoreElements.push(elementConfig.elementName);
        }
      });
    }

    _ignorePageSet = new Set(ignorePages);
    _ignoreElementSet = new Set(ignoreElements);

    for (let callback of listeners) {
      callback(_config);
    }
  },

  addListener(callback?: Function) {
    if (callback) {
      listeners.push(callback);
    }
  },

  removeListener(callback?: Function) {
    if (!callback) {
      return;
    }
    const index = listeners.indexOf(callback);
    if (index > -1) {
      listeners.splice(index, 1);
    }
  },
};