import {
  ROOT_GETTER,
  ROOT_GETTER_ISMOBILE_VIEW,
  ROOT_GETTER_GET_BREADCRUMBS,
  ROOT_GETTER_GET_LEAD_DATA,
  ROOT_GETTER_GET_LEAD_DATA_REALTIME,
  ROOT_GETTER_GET_CHANNELS,
  ROOT_GETTER_GET_CHANNEL_TYPES,
  ROOT_GETTER_GET_LEAD_SPECIFIC_DATA,
  ROOT_GETTER_IS_SELECTED_LEAD_ONLINE,
  ROOT_GETTER_SELECTED_LEAD_DETAILS,
  ROOT_GETTER_IS_SELECTED_LEAD_TYPING,
  ROOT_GETTER_GET_LEAD_DATA_REALTIME_FILTERS,
} from '../../constants';
import _ from 'lodash';
import moment from 'moment';
export default {
  [ROOT_GETTER](state) {
    return state;
  },
  [ROOT_GETTER_GET_LEAD_DATA](state) {
    return state.leadData;
  },
  [ROOT_GETTER_GET_LEAD_DATA_REALTIME_FILTERS](state) {
    const sourceObject = {};
    _.forEach(state.sources, t => {
      sourceObject[t.id] = t;
    });

    if (state.leadRealTimeFilters == null) {
      return {};
    }
    return {
      channelTypes: _.map(state.leadRealTimeFilters.interactiontypes, v => {
        let label = '';
        switch (v.label) {
          case 'CHAT_MESSAGE':
            label = 'Chat';
            break;
          case 'EMAIL':
            label = 'Email';
            break;
        }
        return {
          label: label,
          value: v.label,
        };
      }),
      sources: _.map(
        _.filter(state.leadRealTimeFilters.sourceIds, s => s.length),
        b => ({
          ...b,
          label: sourceObject[b.label].name,
        }),
      ),
    };
  },
  [ROOT_GETTER_GET_LEAD_SPECIFIC_DATA](state) {
    const sourceObject = {};
    _.forEach(state.sources, t => {
      sourceObject[t.id] = t;
    });
    // const channeltypeObject = {};
    // _.forEach(state.channel_types, t => {
    //   channeltypeObject[t.type_id] = t;
    // });
    const channelsObject = {};
    _.forEach(state.channels, t => {
      channelsObject[t.channel_id] = t;
    });
    const leadssObject = {};
    _.forEach(state.leadData, t => {
      leadssObject[t.leadId] = t;
    });

    let response = _.map(state.leadSpecificRealTimeData, rt => {
      const createdAt = new Date(rt.created_at);
      const createdDay = moment(createdAt).format('L');
      const isyesterday =
        createdDay ===
        moment()
          .subtract(1, 'days')
          .format('L');
      const istoday = createdDay === moment().format('L');
      let interactionHeading = '';
      const isLeadInteraction = rt.fromLead !== undefined ? rt.fromLead : true;
      switch (rt.interaction_type) {
        case 'CHAT_MESSAGE':
          interactionHeading = 'Chat';
          break;
        case 'EMAIL':
          interactionHeading = 'Email';
          break;
        // case 'PHONE_CALL':
        //   interactionHeading = 'Phone Call';
        //   break;
        // case 'PHONE_MISSED_CALL':
        //   interactionHeading = 'Missed Call';
        //   break;
        // case 'PHONE_SMS':
        //   interactionHeading = 'SMS';
        //   break;
        // case 'PHONE_VOICE_MAIL':
        //   interactionHeading = 'Voicemail';
        //   break;
        // case 'WEBFORM_SUBMISSION':
        //   interactionHeading = 'Webform ';
        //   break;
        default:
          interactionHeading = 'Unknown';
      }
      // interactionHeading += ` ${isLeadInteraction ? 'Recieved' : 'Sent'}`;
      return {
        ...rt,
        sourceDetails: sourceObject[rt.source_id],
        interactionHeading,
        createdAt,
        createdByDay: moment(createdAt).format('L'),
        timeFormattedString: moment(createdAt).fromNow(),
        dateFormattedString: moment(createdAt).format('MMM Do'),
        isyesterday,
        istoday,
      };
    });
    response = _.groupBy(response, 'createdByDay');
    response = _.map(
      _.orderBy(_.keys(response), k => moment(k), ['asc']),
      d => ({
        day: d,
        interactions: _.orderBy(response[d], k => moment(k.createdAt), ['asc']),
      }),
    );
    return response;
  },
  [ROOT_GETTER_GET_LEAD_DATA_REALTIME](state) {
    if (
      _.isEmpty(state.leadData) ||
      _.isEmpty(state.channels) ||
      _.isEmpty(state.sources)
    ) {
      return [];
    }
    const sourceObject = {};
    _.forEach(state.sources, t => {
      sourceObject[t.id] = t;
    });
    const channelsObject = {};
    _.forEach(state.channels, t => {
      channelsObject[t.channel_id] = t;
    });

    const leadssObject = {};
    _.forEach(state.leadData, t => {
      leadssObject[t.leadId] = t;
    });
    let validRealTimeData = _.filter(state.leadRealTimeData, ({ leadId }) =>
      _.includes(_.keys(leadssObject), leadId),
    );
    if (state.leadDrivenBoxDBFilters.intentScore.length) {
      validRealTimeData = _.filter(state.leadRealTimeData, ({ leadId }) =>
        _.includes(state.newdbFilteredLeadIds, leadId),
      );
    }
    let dbSortApplied = state.leadDrivenBoxFiltersDB.sort !== null;

    let _data = _.map(validRealTimeData, d => ({
      ...d,
      sort: leadssObject[d.leadId].sort,
    }));
    let response = _.map(_data, rt => {
      const createdAt = new Date(
        rt.latest_interaction_details._source.created_at,
      );

      const createdDay = moment(createdAt).format('L');
      const isyesterday =
        createdDay ===
        moment()
          .subtract(1, 'days')
          .format('L');
      const istoday = createdDay === moment().format('L');
      return {
        ...rt,
        createdAt,
        createdByDay: moment(createdAt).format('L'),
        timeFormattedString: moment(createdAt).fromNow(),
        dateFormattedString: moment(createdAt).format('MMM Do'),
        isyesterday,
        istoday,
      };
    });
    if (state.leadDrivenBoxFiltersDB.searchTerm.length > 0) {
      const sortedFilteredLeadIDs = _.uniq([
        // ...state.dbFilteredLeadIds,
        ...state.realTimeSeachedLeadIds,
      ]);
      if (sortedFilteredLeadIDs.length) {
        response = _.filter(response, ({ leadId }) =>
          _.includes(sortedFilteredLeadIDs, leadId),
        );
        response = _.reverse(
          _.map(_.reverse(sortedFilteredLeadIDs), (d, index) => ({
            ..._.find(response, ({ leadId }) => leadId === d),
            sort: index,
          })),
        );
        dbSortApplied = true;
      } else {
        response = [];
      }
    }
    if (dbSortApplied) {
      response = _.groupBy(response, 'sort');
      response = _.map(_.sortBy(_.keys(response)).reverse(), d => ({
        sort: d,
        leads: _.orderBy(response[d], k => moment(k.createdAt), ['desc']),
      }));
    } else {
      response = _.groupBy(response, 'createdByDay');
      response = _.map(
        _.orderBy(_.keys(response), k => moment(k), ['desc']),
        d => ({
          day: d,
          leads: _.orderBy(response[d], k => moment(k.createdAt), ['desc']),
        }),
      );
    }
    response = _.map(response, r => ({
      ...r,
      leads: _.map(r.leads, l => ({
        ...l,
        leadDetails: {
          ...leadssObject[l.leadId],
          sources: _.map(
            _.filter(l.sources, s => s.length),
            s => sourceObject[s],
          ),
        },
        new_interaction_details:
          l.new_interaction_count > 0
            ? _.map(l.new_interaction_details, n => ({
                ...n,
                sourceDetails: sourceObject[n._source.source_id],
                channelDetails: channelsObject[n._source.channel],
                // channelTypeDetails: channeltypeObject[n._source.channel_type],
              }))
            : [],
        latest_interaction_details: {
          ...l.latest_interaction_details,
          sourceDetails:
            sourceObject[l.latest_interaction_details._source.source_id],
          channelDetails:
            channelsObject[l.latest_interaction_details._source.channel],
          // channelTypeDetails:
          //   channeltypeObject[
          //     l.latest_interaction_details._source.channel_type
          //   ],
        },
      })),
    }));
    return response;
  },
  [ROOT_GETTER_GET_CHANNELS](state) {
    const response = {};
    _.forEach(state.channels, t => {
      response[t.channel_id] = t;
    });
    return response;
  },
  [ROOT_GETTER_GET_CHANNEL_TYPES](state) {
    const response = {};
    _.forEach(state.channel_types, t => {
      response[t.type_id] = t;
    });
    return response;
  },
  [ROOT_GETTER_ISMOBILE_VIEW]({ windowWidth }) {
    if (windowWidth < 991) {
      return true;
    }
    return false;
  },
  [ROOT_GETTER_GET_BREADCRUMBS]({ breadCrumbs }) {
    return _.sortBy(
      _.map(
        _.filter(_.keys(breadCrumbs), b => breadCrumbs[b].isVisible === true),
        k => ({ ...breadCrumbs[k], event: k }),
      ),
      'sort',
    );
  },
  [ROOT_GETTER_IS_SELECTED_LEAD_TYPING](state) {
    if (state.selectedLeadID === null) {
      return false;
    }
    let isTyping = _.find(
      state.leadRealTimeData,
      ({ leadId }) => leadId === state.selectedLeadID,
    ).typing;
    return isTyping === undefined ? false : isTyping;
  },
  [ROOT_GETTER_IS_SELECTED_LEAD_ONLINE](state) {
    if (state.selectedLeadID === null) {
      return false;
    }
    if (
      _.find(
        state.leadRealTimeData,
        ({ leadId }) => leadId === state.selectedLeadID,
      )
    ) {
      return _.find(
        state.leadRealTimeData,
        ({ leadId }) => leadId === state.selectedLeadID,
      ).isOnline;
    }
    return false;
  },
  [ROOT_GETTER_SELECTED_LEAD_DETAILS](state) {
    if (state.selectedLeadID === null) {
      return null;
    }
    const leadssObject = {};
    _.forEach(state.leadData, t => {
      leadssObject[t.leadId] = t;
    });
    return {
      ..._.find(
        state.leadRealTimeData,
        ({ leadId }) => leadId === state.selectedLeadID,
      ),
      leadDetails: leadssObject[state.selectedLeadID],
    };
  },
};