/*
 * Copyright 2018, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.partner.mapsbooking.rest;

import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.util.JsonFormat;
import ext.maps.booking.partner.v3.ApiV3;
import ext.maps.booking.partner.v3.Waitlist;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/** Booking REST Server for API v3 with authentication. */
@Path("/v3")
public class BookingService {

  private JsonFormat.Printer jsonPrinter() {
    return JsonFormat.printer().preservingProtoFieldNames();
  }

  @Path("/HealthCheck")
  @GET
  @Produces(MediaType.TEXT_PLAIN)
  public String checkServer() {
    return "200";
  }

  @Path("/CheckAvailability")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String checkAvailability(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String to protocol buffer
    ApiV3.CheckAvailabilityRequest.Builder requestBuilder =
        ApiV3.CheckAvailabilityRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.CheckAvailabilityRequest checkAvailabilityRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.CheckAvailabilityResponse response = performCheckAvailability(checkAvailabilityRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to perform availability check
  private ApiV3.CheckAvailabilityResponse performCheckAvailability(
      ApiV3.CheckAvailabilityRequest request) {

    //        Check availability business logic:
    //        e.g.
    //        ApiV3.Slot requestedSlot = request.getSlot();
    //        int available_spots = ...;
    //        ApiV3.CheckAvailabilityResponse response =
    //                ApiV3.CheckAvailabilityResponse.newBuilder()
    //                        .setSlot(requestedSlot)
    //                        .setCountAvailable(available_spots)
    //                        .build();
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/BatchAvailabilityLookup")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String batchAvailabilityLookup(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.BatchAvailabilityLookupRequest.Builder requestBuilder
        = ApiV3.BatchAvailabilityLookupRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.BatchAvailabilityLookupRequest batchAvailabilityLookupRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    // Normal path: get response object from the helper function
    ApiV3.BatchAvailabilityLookupResponse response
        = performBatchAvailabilityLookup(batchAvailabilityLookupRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to perform batch availability lookup
  private ApiV3.BatchAvailabilityLookupResponse performBatchAvailabilityLookup(
      ApiV3.BatchAvailabilityLookupRequest request) {
    //        BatchAvailabilityLookup logic:
    //        e.g.
    //        String merchantId = request.getMerchantId();
    //        List<ApiV3.SlotTime> requestedSlotTimes = request.getSlotTimeList();
    //
    //        List<ApiV3.SlotTimeAvailability> slotTimeAvailabilities =
    //             new ArrayList<SlotTimeAvailability>();
    //
    //        loop through all requested slotTimes &
    //          populate slotTimeAvailabilities with availability status:
    //        e.g
    //        for (ApiV3.SlotTime slotTime : requestedSlotTimes) {
    //            slotTimeAvailabilities.add(SlotTimeAvailability.newBuilder()
    //                .setSlotTime(slotTime)
    //                .setAvailable(true)
    //                .build());
    //        }
    //
    //        ApiV3.BatchAvailabilityLookupResponse response =
    //            ApiV3.BatchAvailabilityLookupResponse.newBuilder()
    //                .addAllSlotTimeAvailability(slotTimeAvailabilities).build();
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/CreateBooking")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String createBooking(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.CreateBookingRequest.Builder requestBuilder = ApiV3.CreateBookingRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.CreateBookingRequest createBookingRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.CreateBookingResponse response = performCreateBooking(createBookingRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to create a booking based on the request
  private ApiV3.CreateBookingResponse performCreateBooking(ApiV3.CreateBookingRequest request) {

    //        Create booking business logic:
    //        e.g.
    //        ApiV3.Booking createdBooking = ApiV3.Booking.newBuilder()
    //                .setBookingId("sampleBooking1")
    //                .setSlot(request.getSlot())
    //                .setUserInformation(request.getUserInformation())
    //                .setStatus(ApiV3.BookingStatus.CONFIRMED)
    //                .build();
    //
    //        ApiV3.CreateBookingResponse response = ApiV3.CreateBookingResponse.newBuilder()
    //                .setBooking(createdBooking)
    //                .build();
    //
    //        Business logic error -> set the BookingFailure in the response
    //        e.g.
    //        BookingServerModel.BookingFailure bookingFailure =
    // BookingServerModel.BookingFailure.newBuilder()
    //                .setCause(BookingServerModel.BookingFailure.Cause.SLOT_UNAVAILABLE)
    //                .setDescription("slot is not available now")
    //                .build();
    //        BookingServerModel.CreateBookingResponse response =
    // BookingServerModel.CreateBookingResponse.newBuilder()
    //                .setBookingFailure(bookingFailure).build();
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/UpdateBooking")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String updateBooking(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.UpdateBookingRequest.Builder requestBuilder = ApiV3.UpdateBookingRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.UpdateBookingRequest updateBookingRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.UpdateBookingResponse response = performUpdateBooking(updateBookingRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to update the booking based on the request
  private ApiV3.UpdateBookingResponse performUpdateBooking(ApiV3.UpdateBookingRequest request) {

    //        Update booking business logic:
    //        e.g.
    //        ApiV3.Booking booking = request.getBooking();
    //        ApiV3.Booking updatedBooking = ...
    //        ApiV3.UpdateBookingResponse response = ApiV3.UpdateBookingResponse.newBuilder()
    //                .setBooking(updatedBooking)
    //                .build();
    //
    //        Business logic error -> set the BookingFailure in the response
    //        e.g.
    //        BookingServerModel.BookingFailure bookingFailure =
    // BookingServerModel.BookingFailure.newBuilder()
    //                .setCause(BookingServerModel.BookingFailure.Cause.BOOKING_NOT_CANCELLABLE)
    //                .setDescription("this booking is not cancellable")
    //                .build();
    //        BookingServerModel.CreateBookingResponse response =
    // BookingServerModel.CreateBookingResponse.newBuilder()
    //                .setBookingFailure(bookingFailure).build();
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/GetBookingStatus")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String getBookingStatus(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.GetBookingStatusRequest.Builder requestBuilder =
        ApiV3.GetBookingStatusRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.GetBookingStatusRequest getBookingStatusRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.GetBookingStatusResponse response = performGetBookingStatus(getBookingStatusRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to get the booking status and prepayment status based on
  // the request
  private ApiV3.GetBookingStatusResponse performGetBookingStatus(
      ApiV3.GetBookingStatusRequest request) {

    //        Get booking status business logic:
    //        e.g.
    //        String bookingId = request.getBookingId();
    //        ...
    //        ApiV3.GetBookingStatusResponse response = ApiV3.GetBookingStatusResponse.newBuilder()
    //                .setBookingId(bookingId)
    //                .setBookingStatus(ApiV3.BookingStatus.CONFIRMED)
    //                .setPrepaymentStatus(ApiV3.PrepaymentStatus.PREPAYMENT_NOT_PROVIDED)
    //                .build();
    //
    //        If booking id is not found -> throw new NotFoundException("Booking id not found");
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/ListBookings")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String getListBooking(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.ListBookingsRequest.Builder requestBuilder = ApiV3.ListBookingsRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.ListBookingsRequest listBookingsRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.ListBookingsResponse response = performGetListBooking(listBookingsRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to look up all bookings with the given userId
  private ApiV3.ListBookingsResponse performGetListBooking(ApiV3.ListBookingsRequest request) {

    //        List bookings business logic:
    //        e.g.
    //        String userId = request.getUserId();
    //        List<ApiV3.Booking> bookings = ...
    //
    //        ApiV3.ListBookingsResponse response = ApiV3.ListBookingsResponse.newBuilder()
    //                .addAllBookings(bookings)
    //                .build();
    //
    //        If user id not found -> throw new NotFoundException("User id not found");
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/CheckOrderFulfillability")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String checkOrderFulfillability(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.CheckOrderFulfillabilityRequest.Builder requestBuilder =
        ApiV3.CheckOrderFulfillabilityRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.CheckOrderFulfillabilityRequest checkOrderFulfillabilityRequest = requestBuilder.build();

    // For unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.CheckOrderFulfillabilityResponse response =
        performCheckOrderFulfillability(checkOrderFulfillabilityRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to perform order fulfillability check
  private ApiV3.CheckOrderFulfillabilityResponse performCheckOrderFulfillability(
      ApiV3.CheckOrderFulfillabilityRequest request) {

    //        Check order fulfillability business logic:
    //        e.g.
    //        String merchantId = request.getMerchantId();
    //        List<ApiV3.LineItem> lineItems = request.getItemList();
    //
    //        List<ApiV3.LineItemFulfillability> itemFulfillabilities =
    //                getLineItemFulfillability(merchantId,lineItems);
    //        ApiV3.OrderFulfillability.OrderFulfillabilityResult result =
    //                getOrderFulfillabilityResult(itemFulfillabilities);
    //
    //        ApiV3.OrderFulfillability.Builder orderFulfillability =
    // ApiV3.OrderFulfillability.newBuilder()
    //                .setResult(result);
    //        for (int i = 0; i < itemFulfillabilities.size(); i++) {
    //            orderFulfillability.setItemFulfillability(i, itemFulfillabilities.get(i));
    //        }
    //        ApiV3.Price total = ...   // total processing fees & taxes for this order
    //        ApiV3.CheckOrderFulfillabilityResponse response =
    // ApiV3.CheckOrderFulfillabilityResponse.newBuilder()
    //                .setFulfillability(orderFulfillability.build())
    //                .setFeesAndTaxes(total)
    //                .build();
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/CreateOrder")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String createOrder(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.CreateOrderRequest.Builder requestBuilder = ApiV3.CreateOrderRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.CreateOrderRequest createOrderRequest = requestBuilder.build();

    // For unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.CreateOrderResponse response = performCreateOrder(createOrderRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to create the order based on the request
  private ApiV3.CreateOrderResponse performCreateOrder(ApiV3.CreateOrderRequest request) {

    //        Create order business logic:
    //        e.g.
    //        ApiV3.Order order = request.getOrder();
    //
    //        normal case -> create this order in the backend, return response:
    //        ApiV3.CreateOrderResponse response = ApiV3.CreateOrderResponse.newBuilder()
    //                .setOrder(order)
    //                .build();
    //
    //        Business logic error -> set the BookingFailure in the response
    //        e.g.
    //        ApiV3.OrderFailure orderFailure = ApiV3.OrderFailure.newBuilder()
    //                .setCause(ApiV3.OrderFailure.Cause.ORDER_UNFULFILLABLE)
    //                .setFulfillability(orderFulfillability...)
    //                .build();
    //        ApiV3.CreateOrderResponse response = ApiV3.CreateOrderResponse.newBuilder()
    //                .setOrderFailure(orderFailure)
    //                .build();
    //
    //        return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/ListOrders")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String listOrders(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    ApiV3.ListOrdersRequest.Builder requestBuilder = ApiV3.ListOrdersRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    ApiV3.ListOrdersRequest listOrdersRequest = requestBuilder.build();

    // For unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    ApiV3.ListOrdersResponse response = getListOrders(listOrdersRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to list orders based on user id or order ids
  private ApiV3.ListOrdersResponse getListOrders(ApiV3.ListOrdersRequest request) {

    //        List orders business logic:
    //        e.g.
    //        String userId = request.getUserId();
    //        ApiV3.ListOrdersRequest.OrderIds orderIds = request.getOrderIds();
    //        List<ApiV3.Order> orders = new ArrayList<ApiV3.Order>();
    //        if (userId != null) {
    //            orders = findOrdersByUserId(userId);
    //        } else if (orderIds != null) {
    //            List<String> orderId = orderIds.getOrderIdList();
    //            orders = getOrders(orderId);
    //        } else {
    //            throw new NotFoundException("No userId or orderId matched");
    //        }
    //        ApiV3.ListOrdersResponse.Builder response = ApiV3.ListOrdersResponse.newBuilder();
    //        for (int i = 0; i < orders.size(); i++) {
    //            response.setOrder(i, orders.get(i));
    //        }
    //
    //        return response.build();

    throw new UnsupportedOperationException("Not implemented yet");
  }


  /**
   * Waitlist Implementation
   * Proto File -
   * https://developers.google.com/maps-booking/reference/rest-api-v3/waitlists/proto-bundle
   */
  @Path("/BatchGetWaitEstimates")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String batchGetWaitEstimates(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    Waitlist.BatchGetWaitEstimatesRequest.Builder requestBuilder
        = Waitlist.BatchGetWaitEstimatesRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    Waitlist.BatchGetWaitEstimatesRequest batchGetWaitEstimatesRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    Waitlist.BatchGetWaitEstimatesResponse response
        = performBatchGetWaitEstimates(batchGetWaitEstimatesRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to return wait estimates based on party size
  private Waitlist.BatchGetWaitEstimatesResponse performBatchGetWaitEstimates(
      Waitlist.BatchGetWaitEstimatesRequest request) {
    // String merchantId = request.getMerchantId();
    // String serviceId = request.getServiceId();
    //
    // List<Integer> requestedPartySizes = request.getPartySizeList();
    //
    // Waitlist.BatchGetWaitEstimatesResponse response
    //     = Waitlist.BatchGetWaitEstimatesResponse.newBuilder().setWaitlistStatus(
    //           WaitlistStatus.OPEN).addAllWaitEstimate(...).build();
    //
    // return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/CreateWaitlistEntry")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String createWaitlistEntry(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    Waitlist.CreateWaitlistEntryRequest.Builder requestBuilder
        = Waitlist.CreateWaitlistEntryRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    Waitlist.CreateWaitlistEntryRequest createWaitlistEntryRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    Waitlist.CreateWaitlistEntryResponse response
        = performCreateWaitlistEntry(createWaitlistEntryRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to create wait list entry based on request
  private Waitlist.CreateWaitlistEntryResponse performCreateWaitlistEntry(
      Waitlist.CreateWaitlistEntryRequest request) {
    // String merchantId = request.getMerchantId();
    // String serviceId = request.getServiceId();
    // int partySize = request.getPartySize();
    //
    // Waitlist.UserInformation userInformation = request.getUserInformation();
    // String idempotencyToken = request.getIdempotencyToken();
    //
    // Normal Case -> return a unique waitlist_entry_id e.g
    // Waitlist.CreateWaitlistEntryResponse response
    //     = Waitlist.CreateWaitlistEntryResponse.newBuilder().setWaitlistEntryId(...).build();
    //
    // Business logic error -> set the WaitlistBusinessLogicFailure in the response
    //
    // Waitlist.WaitlistBusinessLogicFailure waitlistBusinessLogicFailure
    //     = Waitlist.WaitlistBusinessLogicFailure.newBuilder()
    //         .setCause(Cause.WAITLIST_FULL).setDescription("").build();
    //
    // Waitlist.CreateWaitlistEntryResponse response
    //     = Waitlist.CreateWaitlistEntryResponse.newBuilder()
    //         .setWaitlistBusinessLogicFailure(waitlistBusinessLogicFailure).build();
    //
    // return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/GetWaitlistEntry")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String getWaitlistEntry(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    Waitlist.GetWaitlistEntryRequest.Builder requestBuilder
        = Waitlist.GetWaitlistEntryRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    Waitlist.GetWaitlistEntryRequest getWaitlistEntryRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // Normal path: get response object from the helper function
    Waitlist.GetWaitlistEntryResponse response
        = performGetWaitlistEntry(getWaitlistEntryRequest);

    // use JsonFormat to convert protocol buffer to Json
    String jsonResponse = jsonPrinter().print(response);
    return jsonResponse;
  }

  // TODO(partner): Implement this method to return waitlist entry
  private Waitlist.GetWaitlistEntryResponse performGetWaitlistEntry(
      Waitlist.GetWaitlistEntryRequest request) {
    // String waitlistEntryId = request.getWaitlistEntryId();
    //
    // Waitlist.GetWaitlistEntryResponse response = Waitlist.GetWaitlistEntryResponse.newBuilder()
    //     .setWaitlistEntry(WaitlistEntry...).build();
    //
    // return response;

    throw new UnsupportedOperationException("Not implemented yet");
  }

  @Path("/DeleteWaitlistEntry")
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public String deleteWaitlistEntry(String request) throws InvalidProtocolBufferException {

    // use JsonFormat.Parser to convert Json String into protocol buffer
    Waitlist.DeleteWaitlistEntryRequest.Builder requestBuilder
        = Waitlist.DeleteWaitlistEntryRequest.newBuilder();
    JsonFormat.Parser jsonParser = JsonFormat.parser();
    jsonParser.merge(request, requestBuilder);
    Waitlist.DeleteWaitlistEntryRequest deleteWaitlistEntryRequest = requestBuilder.build();

    // Unexpected error: throw exception and handle it in BookingExceptionMapper class,
    // return corresponding response and HTTP code
    //
    // If entry exists, delete it. Otherwise throw 404
    performDeleteWaitlistEntry(deleteWaitlistEntryRequest);

    return "";
  }

  // TODO(partner): Implement this method to return waitlist entry
  private void performDeleteWaitlistEntry(Waitlist.DeleteWaitlistEntryRequest request) {

    // String waitlistEntryId = request.getWaitlistEntryId();
    // If waitlist entry Id exists, delete it
    // If waitlist entry id doesn't exist, return 404
    // throw new WebApplicationException(404);

    throw new UnsupportedOperationException("Not implemented yet");
  }
}