package net.minecraft.server.packs.repository;

import com.mojang.logging.LogUtils;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import net.minecraft.network.chat.Component;
import net.minecraft.resources.Identifier;
import net.minecraft.server.packs.PackLocationInfo;
import net.minecraft.server.packs.PackResources;
import net.minecraft.server.packs.PackType;
import net.minecraft.server.packs.VanillaPackResources;
import net.minecraft.world.level.validation.DirectoryValidator;
import org.apache.commons.lang3.StringUtils;
import org.jspecify.annotations.Nullable;
import org.slf4j.Logger;

public abstract class BuiltInPackSource implements RepositorySource {
	private static final Logger LOGGER = LogUtils.getLogger();
	public static final String VANILLA_ID = "vanilla";
	public static final String TESTS_ID = "tests";
	public static final KnownPack CORE_PACK_INFO = KnownPack.vanilla("core");
	private final PackType packType;
	private final VanillaPackResources vanillaPack;
	private final Identifier packDir;
	private final DirectoryValidator validator;

	public BuiltInPackSource(final PackType packType, final VanillaPackResources vanillaPack, final Identifier packDir, final DirectoryValidator validator) {
		this.packType = packType;
		this.vanillaPack = vanillaPack;
		this.packDir = packDir;
		this.validator = validator;
	}

	@Override
	public void loadPacks(final Consumer<Pack> result) {
		Pack vanilla = this.createVanillaPack(this.vanillaPack);
		if (vanilla != null) {
			result.accept(vanilla);
		}

		this.listBundledPacks(result);
	}

	@Nullable
	protected abstract Pack createVanillaPack(final PackResources resources);

	protected abstract Component getPackTitle(final String id);

	public VanillaPackResources getVanillaPack() {
		return this.vanillaPack;
	}

	private void listBundledPacks(final Consumer<Pack> packConsumer) {
		Map<String, Function<String, Pack>> discoveredPacks = new HashMap();
		this.populatePackList(discoveredPacks::put);
		discoveredPacks.forEach((id, packSupplier) -> {
			Pack pack = (Pack)packSupplier.apply(id);
			if (pack != null) {
				packConsumer.accept(pack);
			}
		});
	}

	protected void populatePackList(final BiConsumer<String, Function<String, Pack>> discoveredPacks) {
		this.vanillaPack.listRawPaths(this.packType, this.packDir, path -> this.discoverPacksInPath(path, discoveredPacks));
	}

	protected void discoverPacksInPath(@Nullable final Path targetDir, final BiConsumer<String, Function<String, Pack>> discoveredPacks) {
		if (targetDir != null && Files.isDirectory(targetDir, new LinkOption[0])) {
			try {
				FolderRepositorySource.discoverPacks(
					targetDir,
					this.validator,
					(path, resources) -> discoveredPacks.accept(pathToId(path), (Function)id -> this.createBuiltinPack(id, resources, this.getPackTitle(id)))
				);
			} catch (IOException var4) {
				LOGGER.warn("Failed to discover packs in {}", targetDir, var4);
			}
		}
	}

	private static String pathToId(final Path path) {
		return StringUtils.removeEnd(path.getFileName().toString(), ".zip");
	}

	@Nullable
	protected abstract Pack createBuiltinPack(final String id, final Pack.ResourcesSupplier resources, final Component name);

	protected static Pack.ResourcesSupplier fixedResources(final PackResources instance) {
		return new Pack.ResourcesSupplier() {
			@Override
			public PackResources openPrimary(final PackLocationInfo location) {
				return instance;
			}

			@Override
			public PackResources openFull(final PackLocationInfo location, final Pack.Metadata metadata) {
				return instance;
			}
		};
	}
}