lbry-desktop/ui/redux/reducers/comments.js

// @flow
import * as ACTIONS from 'constants/action_types';
import { handleActions } from 'util/redux-utils';
import { BLOCK_LEVEL } from 'constants/comment';
import { isURIEqual } from 'lbry-redux';

const defaultState: CommentsState = {
  commentById: {}, // commentId -> Comment
  byId: {}, // ClaimID -> list of fetched comment IDs.
  totalCommentsById: {}, // ClaimId -> ultimate total (including replies) in commentron.
  repliesByParentId: {}, // ParentCommentID -> list of fetched replies.
  repliesTotalPagesByParentId: {}, // ParentCommentID -> total number of reply pages for a parentId in commentron.
  topLevelCommentsById: {}, // ClaimID -> list of fetched top level comments.
  topLevelTotalPagesById: {}, // ClaimID -> total number of top-level pages in commentron. Based on COMMENT_PAGE_SIZE_TOP_LEVEL.
  topLevelTotalCommentsById: {}, // ClaimID -> total top level comments in commentron.
  // TODO:
  // Remove commentsByUri
  // It is not needed and doesn't provide anything but confusion
  commentsByUri: {}, // URI -> claimId
  linkedCommentAncestors: {}, // {"linkedCommentId": ["parentId", "grandParentId", ...]}
  superChatsByUri: {},
  pinnedCommentsById: {}, // ClaimId -> array of pinned comment IDs
  isLoading: false,
  isLoadingByParentId: {},
  isCommenting: false,
  myComments: undefined,
  isFetchingReacts: false,
  pendingCommentReactions: [],
  typesReacting: [],
  myReactsByCommentId: undefined,
  othersReactsByCommentId: undefined,
  moderationBlockList: undefined,
  adminBlockList: undefined,
  moderatorBlockList: undefined,
  moderatorBlockListDelegatorsMap: {},
  fetchingModerationBlockList: false,
  moderationDelegatesById: {},
  fetchingModerationDelegates: false,
  moderationDelegatorsById: {},
  fetchingModerationDelegators: false,
  blockingByUri: {},
  unBlockingByUri: {},
  togglingForDelegatorMap: {},
  settingsByChannelId: {}, // ChannelId -> PerChannelSettings
  fetchingSettings: false,
  fetchingBlockedWords: false,
};

function pushToArrayInObject(obj, key, valueToPush) {
  if (!obj[key]) {
    obj[key] = [valueToPush];
  } else if (!obj[key].includes(valueToPush)) {
    obj[key].push(valueToPush);
  }
}

export default handleActions(
  {
    [ACTIONS.COMMENT_CREATE_STARTED]: (state: CommentsState, action: any): CommentsState => ({
      ...state,
      isCommenting: true,
    }),

    [ACTIONS.COMMENT_CREATE_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isCommenting: false,
    }),

    [ACTIONS.COMMENT_CREATE_COMPLETED]: (state: CommentsState, action: any): CommentsState => {
      const {
        comment,
        claimId,
        uri,
        livestream,
      }: { comment: Comment, claimId: string, uri: string, livestream: boolean } = action.data;

      const commentById = Object.assign({}, state.commentById);
      const byId = Object.assign({}, state.byId);
      const totalCommentsById = Object.assign({}, state.totalCommentsById);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById); // was byId {ClaimId -> [commentIds...]}
      const repliesByParentId = Object.assign({}, state.repliesByParentId); // {ParentCommentID -> [commentIds...] } list of reply comments
      const commentsByUri = Object.assign({}, state.commentsByUri);
      const comments = byId[claimId] || [];
      const newCommentIds = comments.slice();

      // If it was created during a livestream, let the websocket handler perform the state update
      if (!livestream) {
        // add the comment by its ID
        commentById[comment.comment_id] = comment;

        // push the comment_id to the top of ID list
        newCommentIds.unshift(comment.comment_id);
        byId[claimId] = newCommentIds;

        if (totalCommentsById[claimId]) {
          totalCommentsById[claimId] += 1;
        }

        if (comment['parent_id']) {
          if (!repliesByParentId[comment.parent_id]) {
            repliesByParentId[comment.parent_id] = [comment.comment_id];
          } else {
            repliesByParentId[comment.parent_id].unshift(comment.comment_id);
          }

          // Update the parent's "replies" value
          if (commentById[comment.parent_id]) {
            commentById[comment.parent_id].replies = (commentById[comment.parent_id].replies || 0) + 1;
          }
        } else {
          if (!topLevelCommentsById[claimId]) {
            commentsByUri[uri] = claimId;
            topLevelCommentsById[claimId] = [comment.comment_id];
          } else {
            topLevelCommentsById[claimId].unshift(comment.comment_id);
          }
        }
      }

      return {
        ...state,
        topLevelCommentsById,
        repliesByParentId,
        commentById,
        byId,
        totalCommentsById,
        commentsByUri,
        isLoading: false,
        isCommenting: false,
      };
    },

    [ACTIONS.COMMENT_REACTION_LIST_STARTED]: (state: CommentsState, action: any): CommentsState => ({
      ...state,
      isFetchingReacts: true,
    }),

    [ACTIONS.COMMENT_REACTION_LIST_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isFetchingReacts: false,
    }),

    [ACTIONS.COMMENT_REACT_FAILED]: (state: CommentsState, action: any): CommentsState => {
      const commentReaction = action.data; // String: reactionHash + type
      const newReactingTypes = new Set(state.pendingCommentReactions);
      newReactingTypes.delete(commentReaction);

      return {
        ...state,
        pendingCommentReactions: Array.from(newReactingTypes),
      };
    },

    [ACTIONS.COMMENT_REACT_STARTED]: (state: CommentsState, action: any): CommentsState => {
      const commentReaction = action.data;
      const newReactingTypes = new Set(state.pendingCommentReactions);
      newReactingTypes.add(commentReaction);

      return {
        ...state,
        pendingCommentReactions: Array.from(newReactingTypes),
      };
    },

    [ACTIONS.COMMENT_REACT_COMPLETED]: (state: CommentsState, action: any): CommentsState => {
      const commentReaction = action.data; // String: reactionHash + type
      const newReactingTypes = new Set(state.pendingCommentReactions);
      newReactingTypes.delete(commentReaction);

      return {
        ...state,
        pendingCommentReactions: Array.from(newReactingTypes),
      };
    },

    [ACTIONS.COMMENT_REACTION_LIST_COMPLETED]: (state: CommentsState, action: any): CommentsState => {
      const { myReactions, othersReactions, channelId, commentIds } = action.data;
      const myReacts = Object.assign({}, state.myReactsByCommentId);
      const othersReacts = Object.assign({}, state.othersReactsByCommentId);

      const myReactionsEntries = myReactions ? Object.entries(myReactions) : [];
      const othersReactionsEntries = othersReactions ? Object.entries(othersReactions) : [];

      if (myReactionsEntries.length > 0) {
        myReactionsEntries.forEach(([commentId, reactions]) => {
          const key = channelId ? `${commentId}:${channelId}` : commentId;
          myReacts[key] = Object.entries(reactions).reduce((acc, [name, count]) => {
            if (count === 1) {
              acc.push(name);
            }
            return acc;
          }, []);
        });
      } else {
        commentIds.forEach((commentId) => {
          const key = channelId ? `${commentId}:${channelId}` : commentId;
          myReacts[key] = [];
        });
      }

      if (othersReactionsEntries.length > 0) {
        othersReactionsEntries.forEach(([commentId, reactions]) => {
          const key = channelId ? `${commentId}:${channelId}` : commentId;
          othersReacts[key] = reactions;
        });
      } else {
        commentIds.forEach((commentId) => {
          const key = channelId ? `${commentId}:${channelId}` : commentId;
          othersReacts[key] = {};
        });
      }

      return {
        ...state,
        isFetchingReacts: false,
        myReactsByCommentId: myReacts,
        othersReactsByCommentId: othersReacts,
      };
    },

    [ACTIONS.COMMENT_LIST_STARTED]: (state, action: any) => {
      const { parentId } = action.data;
      const isLoadingByParentId = Object.assign({}, state.isLoadingByParentId);
      if (parentId) {
        isLoadingByParentId[parentId] = true;
      }

      return {
        ...state,
        isLoading: true,
        isLoadingByParentId,
      };
    },

    [ACTIONS.COMMENT_LIST_COMPLETED]: (state: CommentsState, action: any) => {
      const {
        comments,
        parentId,
        totalItems,
        totalFilteredItems,
        totalPages,
        claimId,
        uri,
        disabled,
        commenterClaimId,
      } = action.data;

      const commentById = Object.assign({}, state.commentById);
      const byId = Object.assign({}, state.byId);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById); // was byId {ClaimId -> [commentIds...]}
      const topLevelTotalCommentsById = Object.assign({}, state.topLevelTotalCommentsById);
      const topLevelTotalPagesById = Object.assign({}, state.topLevelTotalPagesById);
      const commentsByUri = Object.assign({}, state.commentsByUri);
      const repliesByParentId = Object.assign({}, state.repliesByParentId);
      const totalCommentsById = Object.assign({}, state.totalCommentsById);
      const pinnedCommentsById = Object.assign({}, state.pinnedCommentsById);
      const repliesTotalPagesByParentId = Object.assign({}, state.repliesTotalPagesByParentId);
      const isLoadingByParentId = Object.assign({}, state.isLoadingByParentId);
      const settingsByChannelId = Object.assign({}, state.settingsByChannelId);

      settingsByChannelId[commenterClaimId] = {
        ...(settingsByChannelId[commenterClaimId] || {}),
        comments_enabled: !disabled,
      };

      if (parentId) {
        isLoadingByParentId[parentId] = false;
      }

      if (!disabled) {
        if (parentId) {
          repliesTotalPagesByParentId[parentId] = totalPages;
        } else {
          totalCommentsById[claimId] = totalItems;
          topLevelTotalCommentsById[claimId] = totalFilteredItems;
          topLevelTotalPagesById[claimId] = totalPages;
        }

        const commonUpdateAction = (comment, commentById, commentIds, index) => {
          // map the comment_ids to the new comments
          commentById[comment.comment_id] = comment;
          commentIds[index] = comment.comment_id;
        };

        if (comments) {
          // we use an Array to preserve order of listing
          // in reality this doesn't matter and we can just
          // sort comments by their timestamp
          const commentIds = Array(comments.length);

          // --- Top-level comments ---
          if (!parentId) {
            for (let i = 0; i < comments.length; ++i) {
              const comment = comments[i];
              commonUpdateAction(comment, commentById, commentIds, i);
              if (comment.is_pinned) {
                pushToArrayInObject(pinnedCommentsById, claimId, comment.comment_id);
              } else {
                pushToArrayInObject(topLevelCommentsById, claimId, comment.comment_id);
              }
            }
          }
          // --- Replies ---
          else {
            for (let i = 0; i < comments.length; ++i) {
              const comment = comments[i];
              commonUpdateAction(comment, commentById, commentIds, i);
              pushToArrayInObject(repliesByParentId, parentId, comment.comment_id);
            }
          }

          byId[claimId] ? byId[claimId].push(...commentIds) : (byId[claimId] = commentIds);
          commentsByUri[uri] = claimId;
        }
      }

      return {
        ...state,
        topLevelCommentsById,
        topLevelTotalCommentsById,
        topLevelTotalPagesById,
        repliesByParentId,
        totalCommentsById,
        pinnedCommentsById,
        repliesTotalPagesByParentId,
        byId,
        commentById,
        commentsByUri,
        isLoading: false,
        isLoadingByParentId,
        settingsByChannelId,
      };
    },

    [ACTIONS.COMMENT_BY_ID_COMPLETED]: (state: CommentsState, action: any) => {
      const { comment, ancestors } = action.data;
      const claimId = comment.claim_id;

      const commentById = Object.assign({}, state.commentById);
      const byId = Object.assign({}, state.byId);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById); // was byId {ClaimId -> [commentIds...]}
      const topLevelTotalCommentsById = Object.assign({}, state.topLevelTotalCommentsById);
      const topLevelTotalPagesById = Object.assign({}, state.topLevelTotalPagesById);
      const pinnedCommentsById = Object.assign({}, state.pinnedCommentsById);
      const repliesByParentId = Object.assign({}, state.repliesByParentId);
      const linkedCommentAncestors = Object.assign({}, state.linkedCommentAncestors);

      const updateStore = (comment, commentById, byId, repliesByParentId, topLevelCommentsById) => {
        // 'comment.ByID' doesn't populate 'replies'. We should have at least 1
        // at the moment, and the correct value will populated by 'comment.List'.
        commentById[comment.comment_id] = { ...comment, replies: 1 };
        byId[claimId] ? byId[claimId].unshift(comment.comment_id) : (byId[claimId] = [comment.comment_id]);

        const parentId = comment.parent_id;
        if (comment.parent_id) {
          pushToArrayInObject(repliesByParentId, parentId, comment.comment_id);
        } else {
          if (comment.is_pinned) {
            pushToArrayInObject(pinnedCommentsById, claimId, comment.comment_id);
          } else {
            pushToArrayInObject(topLevelCommentsById, claimId, comment.comment_id);
          }
        }
      };

      updateStore(comment, commentById, byId, repliesByParentId, topLevelCommentsById);

      if (ancestors) {
        ancestors.forEach((ancestor) => {
          updateStore(ancestor, commentById, byId, repliesByParentId, topLevelCommentsById);
          pushToArrayInObject(linkedCommentAncestors, comment.comment_id, ancestor.comment_id);
        });
      }

      return {
        ...state,
        topLevelCommentsById,
        topLevelTotalCommentsById,
        topLevelTotalPagesById,
        pinnedCommentsById,
        repliesByParentId,
        byId,
        commentById,
        linkedCommentAncestors,
      };
    },

    [ACTIONS.COMMENT_SUPER_CHAT_LIST_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isLoading: false,
    }),
    [ACTIONS.COMMENT_SUPER_CHAT_LIST_STARTED]: (state) => ({ ...state, isLoading: true }),

    [ACTIONS.COMMENT_SUPER_CHAT_LIST_COMPLETED]: (state: CommentsState, action: any) => {
      const { comments, totalAmount, uri } = action.data;

      return {
        ...state,
        superChatsByUri: {
          ...state.superChatsByUri,
          [uri]: {
            comments,
            totalAmount,
          },
        },
        isLoading: false,
      };
    },

    [ACTIONS.COMMENT_LIST_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isLoading: false,
    }),

    [ACTIONS.COMMENT_LIST_RESET]: (state: CommentsState, action: any) => {
      const { claimId } = action.data;

      const byId = Object.assign({}, state.byId);
      const totalCommentsById = Object.assign({}, state.totalCommentsById);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById); // was byId {ClaimId -> [commentIds...]}
      const topLevelTotalCommentsById = Object.assign({}, state.topLevelTotalCommentsById);
      const topLevelTotalPagesById = Object.assign({}, state.topLevelTotalPagesById);
      const pinnedCommentsById = Object.assign({}, state.pinnedCommentsById);
      const myReacts = Object.assign({}, state.myReactsByCommentId);
      const othersReacts = Object.assign({}, state.othersReactsByCommentId);

      function deleteReacts(reactObj, commentIdsToRemove) {
        if (commentIdsToRemove && commentIdsToRemove.length > 0) {
          let reactionKeys = Object.keys(reactObj);
          reactionKeys.forEach((rk) => {
            const colonIndex = rk.indexOf(':');
            const commentId = colonIndex === -1 ? rk : rk.substring(0, colonIndex);
            if (commentIdsToRemove.includes(commentId)) {
              delete reactObj[rk];
            }
          });
        }
      }

      deleteReacts(myReacts, byId[claimId]);
      deleteReacts(othersReacts, byId[claimId]);

      delete byId[claimId];
      delete totalCommentsById[claimId];
      delete topLevelCommentsById[claimId];
      delete topLevelTotalCommentsById[claimId];
      delete topLevelTotalPagesById[claimId];
      delete pinnedCommentsById[claimId];

      return {
        ...state,
        byId,
        totalCommentsById,
        topLevelCommentsById,
        topLevelTotalCommentsById,
        topLevelTotalPagesById,
        pinnedCommentsById,
        myReactsByCommentId: myReacts,
        othersReactsByCommentId: othersReacts,
      };
    },

    [ACTIONS.COMMENT_RECEIVED]: (state: CommentsState, action: any) => {
      const { uri, claimId, comment } = action.data;
      const commentsByUri = Object.assign({}, state.commentsByUri);
      const commentsByClaimId = Object.assign({}, state.byId);
      const allCommentsById = Object.assign({}, state.commentById);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById);
      const superChatsByUri = Object.assign({}, state.superChatsByUri);
      const commentsForId = topLevelCommentsById[claimId];

      allCommentsById[comment.comment_id] = comment;
      commentsByUri[uri] = claimId;

      if (commentsForId) {
        const newCommentsForId = commentsForId.slice();
        const commentExists = newCommentsForId.includes(comment.comment_id);
        if (!commentExists) {
          newCommentsForId.unshift(comment.comment_id);
        }

        topLevelCommentsById[claimId] = newCommentsForId;
      } else {
        topLevelCommentsById[claimId] = [comment.comment_id];
      }

      // We don't care to keep existing lower level comments since this is just for livestreams
      commentsByClaimId[claimId] = topLevelCommentsById[claimId];

      if (comment.support_amount > 0) {
        const superChatForUri = superChatsByUri[uri];
        const superChatCommentsForUri = superChatForUri && superChatForUri.comments;

        let sortedSuperChatComments = [];
        let hasAddedNewComment = false;
        if (superChatCommentsForUri && superChatCommentsForUri.length > 0) {
          // Go for the entire length of superChatCommentsForUri since a comment will be added to this list
          for (var i = 0; i < superChatCommentsForUri.length; i++) {
            const existingSuperChat = superChatCommentsForUri[i];
            if (existingSuperChat.support_amount < comment.support_amount && !hasAddedNewComment) {
              hasAddedNewComment = true;
              sortedSuperChatComments.push(comment);
              sortedSuperChatComments.push(existingSuperChat);
            } else {
              sortedSuperChatComments.push(existingSuperChat);
            }

            // If the new superchat hasn't been added yet, it must be the smallest superchat in the list
            if (
              i === superChatCommentsForUri.length - 1 &&
              sortedSuperChatComments.length === superChatCommentsForUri.length
            ) {
              sortedSuperChatComments.push(comment);
            }
          }

          superChatsByUri[uri].comments = sortedSuperChatComments;
          superChatsByUri[uri].totalAmount += comment.support_amount;
        } else {
          superChatsByUri[uri] = { comments: [comment], totalAmount: comment.support_amount };
        }
      }

      return {
        ...state,
        byId: commentsByClaimId,
        commentById: allCommentsById,
        commentsByUri,
        topLevelCommentsById,
        superChatsByUri,
      };
    },

    [ACTIONS.COMMENT_ABANDON_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      isLoading: true,
    }),
    [ACTIONS.COMMENT_ABANDON_COMPLETED]: (state: CommentsState, action: any) => {
      const { comment_id } = action.data;
      const commentById = Object.assign({}, state.commentById);
      const byId = Object.assign({}, state.byId);
      const repliesByParentId = Object.assign({}, state.repliesByParentId); // {ParentCommentID -> [commentIds...] } list of reply comments
      const totalCommentsById = Object.assign({}, state.totalCommentsById);

      const comment = commentById[comment_id];

      // to remove the comment and its references
      const claimId = comment.claim_id;
      for (let i = 0; i < byId[claimId].length; i++) {
        if (byId[claimId][i] === comment_id) {
          byId[claimId].splice(i, 1);
          break;
        }
      }

      // Update replies
      if (comment['parent_id'] && repliesByParentId[comment.parent_id]) {
        const index = repliesByParentId[comment.parent_id].indexOf(comment.comment_id);
        if (index > -1) {
          repliesByParentId[comment.parent_id].splice(index, 1);

          if (commentById[comment.parent_id]) {
            commentById[comment.parent_id].replies = Math.max(0, (commentById[comment.parent_id].replies || 0) - 1);
          }
        }
      }

      if (totalCommentsById[claimId]) {
        totalCommentsById[claimId] = Math.max(0, totalCommentsById[claimId] - 1);
      }

      delete commentById[comment_id];

      return {
        ...state,
        commentById,
        byId,
        totalCommentsById,
        repliesByParentId,
        isLoading: false,
      };
    },

    [ACTIONS.COMMENT_ABANDON_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isCommenting: false,
    }),
    [ACTIONS.COMMENT_UPDATE_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      isCommenting: true,
    }),
    [ACTIONS.COMMENT_UPDATE_COMPLETED]: (state: CommentsState, action: any) => {
      const { comment } = action.data;
      const commentById = Object.assign({}, state.commentById);
      commentById[comment.comment_id] = comment;

      return {
        ...state,
        commentById,
        isCommenting: false,
      };
    },
    [ACTIONS.COMMENT_UPDATE_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      isCmmenting: false,
    }),

    [ACTIONS.COMMENT_PIN_COMPLETED]: (state: CommentsState, action: any) => {
      const { pinnedComment, claimId, unpin } = action.data;
      const commentById = Object.assign({}, state.commentById);
      const topLevelCommentsById = Object.assign({}, state.topLevelCommentsById);
      const pinnedCommentsById = Object.assign({}, state.pinnedCommentsById);

      if (pinnedComment) {
        if (topLevelCommentsById[claimId]) {
          const index = topLevelCommentsById[claimId].indexOf(pinnedComment.comment_id);
          if (index > -1) {
            topLevelCommentsById[claimId].splice(index, 1);
          }
        } else {
          topLevelCommentsById[claimId] = [];
        }

        if (pinnedCommentsById[claimId]) {
          const index = pinnedCommentsById[claimId].indexOf(pinnedComment.comment_id);
          if (index > -1) {
            pinnedCommentsById[claimId].splice(index, 1);
          }
        } else {
          pinnedCommentsById[claimId] = [];
        }

        if (unpin) {
          // Without the sort score, I have no idea where to put it. Just
          // dump it at the top. Users can refresh if they want it back to
          // the correct sorted position.
          topLevelCommentsById[claimId].unshift(pinnedComment.comment_id);
        } else {
          pinnedCommentsById[claimId].unshift(pinnedComment.comment_id);
        }

        if (commentById[pinnedComment.comment_id]) {
          // Commentron's `comment.Pin` response places the creator's credentials
          // in the 'channel_*' fields, which doesn't make sense. Maybe it is to
          // show who signed/pinned it, but even if so, it shouldn't overload
          // these variables which are already used by existing comment data structure.
          // Ensure we don't override the existing/correct values, but fallback
          // to whatever was given.
          const { channel_id, channel_name, channel_url } = commentById[pinnedComment.comment_id];
          commentById[pinnedComment.comment_id] = {
            ...pinnedComment,
            channel_id: channel_id || pinnedComment.channel_id,
            channel_name: channel_name || pinnedComment.channel_name,
            channel_url: channel_url || pinnedComment.channel_url,
          };
        } else {
          commentById[pinnedComment.comment_id] = pinnedComment;
        }
      }

      return {
        ...state,
        commentById,
        topLevelCommentsById,
        pinnedCommentsById,
      };
    },

    [ACTIONS.COMMENT_MODERATION_BLOCK_LIST_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationBlockList: true,
    }),
    [ACTIONS.COMMENT_MODERATION_BLOCK_LIST_COMPLETED]: (state: CommentsState, action: any) => {
      const { personalBlockList, adminBlockList, moderatorBlockList, moderatorBlockListDelegatorsMap } = action.data;

      return {
        ...state,
        moderationBlockList: personalBlockList,
        adminBlockList: adminBlockList,
        moderatorBlockList: moderatorBlockList,
        moderatorBlockListDelegatorsMap: moderatorBlockListDelegatorsMap,
        fetchingModerationBlockList: false,
      };
    },
    [ACTIONS.COMMENT_MODERATION_BLOCK_LIST_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationBlockList: false,
    }),

    [ACTIONS.COMMENT_MODERATION_BLOCK_STARTED]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;

      switch (blockLevel) {
        default:
        case BLOCK_LEVEL.SELF:
        case BLOCK_LEVEL.ADMIN:
          return {
            ...state,
            blockingByUri: {
              ...state.blockingByUri,
              [blockedUri]: true,
            },
          };

        case BLOCK_LEVEL.MODERATOR:
          const newMap = Object.assign({}, state.togglingForDelegatorMap);
          const togglingDelegatorsForBlockedUri = newMap[blockedUri];
          if (togglingDelegatorsForBlockedUri) {
            if (!togglingDelegatorsForBlockedUri.includes(creatorUri)) {
              togglingDelegatorsForBlockedUri.push(creatorUri);
            }
          } else {
            newMap[blockedUri] = [creatorUri];
          }

          return {
            ...state,
            togglingForDelegatorMap: newMap,
          };
      }
    },

    [ACTIONS.COMMENT_MODERATION_UN_BLOCK_STARTED]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;

      switch (blockLevel) {
        default:
        case BLOCK_LEVEL.SELF:
        case BLOCK_LEVEL.ADMIN:
          return {
            ...state,
            unBlockingByUri: {
              ...state.unBlockingByUri,
              [blockedUri]: true,
            },
          };

        case BLOCK_LEVEL.MODERATOR:
          const newMap = Object.assign({}, state.togglingForDelegatorMap);
          const togglingDelegatorsForBlockedUri = newMap[blockedUri];
          if (togglingDelegatorsForBlockedUri) {
            if (!togglingDelegatorsForBlockedUri.includes(creatorUri)) {
              togglingDelegatorsForBlockedUri.push(creatorUri);
            }
          } else {
            newMap[blockedUri] = [creatorUri];
          }

          return {
            ...state,
            togglingForDelegatorMap: newMap,
          };
      }
    },

    [ACTIONS.COMMENT_MODERATION_BLOCK_FAILED]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;

      switch (blockLevel) {
        default:
        case BLOCK_LEVEL.SELF:
        case BLOCK_LEVEL.ADMIN:
          return {
            ...state,
            blockingByUri: {
              ...state.blockingByUri,
              [blockedUri]: false,
            },
          };

        case BLOCK_LEVEL.MODERATOR:
          const newMap = Object.assign({}, state.togglingForDelegatorMap);
          const togglingDelegatorsForBlockedUri = newMap[blockedUri];
          if (togglingDelegatorsForBlockedUri) {
            newMap[blockedUri] = togglingDelegatorsForBlockedUri.filter((x) => x !== creatorUri);
          }

          return {
            ...state,
            togglingForDelegatorMap: newMap,
          };
      }
    },

    [ACTIONS.COMMENT_MODERATION_UN_BLOCK_FAILED]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;

      switch (blockLevel) {
        default:
        case BLOCK_LEVEL.SELF:
        case BLOCK_LEVEL.ADMIN:
          return {
            ...state,
            unBlockingByUri: {
              ...state.unBlockingByUri,
              [blockedUri]: false,
            },
          };

        case BLOCK_LEVEL.MODERATOR:
          const newMap = Object.assign({}, state.togglingForDelegatorMap);
          const togglingDelegatorsForBlockedUri = newMap[blockedUri];
          if (togglingDelegatorsForBlockedUri) {
            newMap[blockedUri] = togglingDelegatorsForBlockedUri.filter((x) => x !== creatorUri);
          }

          return {
            ...state,
            togglingForDelegatorMap: newMap,
          };
      }
    },

    [ACTIONS.COMMENT_MODERATION_BLOCK_COMPLETE]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;
      const commentById = Object.assign({}, state.commentById);
      const blockingByUri = Object.assign({}, state.blockingByUri);

      for (const commentId in commentById) {
        const comment = commentById[commentId];

        if (isURIEqual(blockedUri, comment.channel_url)) {
          delete commentById[comment.comment_id];
        }
      }

      switch (blockLevel) {
        case BLOCK_LEVEL.SELF: {
          const blockList = state.moderationBlockList || [];
          const newBlockList = blockList.slice();
          newBlockList.push(blockedUri);
          delete blockingByUri[blockedUri];

          return {
            ...state,
            commentById,
            blockingByUri,
            moderationBlockList: newBlockList,
          };
        }

        case BLOCK_LEVEL.MODERATOR: {
          const blockList = state.moderatorBlockList || [];
          const newBlockList = blockList.slice();

          // Update main block list
          if (!newBlockList.includes(blockedUri)) {
            newBlockList.push(blockedUri);
          }

          // Update list of delegators
          const moderatorBlockListDelegatorsMap = Object.assign({}, state.moderatorBlockListDelegatorsMap);
          const delegatorUrisForBlockedUri = moderatorBlockListDelegatorsMap[blockedUri];
          if (delegatorUrisForBlockedUri) {
            if (!delegatorUrisForBlockedUri.includes(creatorUri)) {
              delegatorUrisForBlockedUri.push(creatorUri);
            }
          } else {
            moderatorBlockListDelegatorsMap[blockedUri] = [creatorUri];
          }

          // Remove "toggling" flag
          const togglingMap = Object.assign({}, state.togglingForDelegatorMap);
          const togglingDelegatorsForBlockedUri = togglingMap[blockedUri];
          if (togglingDelegatorsForBlockedUri) {
            togglingMap[blockedUri] = togglingDelegatorsForBlockedUri.filter((x) => x !== creatorUri);
          }

          return {
            ...state,
            commentById,
            moderatorBlockList: newBlockList,
            moderatorBlockListDelegatorsMap,
            togglingForDelegatorMap: togglingMap,
          };
        }

        case BLOCK_LEVEL.ADMIN:
          const blockList = state.adminBlockList || [];
          const newBlockList = blockList.slice();
          newBlockList.push(blockedUri);
          delete blockingByUri[blockedUri];

          return {
            ...state,
            commentById,
            blockingByUri,
            adminBlockList: newBlockList,
          };
      }
    },
    [ACTIONS.COMMENT_MODERATION_UN_BLOCK_COMPLETE]: (state: CommentsState, action: any) => {
      const { blockedUri, creatorUri, blockLevel } = action.data;
      const unBlockingByUri = Object.assign(state.unBlockingByUri, {});

      switch (blockLevel) {
        case BLOCK_LEVEL.SELF: {
          const blockList = state.moderationBlockList || [];
          delete unBlockingByUri[blockedUri];
          return {
            ...state,
            unBlockingByUri,
            moderationBlockList: blockList.slice().filter((uri) => uri !== blockedUri),
          };
        }

        case BLOCK_LEVEL.ADMIN: {
          const blockList = state.adminBlockList || [];
          delete unBlockingByUri[blockedUri];
          return {
            ...state,
            unBlockingByUri,
            adminBlockList: blockList.slice().filter((uri) => uri !== blockedUri),
          };
        }

        case BLOCK_LEVEL.MODERATOR: {
          const blockList = state.moderatorBlockList || [];
          const newBlockList = blockList.slice();
          const togglingMap = Object.assign({}, state.togglingForDelegatorMap);

          const moderatorBlockListDelegatorsMap = Object.assign({}, state.moderatorBlockListDelegatorsMap);
          const delegatorUrisForBlockedUri = moderatorBlockListDelegatorsMap[blockedUri];
          if (delegatorUrisForBlockedUri) {
            const index = delegatorUrisForBlockedUri.indexOf(creatorUri);
            if (index > -1) {
              // Remove from delegators list
              delegatorUrisForBlockedUri.splice(index, 1);

              // // Remove blocked entry if it was removed for all delegators
              // if (delegatorUrisForBlockedUri.length === 0) {
              //   delete moderatorBlockListDelegatorsMap[blockedUri];
              //   newBlockList = newBlockList.filter((uri) => uri !== blockedUri);
              // }

              // Remove from "toggling" flag
              const togglingDelegatorsForBlockedUri = togglingMap[blockedUri];
              if (togglingDelegatorsForBlockedUri) {
                togglingMap[blockedUri] = togglingDelegatorsForBlockedUri.filter((x) => x !== creatorUri);
              }
            }
          }

          return {
            ...state,
            moderatorBlockList: newBlockList,
            togglingForDelegatorMap: togglingMap,
          };
        }
      }
    },

    [ACTIONS.COMMENT_FETCH_MODERATION_DELEGATES_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationDelegates: true,
    }),
    [ACTIONS.COMMENT_FETCH_MODERATION_DELEGATES_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationDelegates: false,
    }),
    [ACTIONS.COMMENT_FETCH_MODERATION_DELEGATES_COMPLETED]: (state: CommentsState, action: any) => {
      const moderationDelegatesById = Object.assign({}, state.moderationDelegatesById);
      if (action.data.delegates) {
        moderationDelegatesById[action.data.id] = action.data.delegates.map((delegate) => {
          return {
            channelId: delegate.channel_id,
            channelName: delegate.channel_name,
          };
        });
      } else {
        moderationDelegatesById[action.data.id] = [];
      }

      return {
        ...state,
        fetchingModerationDelegates: false,
        moderationDelegatesById: moderationDelegatesById,
      };
    },

    [ACTIONS.COMMENT_MODERATION_AM_I_LIST_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationDelegators: true,
    }),

    [ACTIONS.COMMENT_MODERATION_AM_I_LIST_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingModerationDelegators: true,
    }),

    [ACTIONS.COMMENT_MODERATION_AM_I_LIST_COMPLETED]: (state: CommentsState, action: any) => {
      return {
        ...state,
        fetchingModerationDelegators: true,
        moderationDelegatorsById: action.data,
      };
    },

    [ACTIONS.COMMENT_FETCH_SETTINGS_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingSettings: true,
    }),
    [ACTIONS.COMMENT_FETCH_SETTINGS_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingSettings: false,
    }),
    [ACTIONS.COMMENT_FETCH_SETTINGS_COMPLETED]: (state: CommentsState, action: any) => {
      const { channelId, settings, partialUpdate } = action.data;
      const settingsByChannelId = Object.assign({}, state.settingsByChannelId);

      if (partialUpdate) {
        settingsByChannelId[channelId] = {
          // The existing may contain additional Creator Settings (e.g. 'words')
          ...(settingsByChannelId[channelId] || {}),
          // Spread new settings.
          ...settings,
        };
      } else {
        settingsByChannelId[channelId] = settings;
        if (settings.words) {
          settingsByChannelId[channelId].words = settings.words.split(',');
        }
      }

      return {
        ...state,
        settingsByChannelId,
        fetchingSettings: false,
      };
    },

    [ACTIONS.COMMENT_FETCH_BLOCKED_WORDS_STARTED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingBlockedWords: true,
    }),
    [ACTIONS.COMMENT_FETCH_BLOCKED_WORDS_FAILED]: (state: CommentsState, action: any) => ({
      ...state,
      fetchingBlockedWords: false,
    }),
    [ACTIONS.COMMENT_FETCH_BLOCKED_WORDS_COMPLETED]: (state: CommentsState, action: any) => {
      const blockedWordsByChannelId = action.data;
      const settingsByChannelId = Object.assign({}, state.settingsByChannelId);

      // blockedWordsByChannelId: {string: [string]}
      Object.entries(blockedWordsByChannelId).forEach((x) => {
        const channelId = x[0];
        if (!settingsByChannelId[channelId]) {
          settingsByChannelId[channelId] = {};
        }
        settingsByChannelId[channelId].words = x[1];
      });

      return {
        ...state,
        settingsByChannelId,
        fetchingBlockedWords: false,
      };
    },
  },
  defaultState
);