import { getHexGasTotal } from '../../helpers/confirm-transaction/util'

// path constants
const STATUS_PATH = '/status'
const GAS_PRICE_PATH = '/txParams/gasPrice'
const GAS_LIMIT_PATH = '/txParams/gas'

// op constants
const REPLACE_OP = 'replace'

import {
  // event constants
  TRANSACTION_CREATED_EVENT,
  TRANSACTION_SUBMITTED_EVENT,
  TRANSACTION_RESUBMITTED_EVENT,
  TRANSACTION_CONFIRMED_EVENT,
  TRANSACTION_DROPPED_EVENT,
  TRANSACTION_UPDATED_EVENT,
  TRANSACTION_ERRORED_EVENT,
  TRANSACTION_CANCEL_ATTEMPTED_EVENT,
  TRANSACTION_CANCEL_SUCCESS_EVENT,
  // status constants
  SUBMITTED_STATUS,
  CONFIRMED_STATUS,
  DROPPED_STATUS,
} from './transaction-activity-log.constants'

import {
  TRANSACTION_TYPE_CANCEL,
  TRANSACTION_TYPE_RETRY,
} from '../../../../app/scripts/controllers/transactions/enums'

const eventPathsHash = {
  [STATUS_PATH]: true,
  [GAS_PRICE_PATH]: true,
  [GAS_LIMIT_PATH]: true,
}

const statusHash = {
  [SUBMITTED_STATUS]: TRANSACTION_SUBMITTED_EVENT,
  [CONFIRMED_STATUS]: TRANSACTION_CONFIRMED_EVENT,
  [DROPPED_STATUS]: TRANSACTION_DROPPED_EVENT,
}

/**
 * @name getActivities
 * @param {Object} transaction - txMeta object
 * @param {boolean} isFirstTransaction - True if the transaction is the first created transaction
 * in the list of transactions with the same nonce. If so, we use this transaction to create the
 * transactionCreated activity.
 * @returns {Array}
 */
export function getActivities (transaction, isFirstTransaction = false) {
  const { id, hash, history = [], txReceipt: { status } = {}, type } = transaction

  let cachedGasLimit = '0x0'
  let cachedGasPrice = '0x0'

  const historyActivities = history.reduce((acc, base, index) => {
    // First history item should be transaction creation
    if (index === 0 && !Array.isArray(base) && base.txParams) {
      const { time: timestamp, txParams: { value, gas = '0x0', gasPrice = '0x0' } = {} } = base
      // The cached gas limit and gas price are used to display the gas fee in the activity log. We
      // need to cache these values because the status update history events don't provide us with
      // the latest gas limit and gas price.
      cachedGasLimit = gas
      cachedGasPrice = gasPrice

      if (isFirstTransaction) {
        return acc.concat({
          id,
          hash,
          eventKey: TRANSACTION_CREATED_EVENT,
          timestamp,
          value,
        })
      }
      // An entry in the history may be an array of more sub-entries.
    } else if (Array.isArray(base)) {
      const events = []

      base.forEach(entry => {
        const { op, path, value, timestamp: entryTimestamp } = entry
        // Not all sub-entries in a history entry have a timestamp. If the sub-entry does not have a
        // timestamp, the first sub-entry in a history entry should.
        const timestamp = entryTimestamp || base[0] && base[0].timestamp

        if (path in eventPathsHash && op === REPLACE_OP) {
          switch (path) {
            case STATUS_PATH: {
              const gasFee = getHexGasTotal({ gasLimit: cachedGasLimit, gasPrice: cachedGasPrice })

              if (value in statusHash) {
                let eventKey = statusHash[value]

                // If the status is 'submitted', we need to determine whether the event is a
                // transaction retry or a cancellation attempt.
                if (value === SUBMITTED_STATUS) {
                  if (type === TRANSACTION_TYPE_RETRY) {
                    eventKey = TRANSACTION_RESUBMITTED_EVENT
                  } else if (type === TRANSACTION_TYPE_CANCEL) {
                    eventKey = TRANSACTION_CANCEL_ATTEMPTED_EVENT
                  }
                } else if (value === CONFIRMED_STATUS) {
                  if (type === TRANSACTION_TYPE_CANCEL) {
                    eventKey = TRANSACTION_CANCEL_SUCCESS_EVENT
                  }
                }

                events.push({
                  id,
                  hash,
                  eventKey,
                  timestamp,
                  value: gasFee,
                })
              }

              break
            }

            // If the gas price or gas limit has been changed, we update the gasFee of the
            // previously submitted event. These events happen when the gas limit and gas price is
            // changed at the confirm screen.
            case GAS_PRICE_PATH:
            case GAS_LIMIT_PATH: {
              const lastEvent = events[events.length - 1] || {}
              const { lastEventKey } = lastEvent

              if (path === GAS_LIMIT_PATH) {
                cachedGasLimit = value
              } else if (path === GAS_PRICE_PATH) {
                cachedGasPrice = value
              }

              if (lastEventKey === TRANSACTION_SUBMITTED_EVENT ||
                lastEventKey === TRANSACTION_RESUBMITTED_EVENT) {
                lastEvent.value = getHexGasTotal({
                  gasLimit: cachedGasLimit,
                  gasPrice: cachedGasPrice,
                })
              }

              break
            }

            default: {
              events.push({
                id,
                hash,
                eventKey: TRANSACTION_UPDATED_EVENT,
                timestamp,
              })
            }
          }
        }
      })

      return acc.concat(events)
    }

    return acc
  }, [])

  // If txReceipt.status is '0x0', that means that an on-chain error occured for the transaction,
  // so we add an error entry to the Activity Log.
  return status === '0x0'
    ? historyActivities.concat({ id, hash, eventKey: TRANSACTION_ERRORED_EVENT })
    : historyActivities
}

/**
 * @description Removes "Transaction dropped" activities from a list of sorted activities if one of
 * the transactions has been confirmed. Typically, if multiple transactions have the same nonce,
 * once one transaction is confirmed, the rest are dropped. In this case, we don't want to show
 * multiple "Transaction dropped" activities, and instead want to show a single "Transaction
 * confirmed".
 * @param {Array} activities - List of sorted activities generated from the getActivities function.
 * @returns {Array}
 */
function filterSortedActivities (activities) {
  const filteredActivities = []
  const hasConfirmedActivity = Boolean(activities.find(({ eventKey }) => (
    eventKey === TRANSACTION_CONFIRMED_EVENT || eventKey === TRANSACTION_CANCEL_SUCCESS_EVENT
  )))
  let addedDroppedActivity = false

  activities.forEach(activity => {
    if (activity.eventKey === TRANSACTION_DROPPED_EVENT) {
      if (!hasConfirmedActivity && !addedDroppedActivity) {
        filteredActivities.push(activity)
        addedDroppedActivity = true
      }
    } else {
      filteredActivities.push(activity)
    }
  })

  return filteredActivities
}

/**
 * Combines the histories of an array of transactions into a single array.
 * @param {Array} transactions - Array of txMeta transaction objects.
 * @returns {Array}
 */
export function combineTransactionHistories (transactions = []) {
  if (!transactions.length) {
    return []
  }

  const activities = []

  transactions.forEach((transaction, index) => {
    // The first transaction should be the transaction with the earliest submittedTime. We show the
    // 'created' and 'submitted' activities here. All subsequent transactions will use 'resubmitted'
    // instead.
    const transactionActivities = getActivities(transaction, index === 0)
    activities.push(...transactionActivities)
  })

  const sortedActivities = activities.sort((a, b) => a.timestamp - b.timestamp)
  return filterSortedActivities(sortedActivities)
}