/*
 * Copyright 2015-present Facebook, Inc.
 *
 * Licensed 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 com.facebook.buck.util.concurrent;

import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

/**
 * An implementation of {@link BlockingQueue} interface returning elements in LIFO order.
 *
 * @param <E> Type of contained elements.
 */
public class LinkedBlockingStack<E> implements BlockingQueue<E> {

  private final LinkedBlockingDeque<E> delegate;

  public LinkedBlockingStack() {
    delegate = new LinkedBlockingDeque<>();
  }

  @Override
  public boolean add(E element) {
    delegate.addFirst(element);
    return true;
  }

  @Override
  public boolean offer(E element) {
    return delegate.offerFirst(element);
  }

  @Override
  public E remove() {
    return delegate.removeFirst();
  }

  @Override
  public E poll() {
    return delegate.pollFirst();
  }

  @Override
  public E element() {
    return delegate.getFirst();
  }

  @Override
  public E peek() {
    return delegate.peekFirst();
  }

  @Override
  public void put(E element) throws InterruptedException {
    delegate.putFirst(element);
  }

  @Override
  public boolean offer(E element, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate.offerFirst(element, timeout, unit);
  }

  @Override
  public E take() throws InterruptedException {
    return delegate.takeFirst();
  }

  @Override
  public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate.pollFirst(timeout, unit);
  }

  @Override
  public int remainingCapacity() {
    return delegate.remainingCapacity();
  }

  @Override
  public boolean remove(Object object) {
    return delegate.remove(object);
  }

  @Override
  public boolean addAll(Collection<? extends E> collection) {
    boolean modified = false;
    for (E element : collection) {
      if (add(element)) {
        modified = true;
      }
    }
    return modified;
  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public boolean retainAll(Collection<?> collection) {
    return delegate.retainAll(collection);
  }

  @Override
  public boolean removeAll(Collection<?> collection) {
    return delegate.removeAll(collection);
  }

  @Override
  public boolean containsAll(Collection<?> collection) {
    return delegate.containsAll(collection);
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public boolean contains(Object object) {
    return delegate.contains(object);
  }

  @Override
  public Iterator<E> iterator() {
    return delegate.iterator();
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override
  public <T> T[] toArray(T[] array) {
    return delegate.toArray(array);
  }

  @Override
  public int drainTo(Collection<? super E> collection) {
    return delegate.drainTo(collection);
  }

  @Override
  public int drainTo(Collection<? super E> collection, int maxElements) {
    return delegate.drainTo(collection, maxElements);
  }
}