/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.juneau.console.views;

import static org.apache.juneau.commons.utils.Shorts.*;

import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
import org.apache.juneau.terminal.report.*;

/**
 * A thread-safe, in-memory {@link TerminalViewSource} that a producer appends to directly.
 *
 * <p>
 * Tokens are <c>&lt;epoch&gt;.&lt;n&gt;</c>, where <c>epoch</c> is six characters of <c>[0-9a-z]</c> regenerated by
 * {@link #reset()} and <c>n</c> is the last <c>seq</c> the client has.  A page returns the events with
 * <c>seq &gt; n</c>.
 *
 * <p>
 * A <c>done</c> event does not close the log by itself; {@link #close()} is explicit, so an adopter may still append a
 * late note.  A host that pushes events over its own transport (for example server-sent events) forwards the numbered
 * event returned by {@link #append(TerminalEvent)}.
 */
public final class TerminalViewLog implements TerminalViewSource {

   /** The default capacity. */
   public static final int DEFAULT_MAX_EVENTS = 200_000;

   private static final Pattern TOKEN = Pattern.compile("^([0-9a-z]{6})\\.(0|[1-9]\\d{0,17})$");
   private static final String ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";

   private final int maxEvents;
   private final List<TerminalEvent> events = new ArrayList<>();
   private String epoch = newEpoch(null);
   private boolean closed;

   private TerminalViewLog(int maxEvents) {
      this.maxEvents = maxEvents;
   }

   /**
    * Creates a log with the default capacity.
    *
    * @return A new log.
    */
   public static TerminalViewLog create() {
      return new TerminalViewLog(DEFAULT_MAX_EVENTS);
   }

   /**
    * Creates a log with a given capacity.
    *
    * @param maxEvents The maximum number of events, at least 1.
    * @return A new log.
    */
   public static TerminalViewLog create(int maxEvents) {
      if (maxEvents < 1)
         throw iaex("TerminalViewLog maxEvents must be >= 1; got %s", maxEvents);
      return new TerminalViewLog(maxEvents);
   }

   /**
    * Appends an event, assigning <c>seq = size + 1</c>.
    *
    * @param event The event.
    * @return The numbered copy that was stored.
    * @throws IllegalStateException If the log is closed or full.
    * @throws IllegalArgumentException If the event is too large.
    */
   public TerminalEvent append(TerminalEvent event) {
      return appendAll(List.of(event)).get(0);
   }

   /**
    * Appends events atomically, numbering them consecutively.
    *
    * @param batch The events.
    * @return The numbered copies, in order.
    * @throws IllegalStateException If the log is closed or the batch does not fit.
    * @throws IllegalArgumentException If an event is too large.
    */
   public List<TerminalEvent> appendAll(Collection<TerminalEvent> batch) {
      for (var e : batch)
         e.validate();
      synchronized (events) {
         if (closed)
            throw new IllegalStateException("TerminalViewLog is closed");
         if (events.size() + batch.size() > maxEvents)
            throw new IllegalStateException("TerminalViewLog is full (" + maxEvents + " events)");
         var out = new ArrayList<TerminalEvent>(batch.size());
         for (var e : batch) {
            var numbered = e.withSeq(events.size() + 1L);
            events.add(numbered);
            out.add(numbered);
         }
         return out;
      }
   }

   /**
    * Marks the log terminal: no further events will be appended.
    */
   public void close() {
      synchronized (events) {
         closed = true;
      }
   }

   /**
    * Returns whether {@link #close()} has been called.
    *
    * @return <jk>true</jk> if the log is closed.
    */
   public boolean isTerminal() {
      synchronized (events) {
         return closed;
      }
   }

   /**
    * Clears the log, reopens it, and bumps the epoch so that tokens issued before the reset answer <c>410 Gone</c>.
    */
   public void reset() {
      synchronized (events) {
         events.clear();
         closed = false;
         epoch = newEpoch(epoch);
      }
   }

   @Override /* TerminalViewSource */
   public TerminalViewPage page(String after, int max) {
      var limit = Math.max(1, Math.min(max, TerminalViewPage.MAX_PAGE_EVENTS));
      synchronized (events) {
         var from = 0;
         if (after != null) {
            var m = TerminalViewChecks.isToken(after) ? TOKEN.matcher(after) : null;
            if (m == null || ! m.matches() || ! m.group(1).equals(epoch))
               throw new UnknownTokenException(after);
            long n = Long.parseLong(m.group(2));
            if (n > events.size())
               throw new UnknownTokenException(after);
            from = (int)n;
         }
         var to = Math.min(events.size(), from + limit);
         var page = new ArrayList<>(events.subList(from, to));
         var more = to < events.size();
         return TerminalViewPage.of(page, epoch + "." + to, more, closed && ! more);
      }
   }

   private static String newEpoch(String not) {
      var r = ThreadLocalRandom.current();
      String s;
      do {
         var sb = new StringBuilder(6);
         for (var i = 0; i < 6; i++)
            sb.append(ALPHABET.charAt(r.nextInt(ALPHABET.length())));
         s = sb.toString();
      } while (s.equals(not));
      return s;
   }
}