package com.box.sdk;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * A log of events that were retrieved from the events endpoint.
 *
 * <p>An EventLog cannot be instantiated directly. Instead, use one of the static methods to retrieve a log of events.
 * Unlike the {@link EventStream} class, EventLog doesn't support retrieving events in real-time.
 * </p>
 */
public class EventLog implements Iterable<BoxEvent> {

    static final int ENTERPRISE_LIMIT = 500;
    /**
     * Enterprise Event URL Template.
     */
    public static final URLTemplate ENTERPRISE_EVENT_URL_TEMPLATE = new URLTemplate("events?stream_type=admin_logs&"
        + "limit=" + ENTERPRISE_LIMIT);
    private final int chunkSize;
    private final int limit;
    private final String nextStreamPosition;
    private final String streamPosition;
    private final Set<BoxEvent> events;

    private Date startDate;
    private Date endDate;

    EventLog(BoxAPIConnection api, JsonObject json, String streamPosition, int limit) {
        this.streamPosition = streamPosition;
        this.limit = limit;
        JsonValue nextStreamPosition = json.get("next_stream_position");
        if (nextStreamPosition.isString()) {
            this.nextStreamPosition = nextStreamPosition.asString();
        } else {
            this.nextStreamPosition = nextStreamPosition.toString();
        }
        this.chunkSize = json.get("chunk_size").asInt();

        this.events = new LinkedHashSet<>(this.chunkSize);
        JsonArray entries = json.get("entries").asArray();
        for (JsonValue entry : entries) {
            this.events.add(new BoxEvent(api, entry.asObject()));
        }
    }

    /**
     * Method reads from the `admin-logs` stream and returns {@link BoxEvent} {@link Iterator}.
     * The emphasis for this stream is on completeness over latency,
     * which means that Box will deliver admin events in chronological order and without duplicates,
     * but with higher latency. You can specify start and end time/dates. This method
     * will only work with an API connection for an enterprise admin account
     * or service account with manage enterprise properties.
     * You can specify a date range to limit when events occured, starting from a given position within the
     * event stream, set limit or specify event types that should be filtered.
     * Example:
     * <pre>
     * {@code
     * EnterpriseEventsRequest request = new EnterpriseEventsRequest()
     *     .after(after)        // The lower bound on the timestamp of the events returned.
     *     .before(before)      // The upper bound on the timestamp of the events returned.
     *     .limit(20)           // The number of entries to be returned in the response.
     *     .position(position)  // The starting position of the event stream.
     *     .types(EventType.LOGIN, EventType.FAILED_LOGIN); // List of event types to filter by.
     * EventLog.getEnterpriseEvents(api, request);
     * }
     * </pre>
     *
     * @param api                     the API connection to use.
     * @param enterpriseEventsRequest request to get events.
     * @return a log of all the events that met the given criteria.
     */
    public static EventLog getEnterpriseEvents(BoxAPIConnection api, EnterpriseEventsRequest enterpriseEventsRequest) {
        EventLogRequest request = new EventLogRequest(
            enterpriseEventsRequest.getBefore(),
            enterpriseEventsRequest.getAfter(),
            enterpriseEventsRequest.getPosition(),
            enterpriseEventsRequest.getLimit(),
            enterpriseEventsRequest.getTypes()
        );
        return getEnterpriseEventsForStreamType(api, enterpriseEventsRequest.getStreamType(), request);
    }

    /**
     * Method reads from the `admin-logs-streaming` stream and returns {@link BoxEvent} {@link Iterator}
     * The emphasis for this feed is on low latency rather than chronological accuracy, which means that Box may return
     * events more than once and out of chronological order. Events are returned via the API around 12 seconds after they
     * are processed by Box (the 12 seconds buffer ensures that new events are not written after your cursor position).
     * Only two weeks of events are available via this feed, and you cannot set start and end time/dates. This method
     * will only work with an API connection for an enterprise admin account
     * or service account with manage enterprise properties.
     * You can specify a starting from a given position within the event stream,
     * set limit or specify event types that should be filtered.
     * Example:
     * <pre>
     * {@code
     * EnterpriseEventsStreamRequest request = new EnterpriseEventsStreamRequest()
     *     .limit(200)          // The number of entries to be returned in the response.
     *     .position(position)  // The starting position of the event stream.
     *     .types(EventType.LOGIN, EventType.FAILED_LOGIN); // List of event types to filter by.
     * EventLog.getEnterpriseEventsStream(api, request);
     * }
     * </pre>
     *
     * @param api                           the API connection to use.
     * @param enterpriseEventsStreamRequest request to get events.
     * @return a log of all the events that met the given criteria.
     */
    public static EventLog getEnterpriseEventsStream(
        BoxAPIConnection api, EnterpriseEventsStreamRequest enterpriseEventsStreamRequest
    ) {
        EventLogRequest request = new EventLogRequest(
            null,
            null,
            enterpriseEventsStreamRequest.getPosition(),
            enterpriseEventsStreamRequest.getLimit(),
            enterpriseEventsStreamRequest.getTypes()
        );
        return getEnterpriseEventsForStreamType(api, enterpriseEventsStreamRequest.getStreamType(), request);
    }

    private static EventLog getEnterpriseEventsForStreamType(
        BoxAPIConnection api, String streamType, EventLogRequest request
    ) {
        URL url = new URLTemplate("events?").build(api.getBaseURL());
        QueryStringBuilder queryBuilder = new QueryStringBuilder(url.getQuery());
        queryBuilder.appendParam("stream_type", streamType);
        addParamsToQuery(request, queryBuilder);

        try {
            url = queryBuilder.addToURL(url);
        } catch (MalformedURLException e) {
            throw new BoxAPIException("Couldn't append a query string to the provided URL.");
        }

        BoxJSONRequest apiRequest = new BoxJSONRequest(api, url, "GET");
        try (BoxJSONResponse response = apiRequest.send()) {
            JsonObject responseJSON = Json.parse(response.getJSON()).asObject();
            EventLog log = new EventLog(api, responseJSON, request.getPosition(), request.getLimit());
            log.setStartDate(request.getAfter());
            log.setEndDate(request.getBefore());
            return log;
        }
    }

    private static void addParamsToQuery(EventLogRequest request, QueryStringBuilder queryBuilder) {
        queryBuilder.appendParam("limit", request.getLimit());

        if (request.getAfter() != null) {
            queryBuilder.appendParam("created_after", BoxDateFormat.format(request.getAfter()));
        }
        if (request.getBefore() != null) {
            queryBuilder.appendParam("created_before", BoxDateFormat.format(request.getBefore()));
        }
        if (request.getPosition() != null) {
            queryBuilder.appendParam("stream_position", request.getPosition());
        }
        if (request.getTypes().size() > 0) {
            String types = String.join(",", request.getTypes());
            queryBuilder.appendParam("event_type", types);
        }
    }

    /**
     * Returns an iterator over the events in this log.
     *
     * @return an iterator over the events in this log.
     */
    @Override
    public Iterator<BoxEvent> iterator() {
        return this.events.iterator();
    }

    /**
     * Gets the date of the earliest event in this log.
     *
     * <p>The value returned by this method corresponds to the <code>created_after</code> URL parameter that was used
     * when retrieving the events in this EventLog.</p>
     *
     * @return the date of the earliest event in this log.
     */
    public Date getStartDate() {
        return this.startDate;
    }

    void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    /**
     * Gets the date of the latest event in this log.
     *
     * <p>The value returned by this method corresponds to the <code>created_before</code> URL parameter that was used
     * when retrieving the events in this EventLog.</p>
     *
     * @return the date of the latest event in this log.
     */
    public Date getEndDate() {
        return this.endDate;
    }

    void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    /**
     * Gets the maximum number of events that this event log could contain given its start date, end date, and stream
     * position.
     *
     * <p>The value returned by this method corresponds to the <code>limit</code> URL parameter that was used when
     * retrieving the events in this EventLog.</p>
     *
     * @return the maximum number of events.
     */
    public int getLimit() {
        return this.limit;
    }

    /**
     * Gets the starting position of the events in this log within the event stream.
     *
     * <p>The value returned by this method corresponds to the <code>stream_position</code> URL parameter that was used
     * when retrieving the events in this EventLog.</p>
     *
     * @return the starting position within the event stream.
     */
    public String getStreamPosition() {
        return this.streamPosition;
    }

    /**
     * Gets the next position within the event stream for retrieving subsequent events.
     *
     * <p>The value returned by this method corresponds to the <code>next_stream_position</code> field returned by the
     * API's events endpoint.</p>
     *
     * @return the next position within the event stream.
     */
    public String getNextStreamPosition() {
        return this.nextStreamPosition;
    }

    /**
     * Gets the number of events in this log, including duplicate events.
     *
     * <p>The chunk size may not be representative of the number of events returned by this EventLog's iterator because
     * the iterator will automatically ignore duplicate events.</p>
     *
     * <p>The value returned by this method corresponds to the <code>chunk_size</code> field returned by the API's
     * events endpoint.</p>
     *
     * @return the number of events, including duplicates.
     */
    public int getChunkSize() {
        return this.chunkSize;
    }

    /**
     * Gets the number of events in this list, excluding duplicate events.
     *
     * <p>The size is guaranteed to be representative of the number of events returned by this EventLog's iterator.</p>
     *
     * @return the number of events, excluding duplicates.
     */
    public int getSize() {
        return this.events.size();
    }

    private static final class EventLogRequest {
        private final Date before;
        private final Date after;
        private final String position;
        private final Integer limit;
        private final Collection<String> types;

        private EventLogRequest(
            Date before,
            Date after,
            String position,
            Integer limit,
            Collection<String> types
        ) {
            this.before = before;
            this.after = after;
            this.position = position;
            this.limit = limit;
            this.types = types;
        }

        private Date getBefore() {
            return before;
        }

        private Date getAfter() {
            return after;
        }

        private String getPosition() {
            return position;
        }

        private Integer getLimit() {
            return limit;
        }

        private Collection<String> getTypes() {
            return types;
        }
    }
}