import { Context } from '../../../utils';
import { ACTION_LOGGER } from './../../logger';
import { pubsub } from '..';
import { COMMENT_ADDED, COMMENT_REMOVED, COMMENT_UPDATED } from './../Subscription/comment';
import { NotificationTypeEnum } from '../../../entity/Notification';
import { NOTIFICATION_ADDED } from '../Subscription/notification';

export default {
  /**
   * Adds new comment.
   *
   * @param _ Parent.
   * @param params The parameters.
   * @param context The context.
   */
  async addComment(_, { action_id, content, attachments }, context: Context) {
    try {
      ACTION_LOGGER.log({
        level: 'info',
        message: `Add new comment ${action_id}, user=${context.loggedUser.email}`,
      });
      const user = await context.user.findOne(context.userLogin);
      const action = await context.action.findOne(action_id, { relations: ['creator'] });
      if (!action) {
        throw new Error('ACTION_NOT_FOUND');
      }

      const addedComment = await context.comment.addComment(user, action, content);

      if (attachments) {
        await Promise.all(
          attachments.map((attachment: any) =>
            context.attachment.addAttachment(
              context.loggedUser,
              addedComment,
              attachment.size,
              attachment.type,
              attachment.path,
              attachment.name,
            ),
          ),
        );
      }

      pubsub.publish(COMMENT_ADDED, { commentAdded: addedComment });


      action.assignments.map(async assignment => {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: assignment.to,
          type: NotificationTypeEnum.CREATE_COMMENT,
          content: action.id.toString(),
          message: `Comment updated on action: "${action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      });


      // add a new Notification when a new Comment is added
      if (action.creator.id !== context.loggedUser.id) {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: action.creator,
          type: NotificationTypeEnum.CREATE_COMMENT,
          content: action.id.toString(),
          message: `Comment added on action: "${action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      }
      return addedComment;
    } catch (error) {
      ACTION_LOGGER.log({
        level: 'error',
        message: `Add comment error= ${error.message}, action_id=${action_id}, user=${
          context.loggedUser.email
          }`,
      });
      return error;
    }
  },

  /**
   * Removes a comment.
   *
   * @param _ Parent.
   * @param params The parameters.
   * @param context The context.
   */
  async removeComment(_, { id }, context: Context) {
    try {
      ACTION_LOGGER.log({ level: 'info', message: `Remove comment id=${id}` });
      const comment = await context.comment.findOne(id, {
        relations: ['action', 'action.creator', 'user'],
      });
      if (!comment) {
        throw new Error('COMMENT_NOT_FOUND');
      }

      comment.removed = 1;
      await context.comment.save(comment);

      pubsub.publish(COMMENT_REMOVED, { commentRemoved: comment });

      comment.action.assignments.map(async assignment => {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: assignment.to,
          type: NotificationTypeEnum.REMOVE_COMMENT,
          content: comment.action.id.toString(),
          message: `Comment updated on action: "${comment.action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      });

      // add a new Notification when a new Comment is removed
      if (comment.action.creator.id !== context.loggedUser.id) {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: comment.action.creator,
          type: NotificationTypeEnum.REMOVE_COMMENT,
          content: comment.action.id.toString(),
          message: `Comment removed on action: "${comment.action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      }

      return comment;
    } catch (error) {
      ACTION_LOGGER.log({
        level: 'error',
        message: `Remove comment error=${error.message}, id=${id}`,
      });
      return error;
    }
  },

  /**
   * Update a comment.
   *
   * @param _ Parent.
   * @param params The parameters.
   * @param context The context.
   */
  async updateComment(_, { id, content }, context: Context) {
    try {
      ACTION_LOGGER.info({ level: 'info', message: `Update comment id=${id}` });
      const commentUpdated = await context.comment.editComment(context.userLogin, id, content);
      const comment = await context.comment.findOne(id, {
        relations: ['user', 'action', 'action.creator'],
      });
      pubsub.publish(COMMENT_UPDATED, { commentUpdated });

      comment.action.assignments.map(async assignment => {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: assignment.to,
          type: NotificationTypeEnum.UPDATE_COMMENT,
          content: comment.action.id.toString(),
          message: `Comment updated on action: "${comment.action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      });

      // add a new Notification when a Comment is updated
      if (comment.action.creator.id !== context.loggedUser.id) {
        const notification = await context.notification.addNotification({
          from: context.loggedUser,
          to: comment.action.creator,
          type: NotificationTypeEnum.UPDATE_COMMENT,
          content: comment.action.id.toString(),
          message: `Comment updated on action: "${comment.action.description}"`,
        });
        pubsub.publish(NOTIFICATION_ADDED, { notificationAdded: notification });
      }

      return commentUpdated;
    } catch (error) {
      ACTION_LOGGER.log({
        level: 'error',
        message: `Update comment error=${error.message}, id=${id}`,
      });
      return error;
    }
  },

  /**
   * Update a comment to add user that seen it.
   *
   * @param _ Parent.
   * @param params The parameters.
   * @param context The context.
   */
  async updateAllCommentToSeen(_, { actionId }, context: Context) {
    try {
      ACTION_LOGGER.info({
        level: 'info',
        message: `Update action's comment as seen id=${actionId}`,
      });
      const actionUpdated = await context.comment.updateAllCommentToSeen(
        context.userLogin,
        actionId,
        context,
      );
      return actionUpdated;
    } catch (error) {
      ACTION_LOGGER.log({
        level: 'error',
        message: `Update comment error=${error.message}, id=${actionId}`,
      });
      return error;
    }
  },
};