package com.airlock.iam.common.infrastructure.event;

import com.airlock.iam.base.misc.collection.IamMaps;
import com.airlock.iam.common.api.domain.model.event.EventData;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

public final class EventPayloadBuilder {
   private static final String DATA = "data";
   private static final String SOURCE = "source";
   private static final String CUSTOM_DATA = "customData";
   private static final String EVENT_ID = "eventId";
   private static final String EVENT_TYPE = "eventType";
   private static final String OCCURRED_AT = "occurredAt";
   private Map<String, Object> payload = new HashMap<>();

   public EventPayloadBuilder addEventId(String eventId) {
      return this.add("eventId", eventId);
   }

   public EventPayloadBuilder addEventType(String eventType) {
      return this.add("eventType", eventType);
   }

   public EventPayloadBuilder addOccurredAt(Instant occurredAt) {
      return this.add("occurredAt", occurredAt);
   }

   public EventPayloadBuilder addData(Map<String, Object> data) {
      return this.addIfNotEmpty("data", data);
   }

   public EventPayloadBuilder addSource(Map<String, Object> source) {
      return this.addIfNotEmpty("source", source);
   }

   public EventPayloadBuilder addCustomData(Map<String, Object> customData) {
      return this.addIfNotEmpty("customData", customData);
   }

   private EventPayloadBuilder add(String key, Object value) {
      this.payload.put(key, value);
      return this;
   }

   private EventPayloadBuilder addIfNotEmpty(String key, Map<String, Object> additionalData) {
      if (!additionalData.isEmpty()) {
         this.payload = IamMaps.mergeMapsRecursively(this.payload, Map.of(key, additionalData));
      }

      return this;
   }

   public EventData.EventPayload build() {
      return new EventData.EventPayload(Map.copyOf(this.payload));
   }
}