declare const __VERSION__: string
declare const window: any
import { get, omit, map } from 'lodash'
import { wrapStore } from 'react-chrome-redux'
import { applyMiddleware, createStore } from 'redux'
import { createEpicMiddleware } from 'redux-observable'
const RavenMiddleware = require('redux-raven-middleware')

import '../img/webstore_icon.png'
import '../img/bw_icon_128.png'
import '../img/bw_icon_32.png'
import '../img/grey_icon_32.png'
import { submitLoginSuccess } from './modules/auth/actions'
import { user } from './modules/auth/selectors'
import { userHasSeenOnboarding } from './modules/onboarding/actions'
import * as PopupActions from './modules/popup/actions'
import * as PlaybookActions from './modules/playbook/actions'
import * as PlaybookSelectors from './modules/playbook/selectors'
import { setSettingStatus } from './modules/settings/actions'

import reducers from './store'
import { rootEpic } from './store/rootEpic'
import { generateOrgIdRegex } from './utils/email'
import { CLICK_TRACKING_URL, SENTRY_KEY } from './utils/ResourceConstants'
import { initializeSegment } from './utils/segment'
import Raven from './utils/sentry'

initializeSegment()

const filterRavenState = (state: any) => omit(state, ['avatars'])

Raven.setExtraContext({ version: __VERSION__ })

Raven.context(() => { // wraps in try/catch
  const epicMiddleware = createEpicMiddleware(rootEpic)

  const store = createStore(
    reducers,
    applyMiddleware(
      RavenMiddleware(SENTRY_KEY, null, {
        stateTransformer: filterRavenState,
      }),
      epicMiddleware,
    ),
  )

  chrome.browserAction.setBadgeText({ text: '!' })
  chrome.browserAction.setIcon({
    path: 'grey_icon_32.png',
  })

  chrome.storage.sync.get('token', (data) => {
    if (data && data.token) {
      store.dispatch(submitLoginSuccess({ token: data.token }))
      store.dispatch(userHasSeenOnboarding(true))
    }
  })

  chrome.storage.sync.get('settings', (data) => {
    if (data && data.settings) {
      
      const domainMuteList = map(data.settings.domainMuteList, (domain: any) => typeof domain === 'string'
        ? ({ domain, date: Date.now() })
        : domain)
      store.dispatch(setSettingStatus({ ...data.settings, domainMuteList }))
    }
  })

  chrome.webRequest.onBeforeRequest.addListener(
    (details) => {
      const orgId = get(user(store.getState()), 'orgId', null)
      if (!orgId) {
        return
      }
      const orgIdRegex = generateOrgIdRegex(orgId)
      if (details.url.match(orgIdRegex)) {
        return { cancel: true }
      }
    },
    { urls: ['*://*.googleusercontent.com/*', `${CLICK_TRACKING_URL}/*`] },
    ['blocking'],
  )

  const PORT_NAME = 'DRIFT'


  wrapStore(store, { portName: PORT_NAME })

  window.store = store

  chrome.runtime.onConnect.addListener((port: any) => {
    if (port.name !== PORT_NAME) {
      return
    }

    const isPopup = port && port.sender && port.sender.url === chrome.extension.getURL('popup.html')
    if (!isPopup) {
      return
    }

    port.onDisconnect.addListener(() => {
      store.dispatch(PopupActions.popupClose())
    })
  })

  chrome.runtime.setUninstallURL('https://www.drift.com/extension-uninstall/')

  chrome.tabs.onRemoved.addListener((tabId: number) => {
    const emails = PlaybookSelectors.emails(store.getState(), { tabId })
    if (emails.length) {
      store.dispatch(PlaybookActions.clearState({ tabId, emails }))
    }
  })

  chrome.tabs.onReplaced.addListener((tabId: number) => {
    const emails = PlaybookSelectors.emails(store.getState(), { tabId })
    if (emails.length) {
      store.dispatch(PlaybookActions.clearState({ tabId, emails }))
    }
  })
})