package org.warp.commonutils.type;

import java.util.Collection;
import java.util.Iterator;
import java.util.Queue;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull;

@SuppressWarnings("unused")
public class FloatPriorityQueueView<T> implements Queue<T> {

	private final FloatPriorityQueue<? super T> queue;

	public FloatPriorityQueueView(FloatPriorityQueue<? super T> queue) {
		this.queue = queue;
	}

	public static <T> BiFunction<FloatPriorityQueueView<T>, FloatPriorityQueueView<T>, FloatPriorityQueueView<T>> aggregator() {
		return (a, b) -> {
			var fpq = new FloatPriorityQueue<>();
			a.forEachItem(fpq::offer);
			b.forEachItem(fpq::offer);
			return new FloatPriorityQueueView<>(fpq);
		};
	}

	public static <T> FloatPriorityQueueView<T> of() {
		return new FloatPriorityQueueView<>(FloatPriorityQueue.of());
	}

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

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

	@Override
	public boolean contains(Object o) {
		return queue.contains(o);
	}

	@NotNull
	@Override
	public Iterator<T> iterator() {
		var it = queue.iterator();
		return new Iterator<>() {
			@Override
			public boolean hasNext() {
				return it.hasNext();
			}

			@SuppressWarnings("unchecked")
			@Override
			public T next() {
				return (T) it.next();
			}
		};
	}

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

	@NotNull
	@Override
	public <T1> T1 @NotNull [] toArray(@NotNull T1 @NotNull [] a) {
		//noinspection SuspiciousToArrayCall
		return queue.toArray(a);
	}

	@Override
	public boolean containsAll(@NotNull Collection<?> c) {
		return queue.containsAll(c);
	}

	@Override
	public boolean addAll(@NotNull Collection<? extends T> c) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public boolean removeAll(@NotNull Collection<?> c) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public boolean retainAll(@NotNull Collection<?> c) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public void clear() {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public boolean add(T t) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public boolean remove(Object o) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public boolean offer(T t) {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public T remove() {
		throw new UnsupportedOperationException("Read-only");
	}

	@Override
	public T poll() {
		throw new UnsupportedOperationException("Read-only");
	}

	@SuppressWarnings("unchecked")
	@Override
	public T element() {
		return (T) queue.element();
	}

	@SuppressWarnings("unchecked")
	@Override
	public T peek() {
		return (T) queue.peek();
	}

	@SuppressWarnings("unchecked")
	public void forEachItem(Consumer<ScoredValue<T>> action) {
		queue.forEachItem((v) -> action.accept((ScoredValue<T>) v));
	}

	@SuppressWarnings("unchecked")
	public Stream<ScoredValue<T>> streamItems() {
		return queue.streamItems().map(t -> (ScoredValue<T>) t);
	}
}