import {
  ROOT_ACTION_RESET_SUCCESS_AND_ERROR_MESSAGE,
  ROOT_ACTION_SET_BREADCRUMB,
  ROOT_ACTION_SET_WINDOW_WIDTH,
  ROOT_ACTION_SET_ERROR_MESSAGE,
  ROOT_ACTION_SET_SUCCESS_MESSAGE,
  ROOT_ACTION_SET_MOBILE_SCREEN,
  ROOT_MUTATION_SET_MOBILE_SCREEN,
  ROOT_MUTATION_SET_WINDOW_WIDTH,
  ROOT_ACTION_GET_LEAD_DATA,
  ROOT_ACTION_GET_CHANNELS,
  ROOT_MUTATION_SET_CHANNELS,
  ROOT_MUTATION_SET_LEAD_DATA,
  ROOT_MUTATION_SET_LEAD_DATA_REALTIME,
  ROOT_MUTATION_SET_LOADING_CHANNELS,
  ROOT_MUTATION_SET_LOADING_LEAD_DATA,
  ROOT_MUTATION_SET_LOADING_LEAD_DATA_REALTIME,
  ROOT_ACTION_GET_AGENT_DETAILS,
  ROOT_MUTATION_SET_LOADING_PROFILE_DATA,
  ROOT_MUTATION_SET_AGENT_DETAILS,
  ROOT_ACTION_SET_LOADING_LEAD_DATA_REALTIME,
  ROOT_ACTION_SET_LOADING_LEAD_CARDS_DATA_REALTIME,
  ROOT_MUTATION_SET_LOADING_LEAD_CARDS_DATA_REALTIME,
  ROOT_ACTION_SET_LEAD_DATA_REALTIME,
  ROOT_ACTION_SET_LOADING_LEAD_SPECIFIC_DATA,
  ROOT_MUTATION_SET_LOADING_LEAD_SPECIFIC_DATA,
  ROOT_MUTATION_SET_LEAD_SPECIFIC_DATA_REALTIME,
  ROOT_ACTION_SET_LEAD_SPECIFIC_DATA_REALTIME,
  ROOT_ACTION_SELECT_LEAD_ID,
  ROOT_MUTATION_SET_SELECT_LEAD_ID,
  ROOT_ACTION_SET_LEAD_CARD_UPDATE,
  ROOT_GETTER,
  ROOT_ACTION_UPDATE_SELECTED_LEAD_INTERACTIONS,
  ROOT_ACTION_UPDATE_LEAD_INERMEDIATE_STATUS,
  ROOT_MUTATION_SET_LOADING_LEAD_SPECIFIC_DATA_HISTORY,
  ROOT_ACTION_SET_LOADING_LEAD_SPECIFIC_DATA_HISTORY,
  ROOT_MUTATION_SET_SOURCES,
  ROOT_ACTION_GET_SOURCES,
  ROOT_ACTION_SET_LEAD_DRIVEN_BOX_FILTERS_DB,
  ROOT_MUTATION_SET_LEAD_DRIVEN_BOX_FILTERS_DB,
  ROOT_MUTATION_SET_LEAD_DRIVEN_BOX_ACTIVE_TAB,
  ROOT_ACTION_SET_LEAD_DRIVEN_BOX_ACTIVE_TAB,
  ROOT_ACTION_GET_INBOX_TYPE_COUNTS,
  ROOT_MUTATION_SET_INBOX_TYPE_COUNTS,
  ROOT_MUTATION_CHANGE_LEAD_STATUS_LOADING,
  ROOT_ACTION_CHANGE_LEAD_STATUS,
  ROOT_ACTION_SET_LEAD_STATUS_CHANGE_TRIGGERKEY,
  ROOT_MUTATION_SET_LEAD_STATUS_CHANGE_TRIGGERKEY,
  ROOT_MUTATION_SET_SUCCESS_MESSAGE,
  ROOT_MUTATION_SET_ERROR_MESSAGE,
  ROOT_MUTATION_SET_NEW_LEADS,
  ROOT_ACTION_GET_NEW_LEADS,
  ROOT_MUTATION_UPDATE_INTERACTION_VISIBILITY,
  ROOT_ACTION_UPDATE_INTERACTION_VISIBILITY,
  ROOT_ACTION_RESET_SELECTED_LEAD,
  ROOT_MUTATION_RESET_SELECTED_LEAD,
  ROOT_MUTATION_SET_DB_FILTERED_LEADS,
  ROOT_ACTION_GET_DB_FILTERED_LEADS,
  ROOT_MUTATION_SET_LEAD_DB_FILTERS,
  ROOT_ACTION_SET_LEAD_DB_FILTERS,
  ROOT_MUTATION_SHOW_PROFILE_SCREEN,
  ROOT_ACTION_SHOW_PROFILE_SCREEN,
  ROOT_ACTION_GET_SELECTED_LEAD_PROFILE_DATA,
  ROOT_MUTATION_SET_SELECTED_LEAD_PROFILE_DATA,
  ROOT_ACTION_UDPATE_LEAD_DATA,
  ROOT_MUTATION_UDPATE_LEAD_DATA_LOADING,
  ROOT_MUTATION_SET_AGENTS,
  ROOT_ACTION_SET_AGENTS,
  ROOT_MUTATION_SET_CONTACT_TAGS,
  ROOT_ACTION_GET_CONTACT_TAGS,
} from '../../constants';
import InboxService from '../../../../service/inboxService';
import ProfileService from '../../../../service/profileService';
import SourceService from '../../../../service/source';
import ChannelService from '../../../../service/channelService';
import * as _ from 'lodash';
export default {
  async [ROOT_ACTION_UDPATE_LEAD_DATA]({ commit, dispatch }, payload) {
    commit(ROOT_MUTATION_UDPATE_LEAD_DATA_LOADING, true);
    const {
      data: { data, success, message },
    } = await InboxService.updateLeadData(payload.id, payload.data);
    if (!success) {
    } else {
      commit(ROOT_MUTATION_SET_SUCCESS_MESSAGE, message);
      dispatch(ROOT_ACTION_GET_LEAD_DATA);
      dispatch(ROOT_ACTION_GET_SELECTED_LEAD_PROFILE_DATA, payload.id);
    }
    commit(ROOT_MUTATION_UDPATE_LEAD_DATA_LOADING, true);
  },
  [ROOT_ACTION_GET_CONTACT_TAGS]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_CONTACT_TAGS, payload);
  },
  [ROOT_ACTION_SET_AGENTS]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_AGENTS, payload);
  },
  [ROOT_ACTION_SHOW_PROFILE_SCREEN]({ commit, dispatch, rootState }, payload) {
    commit(ROOT_MUTATION_SHOW_PROFILE_SCREEN, payload);
    if (payload && rootState.root.leadProfileData === null) {
      dispatch(
        ROOT_ACTION_GET_SELECTED_LEAD_PROFILE_DATA,
        rootState.root.selectedLeadID,
      );
    }
  },
  [ROOT_ACTION_SET_LEAD_DB_FILTERS]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_DB_FILTERS, payload);
  },
  [ROOT_ACTION_RESET_SELECTED_LEAD]({ commit }) {
    commit(ROOT_MUTATION_RESET_SELECTED_LEAD);
  },
  async [ROOT_ACTION_GET_SELECTED_LEAD_PROFILE_DATA]({ commit }, payload) {
    const {
      data: { data, success },
    } = await InboxService.getLeadDataById(payload);
    if (!success) {
    } else {
      commit(ROOT_MUTATION_SET_SELECTED_LEAD_PROFILE_DATA, data);
    }
  },
  async [ROOT_ACTION_GET_SOURCES]({ commit }) {
    const {
      data: { data, message, success },
    } = await SourceService.getSources();
    if (!success) {
      commit(ROOT_MUTATION_SET_ERROR_MESSAGE, message);
    } else {
      commit(
        ROOT_MUTATION_SET_SOURCES,
        _.map(data, d => ({
          ...d,
          createdOn: moment(d.created_at).format('MMM Do'),
          updatedOn: moment(d.updated_at).format('MMM Do'),
        })),
      );
    }
  },
  [ROOT_ACTION_UPDATE_INTERACTION_VISIBILITY]({ commit }, payload) {
    commit(ROOT_MUTATION_UPDATE_INTERACTION_VISIBILITY, payload);
  },
  [ROOT_ACTION_SET_LEAD_STATUS_CHANGE_TRIGGERKEY]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_STATUS_CHANGE_TRIGGERKEY, payload);
  },

  [ROOT_ACTION_RESET_SUCCESS_AND_ERROR_MESSAGE]({ commit }) {
    commit(ROOT_MUTATION_SET_ERROR_MESSAGE, null);
    commit(ROOT_MUTATION_SET_SUCCESS_MESSAGE, null);
  },
  [ROOT_ACTION_SET_BREADCRUMB]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_BREADCRUMB, payload);
  },
  async [ROOT_ACTION_GET_DB_FILTERED_LEADS]({ commit }, payload) {
    const {
      data: { data, success },
    } = await InboxService.getLeads(payload);
    if (!success) {
    } else {
      commit(
        ROOT_MUTATION_SET_DB_FILTERED_LEADS,
        _.map(data, ({ leadId }) => leadId),
      );
    }
  },
  async [ROOT_ACTION_CHANGE_LEAD_STATUS]({ commit, dispatch }, payload) {
    commit(ROOT_MUTATION_CHANGE_LEAD_STATUS_LOADING, true);
    const {
      data: { message, success },
    } = await InboxService.chnageLeadStatus(payload);
    if (!success) {
      commit(ROOT_MUTATION_SET_ERROR_MESSAGE, message);
    } else {
      commit(ROOT_MUTATION_SET_SUCCESS_MESSAGE, message);
      dispatch(ROOT_ACTION_GET_LEAD_DATA);
      dispatch(ROOT_ACTION_GET_NEW_LEADS);
      commit(ROOT_MUTATION_SET_LEAD_STATUS_CHANGE_TRIGGERKEY, true);
    }
    commit(ROOT_MUTATION_CHANGE_LEAD_STATUS_LOADING, false);
  },
  [ROOT_ACTION_GET_INBOX_TYPE_COUNTS]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_INBOX_TYPE_COUNTS, payload);
  },
  [ROOT_ACTION_SET_LEAD_DRIVEN_BOX_ACTIVE_TAB]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_DRIVEN_BOX_ACTIVE_TAB, payload);
  },
  [ROOT_ACTION_SET_WINDOW_WIDTH]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_WINDOW_WIDTH, payload);
  },
  [ROOT_ACTION_SET_ERROR_MESSAGE]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_ERROR_MESSAGE, payload);
  },
  [ROOT_ACTION_SET_LEAD_DRIVEN_BOX_FILTERS_DB]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_DRIVEN_BOX_FILTERS_DB, payload);
  },
  [ROOT_ACTION_SET_SUCCESS_MESSAGE]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_SUCCESS_MESSAGE, payload);
  },
  [ROOT_ACTION_SET_MOBILE_SCREEN]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_MOBILE_SCREEN, payload);
  },
  async [ROOT_ACTION_GET_NEW_LEADS]({ commit }) {
    const {
      data: { data, success },
    } = await InboxService.getLeads({ status: 'new' });
    if (!success) {
    } else {
      commit(
        ROOT_MUTATION_SET_NEW_LEADS,
        _.map(data, ({ leadId }) => leadId),
      );
    }
  },
  async [ROOT_ACTION_GET_LEAD_DATA]({ commit, getters }) {
    commit(ROOT_MUTATION_SET_LOADING_LEAD_DATA, true);
    const {
      data: { data, message, success },
    } = await InboxService.getLeads(
      _.omit(getters[ROOT_GETTER].leadDrivenBoxFiltersDB, ['searchTerm']),
    );
    if (!success) {
      commit(ROOT_MUTATION_SET_ERROR_MESSAGE, message);
    } else {
      commit(ROOT_MUTATION_SET_LEAD_DATA, {
        type: 'NonFiltered',
        data,
      });
    }
    // if ((getters[ROOT_GETTER].leadDrivenBoxFiltersDB, ['searchTerm'])) {
    //   const {
    //     data: { data, message, success },
    //   } = await InboxService.getLeads(
    //     getters[ROOT_GETTER].leadDrivenBoxFiltersDB,
    //   );
    //   if (!success) {
    //     commit(ROOT_MUTATION_SET_ERROR_MESSAGE, message);
    //   } else {
    //     commit(ROOT_MUTATION_SET_LEAD_DATA, {
    //       type: 'Filtered',
    //       data,
    //     });
    //   }
    // }
    commit(ROOT_MUTATION_SET_LOADING_LEAD_DATA, false);
  },

  [ROOT_ACTION_SET_LEAD_SPECIFIC_DATA_REALTIME]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_SPECIFIC_DATA_REALTIME, payload);
  },
  [ROOT_ACTION_UPDATE_SELECTED_LEAD_INTERACTIONS](
    { commit, getters },
    payload,
  ) {
    if (getters[ROOT_GETTER].selectedLeadID === payload.lead_id) {
      commit(ROOT_MUTATION_SET_LEAD_SPECIFIC_DATA_REALTIME, [
        ...getters[ROOT_GETTER].leadSpecificRealTimeData,
        payload,
      ]);
    }
  },
  [ROOT_ACTION_SET_LOADING_LEAD_SPECIFIC_DATA]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LOADING_LEAD_SPECIFIC_DATA, payload);
  },
  [ROOT_ACTION_SET_LOADING_LEAD_SPECIFIC_DATA_HISTORY]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LOADING_LEAD_SPECIFIC_DATA_HISTORY, payload);
  },
  [ROOT_ACTION_SET_LOADING_LEAD_CARDS_DATA_REALTIME]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LOADING_LEAD_CARDS_DATA_REALTIME, payload);
  },
  [ROOT_ACTION_SET_LOADING_LEAD_DATA_REALTIME]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LOADING_LEAD_DATA_REALTIME, payload);
  },
  [ROOT_ACTION_SET_LEAD_DATA_REALTIME]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_DATA_REALTIME, payload);
  },
  [ROOT_ACTION_SET_LEAD_CARD_UPDATE]({ commit, getters }, payload) {
    const previousLeadCardsData = getters[ROOT_GETTER].leadRealTimeData;
    const agentOptions = payload.agentOptions;
    let inboxType = 'All';
    if (
      getters[ROOT_GETTER].leadDrivenBoxActiveTab === 'My Inbox' &&
      agentOptions.length === 1 &&
      agentOptions[0] === getters[ROOT_GETTER].profileData.userSid
    ) {
      inboxType = 'My Inbox';
    } else if (
      getters[ROOT_GETTER].leadDrivenBoxActiveTab === 'Team Inbox' &&
      agentOptions.length > 1 &&
      _.includes(agentOptions, getters[ROOT_GETTER].profileData.userSid)
    ) {
      inboxType = 'Team Inbox';
    } else if (
      getters[ROOT_GETTER].leadDrivenBoxActiveTab === 'Unassigned' &&
      agentOptions.length === 0
    ) {
      inboxType = 'Unassigned';
    }
    if (inboxType === getters[ROOT_GETTER].leadDrivenBoxActiveTab) {
      commit(ROOT_MUTATION_SET_LEAD_DATA_REALTIME, {
        payload: [
          payload,
          ..._.filter(
            previousLeadCardsData,
            ({ leadId }) => leadId !== payload.leadId,
          ),
        ],
      });
    }
  },

  async [ROOT_ACTION_GET_CHANNELS]({ commit }) {
    commit(ROOT_MUTATION_SET_LOADING_CHANNELS, true);
    const [chatChannels, emailChannels] = await Promise.all([
      ChannelService.getChatChannels(),
      ChannelService.getEmailChannels(),
    ]);
    const formattedChatChannels = _.map(chatChannels.data.data, e => ({
      channel_id: e.id,
      channel_name: e.name,
      sourceId: e.sourceId,
      type: 'CHAT',
    }));
    const formattedEmailChannels = _.map(emailChannels.data.data, e => ({
      channel_id: e.id,
      channel_name: e.name,
      sourceId: e.sourceId,
      type: 'EMAIL',
    }));

    commit(ROOT_MUTATION_SET_CHANNELS, [
      ...formattedChatChannels,
      ...formattedEmailChannels,
    ]);

    commit(ROOT_MUTATION_SET_LOADING_CHANNELS, false);
  },
  async [ROOT_ACTION_GET_AGENT_DETAILS]({ commit }) {
    commit(ROOT_MUTATION_SET_LOADING_PROFILE_DATA, true);
    const {
      data: { data, message, success },
    } = await ProfileService.getProfileInfo();
    if (!success) {
      commit(ROOT_MUTATION_SET_ERROR_MESSAGE, message);
    } else {
      commit(ROOT_MUTATION_SET_AGENT_DETAILS, data);
    }
    commit(ROOT_MUTATION_SET_LOADING_PROFILE_DATA, false);
  },
  [ROOT_ACTION_SELECT_LEAD_ID]({ commit }, payload) {
    commit(ROOT_MUTATION_SET_SELECT_LEAD_ID, payload);
  },
  [ROOT_ACTION_UPDATE_LEAD_INERMEDIATE_STATUS]({ commit, getters }, payload) {
    commit(ROOT_MUTATION_SET_LEAD_DATA_REALTIME, {
      payload: _.map(getters[ROOT_GETTER].leadRealTimeData, v => ({
        ...v,
        isOnline:
          payload.online !== undefined
            ? payload.leadID === v.leadId
              ? payload.online
              : v.isOnline
            : v.isOnline,
        typing:
          payload.typing !== undefined
            ? payload.leadID === v.leadId
              ? payload.typing
              : v.typing !== undefined
              ? v.typing
              : false
            : v.typing !== undefined
            ? v.typing
            : false,
        //typing
      })),
    });
  },
};