package org.jboss.examples.ticketmonster.rest;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jboss.examples.ticketmonster.model.Performance;
import org.jboss.examples.ticketmonster.model.Show;

/**
 * Metric data for a Show. Contains the identifier for the Show to identify it,
 * in addition to the event name, the venue name and capacity, and the metric
 * data for the performances of the Show.
 */
class ShowMetric {

  private Long show;
  private String event;
  private String venue;
  private int capacity;
  private List<PerformanceMetric> performances;

  // Constructor to populate the instance with data
  public ShowMetric(Show show, Map<Long, Long> occupiedCounts) {
    this.show = show.getId();
    this.event = show.getEvent().getName();
    this.venue = show.getVenue().getName();
    this.capacity = show.getVenue().getCapacity();
    this.performances = convertFrom(show.getPerformances(), occupiedCounts);
  }

  private List<PerformanceMetric> convertFrom(Set<Performance> performances,
      Map<Long, Long> occupiedCounts) {
    List<PerformanceMetric> result = new ArrayList<PerformanceMetric>();
    for (Performance performance : performances) {
      Long occupiedCount = occupiedCounts.get(performance.getId());
      result.add(new PerformanceMetric(performance, occupiedCount));
    }
    return result;
  }

  // Getters for Jackson
  // NOTE: No setters and default constructors are defined since
  // deserialization is not required.

  public Long getShow() {
    return show;
  }

  public String getEvent() {
    return event;
  }

  public String getVenue() {
    return venue;
  }

  public int getCapacity() {
    return capacity;
  }

  public List<PerformanceMetric> getPerformances() {
    return performances;
  }
}

package org.jboss.examples.ticketmonster.rest;

import java.util.Date;

import org.jboss.examples.ticketmonster.model.Performance;

/**
 * Metric data for a Performance. Contains the datetime for the performance to
 * identify the performance, as well as the occupied count for the performance.
 */
class PerformanceMetric {

  private Date date;
  private Long occupiedCount;

  // Constructor to populate the instance with data
  public PerformanceMetric(Performance performance, Long occupiedCount) {
    this.date = performance.getDate();
    this.occupiedCount = (occupiedCount == null ? 0 : occupiedCount);
  }

  // Getters for Jackson
  // NOTE: No setters and default constructors are defined since
  // deserialization is not required.

  public Date getDate() {
    return date;
  }

  public Long getOccupiedCount() {
    return occupiedCount;
  }

}

package org.jboss.examples.ticketmonster.rest;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.ejb.Stateless;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.jboss.examples.ticketmonster.model.Show;

/**
 * A read-only REST resource that provides a collection of metrics for shows occuring in the future. Updates to metrics via
 * POST/PUT etc. are not allowed, since they are not meant to be computed by consumers.
 *
 */
@Path("/metrics")
@Stateless
public class MetricsService {

    @Inject
    private EntityManager entityManager;

    /**
     * Retrieves a collection of metrics for Shows. Each metric in the collection contains
     * <ul>
     * <li>the show id,</li>
     * <li>the event name of the show,</li>
     * <li>the venue for the show,</li>
     * <li>the capacity for the venue</li>
     * <li>the performances for the show,
     * <ul>
     * <li>the timestamp for each performance,</li>
     * <li>the occupied count for each performance</li>
     * </ul>
     * </li>
     * </ul>
     *
     * @return A JSON representation of metrics for shows.
     */
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<ShowMetric> getMetrics() {
        return retrieveMetricsFromShows(retrieveShows(),
            retrieveOccupiedCounts());
    }

    private List<ShowMetric> retrieveMetricsFromShows(List<Show> shows,
        Map<Long, Long> occupiedCounts) {
        List<ShowMetric> metrics = new ArrayList<ShowMetric>();
        for (Show show : shows) {
            metrics.add(new ShowMetric(show, occupiedCounts));
        }
        return metrics;
    }

    private List<Show> retrieveShows() {
        TypedQuery<Show> showQuery = entityManager
            .createQuery("select DISTINCT s from Show s JOIN s.performances p WHERE p.date > current_timestamp", Show.class);
        return showQuery.getResultList();
    }

    private Map<Long, Long> retrieveOccupiedCounts() {
        Map<Long, Long> occupiedCounts = new HashMap<Long, Long>();

        Query occupiedCountsQuery = entityManager
            .createQuery("select b.performance.id, SIZE(b.tickets) from Booking b "
                + "WHERE b.performance.date > current_timestamp GROUP BY b.performance.id");

        List<Object[]> results = occupiedCountsQuery.getResultList();
        for (Object[] result : results) {
            occupiedCounts.put((Long) result[0],
                ((Integer) result[1]).longValue());
        }

        return occupiedCounts;
    }
}

package org.jboss.examples.ticketmonster.service;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;
import javax.ejb.Stateless;
import javax.ejb.Timeout;
import javax.ejb.Timer;
import javax.ejb.TimerConfig;
import javax.ejb.TimerService;
import javax.enterprise.event.Event;
import javax.inject.Inject;
import javax.ws.rs.core.Response;

import org.jboss.examples.ticketmonster.model.Performance;
import org.jboss.examples.ticketmonster.model.Show;
import org.jboss.examples.ticketmonster.model.TicketPrice;
import org.jboss.examples.ticketmonster.rest.*;
import org.jboss.examples.ticketmonster.util.MultivaluedHashMap;
import org.jboss.examples.ticketmonster.util.qualifier.BotMessage;

@Stateless
public class Bot {

    private static final Random random = new Random(System.nanoTime());

    /** Frequency with which the bot will book **/
    public static final long DURATION = TimeUnit.SECONDS.toMillis(3);

    /** Maximum number of ticket requests that will be filed **/
    public static int MAX_TICKET_REQUESTS = 100;

    /** Maximum number of tickets per request **/
    public static int MAX_TICKETS_PER_REQUEST = 100;

    public static String [] BOOKERS = {"anne@acme.com", "george@acme.com", "william@acme.com", "victoria@acme.com", "edward@acme.com", "elizabeth@acme.com", "mary@acme.com", "charles@acme.com", "james@acme.com", "henry@acme.com", "richard@acme.com", "john@acme.com", "stephen@acme.com"};

    @Inject
    private ShowService showService;

    @Inject
    private BookingService bookingService;

    @Inject @BotMessage
    Event<String> event;

    @Resource
    private TimerService timerService;

    public Timer start() {
        String startMessage = new StringBuilder("==========================\n")
                .append("Bot started at ").append(new Date().toString()).append("\n")
                .toString();
        event.fire(startMessage);
        return timerService.createIntervalTimer(0, DURATION, new TimerConfig(null, false));
    }

    public void stop(Timer timer) {
        String stopMessage = new StringBuilder("==========================\n")
                .append("Bot stopped at ").append(new Date().toString()).append("\n")
                .toString();
        event.fire(stopMessage);
        timer.cancel();
    }

    @Timeout
    public void book(Timer timer) {
        // Select a show at random
        Show show = selectAtRandom(showService.getAll(MultivaluedHashMap.<String, String>empty()));

        // Select a performance at random
        Performance performance = selectAtRandom(show.getPerformances());

        String requestor = selectAtRandom(BOOKERS);

        BookingRequest bookingRequest = new BookingRequest(performance, requestor);

        List<TicketPrice> possibleTicketPrices = new ArrayList<TicketPrice>(show.getTicketPrices());

        List<Integer> indicies = selectAtRandom(MAX_TICKET_REQUESTS < possibleTicketPrices.size() ? MAX_TICKET_REQUESTS : possibleTicketPrices.size());

        StringBuilder message = new StringBuilder("==========================\n")
        .append("Booking by ")
        .append(requestor)
        .append(" at ")
        .append(new Date().toString())
        .append("\n")
        .append(performance)
        .append("\n")
        .append("~~~~~~~~~~~~~~~~~~~~~~~~~\n");

        for (int index : indicies) {
            int no = random.nextInt(MAX_TICKETS_PER_REQUEST);
            TicketPrice price = possibleTicketPrices.get(index);
            bookingRequest.addTicketRequest(new TicketRequest(price, no));
            message
                .append(no)
                .append(" of ")
                .append(price.getSection())
                .append("\n");

        }
        Response response = bookingService.createBooking(bookingRequest);
        if(response.getStatus() == Response.Status.OK.getStatusCode()) {
            message.append("SUCCESSFUL\n")
                    .append("~~~~~~~~~~~~~~~~~~~~~~~~~\n");
        }
        else {
            message.append("FAILED:\n")
                        .append(((Map<String, Object>) response.getEntity()).get("errors"))
                        .append("~~~~~~~~~~~~~~~~~~~~~~~~~\n");
        }
        event.fire(message.toString());
    }



    private <T> T selectAtRandom(List<T> list) {
        int i = random.nextInt(list.size());
        return list.get(i);
    }

    private <T> T selectAtRandom(T[] array) {
        int i = random.nextInt(array.length);
        return array[i];
    }

    private <T> T selectAtRandom(Collection<T> collection) {
        int item = random.nextInt(collection.size());
        int i = 0;
        for(T obj : collection)
        {
            if (i == item)
                return obj;
            i++;
        }
        throw new IllegalStateException();
    }

    private List<Integer> selectAtRandom(int max) {
        List<Integer> indicies = new ArrayList<Integer>();
        for (int i = 0; i < max;) {
            int r = random.nextInt(max);
            if (!indicies.contains(r)) {
                indicies.add(r);
                i++;
            }
        }
        return indicies;
    }
}

package org.jboss.examples.ticketmonster.util.qualifier;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.inject.Qualifier;

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Qualifier
@Target({ TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
public @interface BotMessage {

}

package org.jboss.examples.ticketmonster.service;

import java.util.List;
import java.util.logging.Logger;

import javax.ejb.Asynchronous;
import javax.ejb.Singleton;
import javax.ejb.Timer;
import javax.enterprise.event.Event;
import javax.enterprise.event.Observes;
import javax.inject.Inject;

import org.jboss.examples.ticketmonster.model.Booking;
import org.jboss.examples.ticketmonster.rest.BookingService;
import org.jboss.examples.ticketmonster.util.CircularBuffer;
import org.jboss.examples.ticketmonster.util.MultivaluedHashMap;
import org.jboss.examples.ticketmonster.util.qualifier.BotMessage;

/**
 * A Bot service that acts as a Facade for the Bot, providing methods to control the Bot state as well as to obtain the current
 * state of the Bot.
 */
@Singleton
public class BotService {

    private static final int MAX_LOG_SIZE = 50;

    private CircularBuffer<String> log;

    @Inject
    private Bot bot;

    @Inject
    private BookingService bookingService;

    @Inject
    private Logger logger;

    @Inject
    @BotMessage
    private Event<String> event;

    private Timer timer;

    public BotService() {
        log = new CircularBuffer<String>(MAX_LOG_SIZE);
    }

    public void start() {
        synchronized (bot) {
            if (timer == null) {
                logger.info("Starting bot");
                timer = bot.start();
            }
        }
    }

    public void stop() {
        synchronized (bot) {
            if (timer != null) {
                logger.info("Stopping bot");
                bot.stop(timer);
                timer = null;
            }
        }
    }

    @Asynchronous
    public void deleteAll() {
        synchronized (bot) {
            stop();
            // Delete 10 bookings at a time
            while(true) {
                MultivaluedHashMap<String,String> params = new MultivaluedHashMap<String, String>();
                params.add("maxResults", Integer.toString(10));
                List<Booking> bookings = bookingService.getAll(params);
                for (Booking booking : bookings) {
                    bookingService.deleteBooking(booking.getId());
                    event.fire("Deleted booking " + booking.getId() + " for "
                            + booking.getContactEmail() + "\n");
                }
                if(bookings.size() < 1) {
                    break;
                }
            }
        }
    }

    public void newBookingRequest(@Observes @BotMessage String bookingRequest) {
        log.add(bookingRequest);
    }

    public List<String> fetchLog() {
        return log.getContents();
    }

    public boolean isBotActive() {
        return (timer != null);
    }

}

package org.jboss.examples.ticketmonster.rest;

/**
 * An enumeration that represents the possible states for the Bot.
 */
public enum BotState {
    RUNNING, NOT_RUNNING, RESET
}

package org.jboss.examples.ticketmonster.rest;

import java.util.List;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.jboss.examples.ticketmonster.service.BotService;

/**
 * A non-RESTful service for providing the current state of the Bot. This service also allows the bot to be started, stopped or
 * the existing bookings to be deleted.
 */
@Path("/bot")
public class BotStatusService {

    @Inject
    private BotService botService;

    /**
     * Produces a JSON representation of the bot's log, containing a maximum of 50 messages logged by the Bot.
     *
     * @return The JSON representation of the Bot's log
     */
    @Path("messages")
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<String> getMessages() {
        return botService.fetchLog();
    }

    /**
     * Produces a representation of the bot's current state. This is a string - "RUNNING" or "NOT_RUNNING" depending on whether
     * the bot is active.
     *
     * @return The represntation of the Bot's current state.
     */
    @Path("status")
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response getBotStatus() {
        BotState state = botService.isBotActive() ? BotState.RUNNING
            : BotState.NOT_RUNNING;
        return Response.ok(state).build();
    }

    /**
     * Updates the state of the Bot with the provided state. This may trigger the bot to start itself, stop itself, or stop and
     * delete all existing bookings.
     *
     * @param updatedStatus The new state of the Bot. Only the state property is considered; any messages provided are ignored.
     * @return An empty HTTP 201 response.
     */
    @Path("status")
    @PUT
    public Response updateBotStatus(BotState updatedState) {
        if (updatedState.equals(BotState.RUNNING)) {
            botService.start();
        } else if (updatedState.equals(BotState.NOT_RUNNING)) {
            botService.stop();
        } else if (updatedState.equals(BotState.RESET)) {
            botService.deleteAll();
        }
        return Response.noContent().build();
    }

}