package com.epam.uc.calendar.service;

import static com.epam.uc.calendar.auth.verifier.role.RoleAccessInspector.getCurrentUser;

import com.epam.uc.calendar.auth.AuthUser;
import com.epam.uc.calendar.auth.verifier.FlowInspector;
import com.epam.uc.calendar.client.AttachmentServiceClient;
import com.epam.uc.calendar.database.criteria.EventCriteriaBuilder;
import com.epam.uc.calendar.database.model.BaseEntity;
import com.epam.uc.calendar.database.model.Event;
import com.epam.uc.calendar.database.model.EventApproval;
import com.epam.uc.calendar.database.model.EventAttendee;
import com.epam.uc.calendar.database.model.Image;
import com.epam.uc.calendar.database.model.User;
import com.epam.uc.calendar.database.model.UserEvent;
import com.epam.uc.calendar.database.repository.EventApprovalRepository;
import com.epam.uc.calendar.database.repository.EventRepository;
import com.epam.uc.calendar.database.repository.ImageRepository;
import com.epam.uc.calendar.database.repository.UserRepository;
import com.epam.uc.calendar.database.sample.EventPaginationObject;
import com.epam.uc.calendar.database.sample.EventSampleObject;
import com.epam.uc.calendar.dto.PromotedStatusDto;
import com.epam.uc.calendar.outlook.model.OutlookResponse;
import com.epam.uc.calendar.outlook.service.OutlookService;
import com.epam.uc.event.model.EventState;
import com.epam.uc.event.model.UserResponse;
import com.epam.uc.event.model.UserType;
import com.epam.uc.event.model.dto.EventApprovalDto;
import com.epam.uc.event.model.dto.EventDto;
import com.epam.uc.event.model.dto.FileInfoDto;
import com.epam.uc.event.model.dto.UserDto;
import com.epam.uc.outlook.model.OutlookMessageDto;
import com.epam.uc.template.model.MailDraftDto;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
@Slf4j
public class EventService {

  private static final Integer DEFAULT_PAGE_SIZE = 10;

  private final EventRepository eventRepository;
  private final UserRepository userRepository;
  private final EventApprovalRepository approvalRepository;
  private final EntityManager entityManager;
  private final ImageRepository imageRepository;
  private final EventManager eventManager;
  private final FlowInspector flowInspector;
  private final OutlookService outlookService;
  private final RealTemplateService realTemplateService;
  private final ModelMapper modelMapper;
  private final AttachmentServiceClient attachmentServiceClient;

  @Autowired
  public EventService(EventRepository eventRepository,
                      UserRepository userRepository,
                      EventApprovalRepository approvalRepository,
                      EntityManager entityManager,
                      ImageRepository imageRepository,
                      EventManager eventManager,
                      FlowInspector flowInspector,
                      OutlookService outlookService,
                      RealTemplateService realTemplateService,
                      ModelMapper modelMapper,
                      AttachmentServiceClient attachmentServiceClient) {
    this.eventRepository = eventRepository;
    this.userRepository = userRepository;
    this.approvalRepository = approvalRepository;
    this.entityManager = entityManager;
    this.imageRepository = imageRepository;
    this.eventManager = eventManager;
    this.flowInspector = flowInspector;
    this.outlookService = outlookService;
    this.realTemplateService = realTemplateService;
    this.modelMapper = modelMapper;
    this.attachmentServiceClient = attachmentServiceClient;
  }

  public EventDto processEventApproval(@NonNull MailDraftDto mailDraftDto) {
    EventDto eventDto = new EventDto();
    if (isEmpty(mailDraftDto)) {
      eventDto = approveEvent(mailDraftDto);
    } else if (isNotEmpty(mailDraftDto)) {
      realTemplateService.update(mailDraftDto, mailDraftDto.getEventId());
      eventDto = approveEvent(mailDraftDto);
    }
    return eventDto;
  }

  private boolean isNotEmpty(@NonNull MailDraftDto mailDraftDto) {
    return mailDraftDto.getEventId() != null && mailDraftDto.getRecipients() != null
        && mailDraftDto.getText() != null && mailDraftDto.getImageUrl() != null
        && mailDraftDto.getTemplate() != null;
  }

  private boolean isEmpty(@NonNull MailDraftDto mailDraftDto) {
    return mailDraftDto.getTemplate() == null && mailDraftDto.getText() == null
        && mailDraftDto.getImageUrl() == null && mailDraftDto.getRecipients() == null
        && mailDraftDto.getEventId() != null;
  }


  public Event findOne(@NonNull Long eventId) {
    Event event = eventManager.buildEventWithPopulatedUsersData(eventRepository.findOne(eventId));

    if (event == null) {
      throw new EntityNotFoundException(String.format("No event with id: %d", eventId));
    }

    return event;
  }

  public List<Event> getAllEvents(EventSampleObject sampleObject,
                                  EventPaginationObject paginationObject) {

    EventCriteriaBuilder eventCriteriaBuilder = new EventCriteriaBuilder(entityManager);

    List<Event> resultList = null;
    AuthUser authUser = getCurrentUser();
    String userEmail = authUser.getEmail()
                               .toLowerCase();

    switch (authUser.getRole()) {
      case ROLE_ADMIN:
        resultList = eventCriteriaBuilder.getAllAdminEvents(sampleObject, paginationObject);
        break;
      case ROLE_MODERATOR:
        Set<Long> availableLocations = authUser.getLocations();
        Set<Long> availableTypes = authUser.getTypes();
        resultList = eventCriteriaBuilder.getAllModeratorEvents(userEmail, sampleObject,
            paginationObject,
            availableLocations, availableTypes);
        break;
      case ROLE_REGULAR_USER:
        resultList = eventCriteriaBuilder.getAllRegularUserEvents(userEmail, sampleObject,
            paginationObject);
        break;
    }

    return eventManager.buildSetOfEventsWithPopulatedUsersData(resultList);
  }

  public List<Event> getModeratorPageEvents(EventSampleObject sampleObject,
                                            EventPaginationObject paginationObject) {
    return getAllEvents(sampleObject, paginationObject);
  }

  public List<Event> getAllMyEvents(EventSampleObject filterObject,
                                    EventPaginationObject eventPaginationObject) {

    AuthUser authUser = getCurrentUser();
    String userEmail = authUser.getEmail();

    if (userEmail == null) {
      return new ArrayList<>();
    }

    EventCriteriaBuilder eventCriteriaBuilder = new EventCriteriaBuilder(entityManager);

    List<Event> myEventsList = eventCriteriaBuilder.getAllMyEvent(userEmail.toLowerCase(),
        filterObject,
        eventPaginationObject);

    return eventManager.buildSetOfEventsWithPopulatedUsersData(myEventsList);
  }

  public Event createEvent(Event event) {
    resetIdForEntityCreationInHibernate(event);

    createAuthorAndSpeakerIfNotExists(event);

    setEventApproval(event, EventState.PROPOSED);

    Set<User> users = event.getAttendees()
                           .stream()
                           .map(EventAttendee::getUser)
                           .filter(Objects::nonNull)
                           .collect(Collectors.toSet());
    createUsersIfNotInDatabase(users);
    setUserEventsHibernateBindingsWithDefaultResponse(event);

    if (event.getImage() != null && event.getImage().getBytes().length != 0) {
      event = uploadEventImage(event);
    }

    return eventRepository.save(event);
  }

  private void updateOutlookResponseInEvent(Optional<EventAttendee> eventAttendee, Event event,
                                            OutlookResponse outlookResponse) {
    if (eventAttendee.isPresent()) {
      event.getAttendees()
           .stream()
           .filter(userFromEmail(outlookResponse.getUserEmail()))
           .forEach(a -> a.setOutlookResponse(outlookResponse.getResponse()));
    } else {
      log.info(
          String.format("Illegal answer from Outlook: user %s is not an attendee of an event %d",
              outlookResponse.getUserEmail(), event.getId()));
      throw new UnsupportedOperationException(
          "Not invited user should not be able to answer to the appointment in Outlook");
    }
    eventRepository.save(event);
  }

  private void updateOutlookResponseForUser(Long eventId, User user,
                                            OutlookResponse outlookResponse) {
    user.getUserEvents()
        .stream()
        .filter(a -> a.getEvent()
                      .getId()
                      .equals(eventId))
        .forEach(a -> a.setOutlookResponse(outlookResponse.getResponse()));
    userRepository.save(user);
  }

  public void updateOutlookResponse(Long eventId, OutlookResponse outlookResponse) {
    Event event = findOne(eventId);
    User user = userRepository.findByLinkIgnoreCase(outlookResponse.getUserEmail());

    if (user == null) {
      log.info(String.format("Illegal answer from Outlook: user %s is not registered",
          outlookResponse.getUserEmail()));
      throw new UnsupportedOperationException(
          "User should be registered in this application before he is invited to Outlook event");
    }

    Optional<EventAttendee> userEvent = event.getAttendees()
                                             .stream()
                                             .filter(userFromEmail(outlookResponse.getUserEmail()))
                                             .findFirst();
    updateOutlookResponseInEvent(userEvent, event, outlookResponse);
    updateOutlookResponseForUser(eventId, user, outlookResponse);
  }

  private void editAttendeeInOutlook(EventState eventApproval, UserEvent userEvent) {
    if (userEvent != null && eventApproval.equals(EventState.APPROVED)) {
      //TODO: add checks whether the user is in outlook event
      switch (userEvent.getUserResponse()) {
        case ACCEPTED:
        case TENTATIVE:
          outlookService.addAttendeeToEvent(userEvent);
          break;
        case DECLINED:
          outlookService.removeAttendeeFromEvent(userEvent);
          break;
        default:
          return;
      }
    }
  }

  private UserEvent updateUserResponseInEvent(Optional<EventAttendee> eventAttendee, User user,
                                              Event event, UserResponse userResponse) {
    UserEvent userEvent;
    AuthUser authUser = getCurrentUser();
    if (eventAttendee.isPresent()) {
      userEvent = (UserEvent) eventAttendee.get();
      event.getAttendees()
           .stream()
           .filter(userFromEmail(authUser.getEmail()))
           .forEach(a -> a.setUserResponse(userResponse));
    } else {
      flowInspector.checkCreateUserResponseFlow(event);
      userEvent = new UserEvent(event, user, userResponse);
      event.getAttendees()
           .add(userEvent);
    }
    eventRepository.save(event);
    return userEvent;
  }

  private void updateUserResponseForUser(Long eventId, User user,
                                         UserResponse userResponse) {
    user.getUserEvents()
        .stream()
        .filter(a -> a.getEvent()
                      .getId()
                      .equals(eventId))
        .forEach(a -> a.setUserResponse(userResponse));
    userRepository.save(user);
  }

  public UserEvent updateUserResponse(Long eventId, UserResponse newUserResponse) {
    Event event = findOne(eventId);
    AuthUser authUser = getCurrentUser();
    User user = userRepository.findByLinkIgnoreCase(authUser.getEmail());

    //TODO add call to user service (or telescope) to receive user info
    if (user == null) {
      user = new User(authUser.getName(), authUser.getEmail(), UserType.EPAMER, "", "");
      userRepository.save(user);
    }

    Optional<EventAttendee> eventAttendee = event.getAttendees()
                                                 .stream()
                                                 .filter(userFromEmail(authUser.getEmail()))
                                                 .findFirst();

    UserEvent result = updateUserResponseInEvent(eventAttendee, user, event, newUserResponse);
    updateUserResponseForUser(eventId, user, newUserResponse);
    editAttendeeInOutlook(event.getEventApproval()
                               .getName(), result);
    return result;
  }

  public UserEvent addAttendee(@NonNull Long eventId) {
    Event event = findOne(eventId);
    AuthUser authUser = getCurrentUser();

    Optional<EventAttendee> eventAttendee = event.getAttendees()
                                                 .stream()
                                                 .filter(userFromEmail(authUser.getEmail()))
                                                 .findFirst();

    if (!eventAttendee.isPresent()) {
      User user = userRepository.findByLinkIgnoreCase(authUser.getEmail());

      //TODO add call to user service (or telescope) to receive user info
      if (user == null) {
        user = new User(authUser.getName(), authUser.getEmail(), UserType.EPAMER, "", "");
        userRepository.save(user);
      }
      flowInspector.checkCreateUserResponseFlow(event);
      UserEvent userEvent = new UserEvent(event, user, UserResponse.NOT_RESPONDED);
      event.getAttendees()
           .add(userEvent);
      eventRepository.save(event);
      user.getUserEvents()
          .add(userEvent);
      userRepository.save(user);
      outlookService.addAttendeeToEvent(userEvent);
      return userEvent;
    }
    return (UserEvent) eventAttendee.get();
  }

  public void addNewAttendees(Long eventId, MailDraftDto mailDraftDto) {
    List<UserDto> expandedUsers = outlookService.expandMailboxes(
        new HashSet<>(mailDraftDto.getRecipients()))
                                                .stream()
                                                .map(outlookMailboxDto -> modelMapper.map(
                                                    outlookMailboxDto, UserDto.class))
                                                .collect(Collectors.toList());

    Event event = eventRepository.findOne(eventId);

    Set<String> attendeeLinks = event.getAttendees()
                                     .stream()
                                     .map(EventAttendee::getUser)
                                     .map(User::getLink)
                                     .map(String::toLowerCase)
                                     .collect(Collectors.toSet());

    expandedUsers.forEach(recipient -> {
      if (!attendeeLinks.contains(recipient.getEmail()
                                           .toLowerCase())) {
        User newAttendee = modelMapper.map(recipient, User.class);
        User userInRepository = userRepository.findByLinkIgnoreCase(newAttendee.getLink());

        if (userInRepository == null) {
          userRepository.saveAndFlush(newAttendee);
        } else {
          newAttendee = userInRepository;
        }

        event.addAttendee(newAttendee, UserResponse.NOT_RESPONDED);
      }
    });

    eventRepository.save(event);
  }

  public void removeAttendee(@NonNull Long eventId) {
    Event event = findOne(eventId);
    AuthUser authUser = getCurrentUser();
    User user = userRepository.findByLinkIgnoreCase(authUser.getEmail());

    //TODO add call to user service (or telescope) to receive user info
    if (user == null) {
      throw new UnsupportedOperationException("Cannot remove a non-existent user from event");
    }

    Optional<EventAttendee> eventAttendee = event.getAttendees()
                                                 .stream()
                                                 .filter(userFromEmail(authUser.getEmail()))
                                                 .findFirst();
    if (eventAttendee.isPresent()) {
      EventAttendee attendee = eventAttendee.get();
      event.getAttendees()
           .remove(attendee);
      eventRepository.save(event);
      user.getUserEvents().remove(attendee);
      userRepository.save(user);
      outlookService.removeAttendeeFromEvent((UserEvent) attendee);
    }
  }

  private void setEventLogo(Event event) {
    //FIXME remove this!!
    String logo = String.format("http://localhost:8080/calendar/events/%d/image", event.getId());
    event.setLogo(logo);
  }

  public UserResponse getCurrentStatus(long eventId) {
    Event event = findOne(eventId);
    AuthUser authUser = getCurrentUser();
    String userEmail = authUser.getEmail();

    return event.getAttendees()
                .stream()
                .filter(userFromEmail(userEmail))
                .map(EventAttendee::getUserResponse)
                .findFirst()
                .orElse(UserResponse.NOT_ATTENDEE);
  }

  private EventDto setAttachments(EventDto eventDto) {
    try {
      List<FileInfoDto> attachmentList = getAttachments(eventDto);

      eventDto.setAttachments(attachmentList);
    } catch (Exception e) {
      eventDto.setAttachments(Collections.emptyList());
    }
    return eventDto;
  }

  private List<FileInfoDto> getAttachments(EventDto eventDto) {
    return eventDto.getAttachmentIds().stream()
                   .map(attachmentId -> attachmentServiceClient
                       .getAttachmentsInfo(
                           attachmentId).getBody())
                   .collect(Collectors.toList());
  }

  public EventDto approveEvent(MailDraftDto mailDraftDto) {
    boolean eventExists = eventRepository.exists(mailDraftDto.getEventId());

    if (eventExists) {
      Event event = eventRepository.findOne(mailDraftDto.getEventId());
      setEventApproval(event, EventState.APPROVED);
      eventRepository.save(event);
      outlookService.createEvent(event, mailDraftDto);

      EventDto eventDto = modelMapper.map(event, EventDto.class);
      return setAttachments(eventDto);
    } else {
      throw new IllegalArgumentException("This event does not exist, you cannot approve it");
    }
  }

  private void setNotChangingValues(Event eventPassedToUpdate, Event eventFromDatabase) {
    eventPassedToUpdate.setEventApproval(eventFromDatabase.getEventApproval());
    eventPassedToUpdate.setAuthor(eventFromDatabase.getAuthor());
    eventPassedToUpdate.setId(eventFromDatabase.getId());
    if (eventFromDatabase.getEventApproval()
                         .getName()
                         .equals(EventState.APPROVED)) {
      eventPassedToUpdate.setType(eventFromDatabase.getType());
    }

    if (eventPassedToUpdate.getLocation() == null) {
      eventPassedToUpdate.setLocation(eventFromDatabase.getLocation());
    }

    if (eventPassedToUpdate.getCity() == null) {
      eventPassedToUpdate.setCity(eventFromDatabase.getCity());
    }

    if (eventPassedToUpdate.getName() == null) {
      eventPassedToUpdate.setName(eventFromDatabase.getName());
    }

    if (eventPassedToUpdate.getFullDescription() == null) {
      eventPassedToUpdate.setFullDescription(eventFromDatabase.getFullDescription());
    }

    if (eventPassedToUpdate.getType() == null) {
      eventPassedToUpdate.setType(eventFromDatabase.getType());
    }
    if (eventPassedToUpdate.getStartTime() == null || eventPassedToUpdate.getEndTime() == null) {
      eventFromDatabase.setStartTime(eventFromDatabase.getStartTime());
      eventFromDatabase.setEndTime(eventFromDatabase.getEndTime());
    }
  }

  public void deleteEvent(Long eventId) {
    if (!eventRepository.exists(eventId)) {
      throw new EntityNotFoundException("Entity doesn`t exist!");
    }

    eventRepository.delete(eventId);
  }


  Image getEventImage(Long eventId) {
    if (eventId == null) {
      throw new IllegalArgumentException("Cannot get an image for eventId = null");
    }
    // FIXME: 8/28/2017 Event selected to find image!!!
    return imageRepository.findByEventId(eventId);
  }

  public Set<EventAttendee> findAllEventAttendees(Long eventId) {
    return eventRepository.findOne(eventId)
                          .getAttendees();
  }

  public List<EventApprovalDto> findAllApprovals() {
    return approvalRepository.findAll().stream()
                             .map(x -> modelMapper.map(x, EventApprovalDto.class))
                             .collect(Collectors.toList());
  }

  private Event uploadEventImage(Event event) {
    imageRepository.deleteByEventId(event.getId());
    Image image = event.getImage();
    image.setEvent(event);
    imageRepository.save(image);
    event.setImage(null);
    eventRepository.save(event);
    setEventLogo(event);
    return event;
  }

  private void updateEventAttendees(Event event) {
    List<EventAttendee> attendees = new ArrayList<>(event.getAttendees());
    event.getAttendees()
         .clear();

    for (EventAttendee attendee : attendees) {
      event.addAttendee(attendee.getUser(), UserResponse.NOT_RESPONDED);
    }
  }

  private Predicate<EventAttendee> userFromEmail(String userEmail) {
    return eventAttendee -> eventAttendee.getUser().getLink().equalsIgnoreCase(userEmail);
  }

  private void createAuthorAndSpeakerIfNotExists(Event event) {
    User author = event.getAuthor();
    Set<User> speakers = event.getSpeakers();

    author.setLink(author.getLink()
                         .toLowerCase());
    speakers.forEach(speaker -> speaker.setLink(speaker.getLink()
                                                       .toLowerCase()));

    if (speakers.contains(author)) {
      speakers.add(author);
    } else {
      createUserIfNotInDatabase(author);
    }

    for (User speaker : event.getSpeakers()) {
      createUserIfNotInDatabase(speaker);
    }
  }

  private void createUserIfNotInDatabase(User user) {
    if (user == null) {
      return;
    }

    User persistedUser = userRepository.findByLinkIgnoreCase(user.getLink());

    if (persistedUser == null) {
      userRepository.save(user);
    }
  }

  private void createUsersIfNotInDatabase(Set<User> users) {
    Set<String> links = users.stream()
                             .map(User::getLink)
                             .collect(Collectors.toSet());
    List<User> persistedUsers = userRepository.findAllByLinkInIgnoreCase(links);

    users.removeAll(persistedUsers);
    userRepository.save(users);
  }


  private void resetIdForEntityCreationInHibernate(BaseEntity entity) {
    entity.setId(null);
  }

  private void setUserEventsHibernateBindingsWithDefaultResponse(Event event) {

    Set<EventAttendee> attendeesToSave = new HashSet<>();

    for (EventAttendee attendee : event.getAttendees()) {
      UserEvent userEvent = new UserEvent(event, attendee.getUser(), UserResponse.NOT_RESPONDED);
      attendeesToSave.add(userEvent);
    }

    event.setAttendees(attendeesToSave);
  }

  private void setEventApproval(Event event, EventState state) {
    // FIXME: 7/19/2017 Fix approval - change default state from fixed name to smth else, enums for example.
    EventApproval approval = approvalRepository.findByName(state);
    event.setEventApproval(approval);
  }

  public Event updateEventState(Event event, EventState newEventState) {
    if (event == null || newEventState == null) {
      return event;
    }
    EventApproval approval = approvalRepository.findByName(newEventState);
    event.setEventApproval(approval);
    eventRepository.save(event);
    return event;
  }


  public void deleteEventImage(Long eventId) {
    if (eventId == null) {
      throw new IllegalArgumentException("Cannot delete an image of an event with id = null");
    }
    Image image = imageRepository.findByEventId(eventId);
    if (image != null) {
      image.getEvent()
           .setImage(null);
      imageRepository.save(image);
      imageRepository.delete(image);
    }
  }

  public Event getHeadliner(Long typeId) {
    EventCriteriaBuilder eventCriteriaBuilder = new EventCriteriaBuilder(entityManager);

    return eventCriteriaBuilder.getHeadliner(typeId);
  }

  public Event updateEventPromotedStatus(PromotedStatusDto promotedStatusDto, Long eventId) {
    if (promotedStatusDto.getIsPromoted() == null) {
      throw new NullPointerException("Event promoted status can not be null!");
    }

    Event oldEvent = eventRepository.findOne(eventId);
    if (oldEvent == null) {
      return null;
    }

    flowInspector.checkEventHeadlinerFlow(oldEvent);

    oldEvent.setIsPromoted(promotedStatusDto.getIsPromoted());
    return eventRepository.save(oldEvent);
  }

  public void rejectEvent(Long eventId, OutlookMessageDto rejectOutlookMessage) {

    Event currentEvent = findOne(eventId);

    flowInspector.checkEventStatusUpdateFlow(currentEvent, EventState.REJECTED);
    updateEventState(currentEvent, EventState.REJECTED);

    if (rejectOutlookMessage != null) {
      outlookService.deleteEvent(eventId, rejectOutlookMessage);
    } else {
      outlookService.deleteEvent(eventId);
    }
  }

  public Event getEvent(Long eventId) {
    Event event = findOne(eventId);
    if (event.getIsPrivate()) {
      flowInspector.checkEventAttendeeGetFlow(event);
    }
    return event;
  }

  public Event updateEvent(Long eventId, Event newEvent) {
    Event oldEvent = findOne(eventId);

    flowInspector.checkEventUpdateFlow(oldEvent);

    setNotChangingValues(newEvent, oldEvent);

    Set<User> users = new HashSet<>();
    for (EventAttendee attendee : newEvent.getAttendees()) {
      users.add(attendee.getUser());
    }

    createUsersIfNotInDatabase(users);
    updateEventAttendees(newEvent);

    if (oldEvent.getEventApproval()
                .getName()
                .equals(EventState.APPROVED)) {
      outlookService.updateEvent(newEvent);
    }
    // FIXME: 10/17/2017  we should fix this piece when we will fix "logo upload flow"
    if (newEvent.getImage() != null && newEvent.getImage()
                                               .getBytes() != null) {
      newEvent = uploadEventImage(newEvent);
    }
    //TODO [MS] 12.11.17 temporary solution until file-service is implemented
    if (newEvent.getLogoImageId() == null) {
      newEvent.setLogoImageId(oldEvent.getLogoImageId());
    }

    return eventRepository.save(newEvent);
  }

  public void secureEventDelete(Long eventId) {

    Event currentEvent = findOne(eventId);
    EventState oldState = currentEvent.getEventApproval()
                                      .getName();
    flowInspector.checkEventDeleteFlow(currentEvent);

    deleteEvent(eventId);

    if (oldState.equals(EventState.APPROVED)) {
      outlookService.deleteEvent(eventId);
    }
  }

  public void secureEventImageDelete(Long eventId) {
    if (eventId == null) {
      throw new IllegalArgumentException("Cannot delete an image of an event with id = null");
    }
    Event currentEvent = findOne(eventId);

    flowInspector.checkEventImageDeleteFlow(currentEvent);

    deleteEventImage(eventId);
  }
}