package lv.enes.mc.eris_alchemy.utils;

import jakarta.annotation.Nonnull;

import java.util.Objects;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;

public sealed abstract class ConsList<E> {
	public static <E> ConsList<E> cons(E car, ConsList<E> cdr) {
		return new Cons<>(car, cdr);
	}

	public static <E> ConsList<E> nil() {
		return Nil.of();
	}

	@Nonnull
	public abstract Optional<E> car();

	@Nonnull
	public abstract ConsList<E> cdr();

	public boolean contains(E elem) {
		return stream().anyMatch(x -> Objects.equals(x, elem));
	}

	public Stream<E> stream() {
		var car = car();
		if (car.isEmpty()) {
			return Stream.empty();
		}

		return Stream.<Supplier<Stream<E>>>of(
						() -> Stream.of(car.get()),
						() -> cdr().stream()
				)
				.flatMap(Supplier::get);
	}

	@Override
	public String toString() {
		if (car().isEmpty()) {
			return "[]";
		}

		var sb = new StringBuilder("[");
		sb.append(car().get());
		stream().skip(1)
				.forEach(x -> {
					sb.append(" -> ");
					sb.append(x);
				});
		sb.append("]");
		return sb.toString();
	}

	private static final class Cons<E> extends ConsList<E> {
		private final E car;
		private final ConsList<E> cdr;

		public Cons(E car, ConsList<E> cdr) {
			this.car = car;
			this.cdr = cdr;
		}

		@Nonnull
		@Override
		public Optional<E> car() {
			return Optional.of(car);
		}

		@Nonnull
		@Override
		public ConsList<E> cdr() {
			return cdr;
		}
	}

	private static final class Nil<E> extends ConsList<E> {
		private static final Nil<?> INSTANCE = new Nil<>();

		@SuppressWarnings("unchecked")
		public static <E> Nil<E> of() {
			return (Nil<E>)INSTANCE;
		}

		private Nil(){}

		@Nonnull
		@Override
		public Optional<E> car() {
			return Optional.empty();
		}

		@Nonnull
		@Override
		public ConsList<E> cdr() {
			return Nil.of();
		}
	}
}