package org.sxkj.common.func;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.util.Assert;

import java.lang.RuntimeException;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class Streams {

	public static <T> Stream<T> stream(List<T> elements) {
		return CollectionUtils.isNotEmpty(elements) ? elements.stream() : Stream.empty();
	}

	public static <T> T first(Collection<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).findFirst().orElse(null);
		}
		return null;
	}

	public static <T> Stream<T> stream(List<T> elements, boolean parallel) {
		if (CollectionUtils.isNotEmpty(elements)) {
			return StreamSupport.stream(elements.spliterator(), parallel);
		}
		return Stream.empty();
	}

	public static <T, R> long countBy(List<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).count();
		}
		return 0;
	}

	public static <T, R> List<R> toList(T[] elements, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (ArrayUtils.isNotEmpty(elements)) {
			return Arrays.stream(elements).map(mapper).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <T, R> Set<R> toSet(Set<T> elements, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().map(mapper).collect(Collectors.toSet());
		}
		return Sets.newHashSet();
	}

	public static <T> List<T> forEach(List<T> elements, Consumer<T> consumer) {
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			elements.forEach(consumer);
			return elements;
		}
		return Lists.newArrayList();
	}

	public static <T> void forEach(Collection<T> elements, Consumer<T> consumer) {
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			elements.forEach(consumer);
		}
	}

	public static <T> List<T> forEach(List<T> elements, Predicate<T> predicate, Consumer<T> consumer) {
		Assert.notNull(consumer, "consumer cannot be not empty!");
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			elements.stream().filter(predicate).forEach(consumer);
			return elements;
		}
		return Lists.newArrayList();
	}

	public static <T, R> Set<R> toSet(List<T> elements, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().map(mapper).collect(Collectors.toSet());
		}
		return Sets.newHashSet();
	}

	public static <T> List<T> filter(List<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <K, V, R> R evalAs(Map<K, V> map, K key, Function<V, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
			return Optional.of(map.get(key)).map(mapper).orElse(null);
		}
		return null;
	}

	public static <T> IPage<T> toPage(IPage<T> page, Consumer<List<T>> consumer) {
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(page.getRecords())) {
			consumer.accept(page.getRecords());
		}
		return page;
	}

	public static <T, R> IPage toPage(IPage<T> page, Function<T, R> mapper) {
		Assert.notNull(mapper, "function cannot be not empty!");

		if (CollectionUtils.isNotEmpty(page.getRecords())) {
			List records = page.getRecords();
			Object collect = records.stream()
				.map(mapper)
				.collect(Collectors.toList());
			page.setRecords((List) collect);
		}
		return page;
	}

	public static <T, R> List<R> toList(Collection<T> elements, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().map(mapper).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <T> boolean anyMatch(Collection<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().anyMatch(predicate);
		}
		return false;
	}

	public static <T> void doContinue(Collection<T> elements, Predicate<T> predicate, Consumer<List<T>> consumer) {
		Assert.notNull(predicate, "predicate cannot be not empty!");
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements) && elements.stream().anyMatch(predicate)) {
			consumer.accept(elements.stream().filter(predicate).collect(Collectors.toList()));
		}
	}

	public static <T> boolean allMatch(Collection<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().allMatch(predicate);
		}
		return false;
	}

	public static <T> boolean noneMatch(Collection<T> elements, Predicate<T> predicate) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().noneMatch(predicate);
		}
		return false;
	}

	public static <K, V> void ifPresent(Map<K, V> map, K key, Consumer<V> consumer) {
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
			Optional.ofNullable(map.get(key)).ifPresent(consumer);
		}
	}

	public static <T> void nonAccept(List<T> elements, Consumer<List<T>> recordConsumer) {
		Assert.notNull(recordConsumer, "recordConsumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			recordConsumer.accept(elements);
		}
	}

	public static <R> R reduce(List<R> elements, R identity, BinaryOperator<R> accumulator) {
		Assert.notNull(identity, "identity cannot be not empty!");
		Assert.notNull(accumulator, "accumulator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().reduce(identity, accumulator);
		}
		return identity;
	}

	public static <T, K> Map<K, List<T>> groupBy(List<T> elements, Function<T, K> classifier) {
		Assert.notNull(classifier, "classifier cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().collect(Collectors.groupingBy(classifier));
		}
		return Maps.newHashMap();
	}

	public static <K, V, R> Set<R> toSet(Map<K, V> map, Function<Map.Entry<K, V>, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (map != null && !map.isEmpty()) {
			return map.entrySet().stream().map(mapper).collect(Collectors.toSet());
		}
		return Sets.newHashSet();
	}

	public static <K, V, R> List<R> toList(Map<K, V> map, Function<Map.Entry<K, V>, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");

		if (MapUtils.isNotEmpty(map)) {
			return map.entrySet().stream().map(mapper).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <T> void ifPresent(Collection<T> elements, Predicate<T> predicate, Consumer<T> consumer) {
		Assert.notNull(predicate, "predicate cannot be not empty!");
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			elements.stream().filter(predicate).findFirst().ifPresent(consumer);
		}
	}

	public static <T, R> Set<R> toSet(List<T> elements, Predicate<T> predicate, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).map(mapper).collect(Collectors.toSet());
		}
		return Sets.newHashSet();
	}

	public static <K, V, R> Set<R> toSet(Map<K, V> map, Predicate<Map.Entry<K, V>> predicate, Function<Map.Entry<K, V>, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (map != null && !map.isEmpty()) {
			return map.entrySet().stream().filter(predicate).map(mapper).collect(Collectors.toSet());
		}
		return Sets.newHashSet();
	}

	public static <T> T firstOrDefault(List<T> elements, Predicate<T> predicate, Supplier<T> supplier) {
		Assert.notNull(predicate, "predicate cannot be not empty!");
		Assert.notNull(supplier, "supplier cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).findFirst().orElseGet(supplier);
		}
		return supplier.get();
	}

	public static <K, V, R> R evalAs(Map<K, V> map, K key, Function<V, R> mapper, R defaultValue) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(defaultValue, "defaultValue cannot be not empty!");

		if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
			return Optional.of(map.get(key)).map(mapper).orElse(defaultValue);
		}
		return defaultValue;
	}

	public static <K, V, R> R evalAs(Map<K, V> map, K key, Function<V, R> mapper, Supplier<R> supplier) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(supplier, "supplier cannot be not empty!");

		if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
			return Optional.of(map.get(key)).map(mapper).orElseGet(supplier);
		}
		return supplier.get();
	}

	public static <T, R> List<R> toList(List<T> elements, Predicate<T> predicate, Function<T, R> mapper) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).map(mapper).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <T> List<T> toSorted(List<T> elements, Comparator<T> comparator) {
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().sorted(comparator).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <T, R> List<R> toSorted(List<T> elements, Function<T, R> mapper, Comparator<R> comparator) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().map(mapper).sorted(comparator).collect(Collectors.toList());
		}
		return Lists.newArrayList();
	}

	public static <K, V> void ifPresent(Map<K, List<V>> map, K key, Predicate<V> predicate, Consumer<V> consumer) {
		Assert.notNull(predicate, "predicate cannot be not empty!");
		Assert.notNull(consumer, "consumer cannot be not empty!");

		if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
			map.get(key).stream().filter(predicate).findFirst().ifPresent(consumer);
		}
	}

	public static <T, K, U> Map<K, U> toMap(List<T> elements, Function<T, K> keyMapper, Function<T, U> valueMapper) {
		if (CollectionUtils.isNotEmpty(elements) && keyMapper != null && valueMapper != null) {
			return elements.stream().collect(Collectors.toMap(keyMapper, valueMapper));
		}
		return Maps.newHashMap();
	}

	public static <T, K, U> Map<K, U> toMap(T[] elements, Function<T, K> keyMapper, Function<T, U> valueMapper) {
		if (ArrayUtils.isNotEmpty(elements) && keyMapper != null && valueMapper != null) {
			return Arrays.stream(elements).collect(Collectors.toMap(keyMapper, valueMapper));
		}
		return Maps.newHashMap();
	}

	public static <T, K, U, M extends Map<K, U>> Map<K, U> toMap(List<T> elements, Function<T, K> keyMapper, Function<T, U> valueMapper, BinaryOperator<U> mergeFunction) {
		if (CollectionUtils.isNotEmpty(elements) && keyMapper != null && valueMapper != null && mergeFunction != null) {
			return elements.stream().collect(Collectors.toMap(keyMapper, valueMapper, mergeFunction));
		}
		return Maps.newHashMap();
	}

	public static <T, K, U, M extends Map<K, U>> Map<K, U> toMap(List<T> elements, Function<T, K> keyMapper, Function<T, U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) {
		if (CollectionUtils.isNotEmpty(elements) && keyMapper != null && valueMapper != null && mergeFunction != null && mapSupplier != null) {
			return elements.stream().collect(Collectors.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier));
		}
		return Maps.newLinkedHashMap();
	}

	public static <T, K> Map<K, List<T>> groupBy(List<T> elements, Predicate<T> predicate, Function<T, K> classifier) {
		if (CollectionUtils.isNotEmpty(elements) && predicate != null && classifier != null) {
			return elements.stream().filter(predicate).collect(Collectors.groupingBy(classifier));
		}
		return Maps.newHashMap();
	}

	/**
	 * 分组后计算总数
	 */
	public static <T, R> Map<R, Long> groupByCount(List<T> elements, Function<T, R> mapper) {
		if (CollectionUtils.isNotEmpty(elements) && mapper != null) {
			return elements.stream().map(mapper).collect(Collectors.groupingBy(
				e -> e,
				Collectors.counting()
			));
		}
		return Maps.newHashMap();
	}


	public static <T, R> R reduce(List<T> elements, Function<T, R> mapper, R identity, BinaryOperator<R> accumulator) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(identity, "identity cannot be not empty!");
		Assert.notNull(accumulator, "accumulator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().map(mapper).reduce(identity, accumulator);
		}
		return identity;
	}

	public static <T, R> R reduce(List<T> elements, Predicate<T> predicate, Function<T, R> mapper, R identity, BinaryOperator<R> accumulator) {
		Assert.notNull(mapper, "mapper cannot be not empty!");
		Assert.notNull(identity, "identity cannot be not empty!");
		Assert.notNull(predicate, "predicate cannot be not empty!");
		Assert.notNull(accumulator, "accumulator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).map(mapper).reduce(identity, accumulator);
		}
		return identity;
	}

	public static <T> T minOrThrow(List<T> elements, Comparator<T> comparator, String exMessage) {
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().min(comparator).orElseThrow(() -> new RuntimeException(exMessage));
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T> T maxOrThrow(List<T> elements, Comparator<T> comparator, String exMessage) {
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().max(comparator).orElseThrow(() -> new java.lang.RuntimeException(exMessage));
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T> T firstOrThrow(List<T> elements, Predicate<T> predicate, String exMessage) {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).findFirst().orElseThrow(() -> new RuntimeException(exMessage));
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T, X extends Throwable> T firstOrThrow(List<T> elements, Predicate<T> predicate, Supplier<X> exceptionSupplier) throws X {
		Assert.notNull(predicate, "predicate cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().filter(predicate).findFirst().orElseThrow(exceptionSupplier);
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T, X extends Throwable> T minOrThrow(List<T> elements, Comparator<T> comparator, Supplier<X> exceptionSupplier) throws X {
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().min(comparator).orElseThrow(exceptionSupplier);
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T, X extends Throwable> T maxOrThrow(List<T> elements, Comparator<T> comparator, Supplier<X> exceptionSupplier) throws X {
		Assert.notNull(comparator, "comparator cannot be not empty!");

		if (CollectionUtils.isNotEmpty(elements)) {
			return elements.stream().max(comparator).orElseThrow(exceptionSupplier);
		}
		throw new RuntimeException("elements cannot be not empty!");
	}

	public static <T, K, U> Map<K, U> toMap(List<T> elements, Predicate<T> predicate, Function<T, K> keyMapper, Function<T, U> valueMapper) {
		if (CollectionUtils.isNotEmpty(elements) && predicate != null && keyMapper != null && valueMapper != null) {
			return elements.stream().filter(predicate).collect(Collectors.toMap(keyMapper, valueMapper));
		}
		return Maps.newHashMap();
	}

	public static <T, R> void doPartition(Collection<T> collection, Consumer<List<T>> consumer, int stepSize) {
		Assert.notEmpty(collection, "collection cannot be not empty");

		List<List<T>> partitionList = Lists.partition(Lists.newArrayList(collection), stepSize);
		for (List<T> partition : partitionList) {
			consumer.accept(partition);
		}
	}

	public static <T> void doWhile(Function<IPage<?>, List<T>> recordPageFunction, Consumer<List<T>> recordConsumer, long batchSize) {
		Assert.notNull(recordConsumer, "recordConsumer cannot be not empty!");
		Assert.notNull(recordPageFunction, "recordPageFunction cannot be not empty!");

		Page<?> page;
		long current = 1;
		List<T> batchRecords;
		boolean hasNextPage = false;
		long size = batchSize > 0 ? batchSize : 10;
		do {
			page = Page.of(current, size, Boolean.FALSE);
			batchRecords = recordPageFunction.apply(page);
			if (CollectionUtils.isNotEmpty(batchRecords)) {
				recordConsumer.accept(batchRecords);
				hasNextPage = batchRecords.size() >= size;
			}
			current++;

		} while (CollectionUtils.isNotEmpty(batchRecords) && hasNextPage);
	}

	/**
	 * 数据进行平铺
	 *
	 * @param collections 二维数组平铺
	 * @param <T>         类型
	 * @return 一维数据
	 */
	public static <T> List<T> flatMap(List<List<T>> collections) {
		if (CollectionUtils.isEmpty(collections)) {
			return Lists.newArrayList();
		}
		return collections.stream()
			.filter(Objects::nonNull)
			.flatMap(List::stream)
			.filter(Objects::nonNull)
			.collect(Collectors.toList());
	}





}