package net.minecraft.util.datafix.fixes;

import com.mojang.brigadier.StringReader;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.datafixers.DataFix;
import com.mojang.datafixers.TypeRewriteRule;
import com.mojang.datafixers.schemas.Schema;
import com.mojang.datafixers.types.Type;
import com.mojang.logging.LogUtils;
import com.mojang.serialization.Dynamic;
import com.mojang.serialization.DynamicOps;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import net.minecraft.nbt.TagParser;
import net.minecraft.util.Mth;
import net.minecraft.util.datafix.schemas.NamespacedSchema;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;

public class ParticleUnflatteningFix extends DataFix {
	private static final Logger LOGGER = LogUtils.getLogger();

	public ParticleUnflatteningFix(Schema outputSchema) {
		super(outputSchema, true);
	}

	@Override
	protected TypeRewriteRule makeRule() {
		Type<?> type = this.getInputSchema().getType(References.PARTICLE);
		Type<?> type2 = this.getOutputSchema().getType(References.PARTICLE);
		return this.writeFixAndRead("ParticleUnflatteningFix", type, type2, this::fix);
	}

	private <T> Dynamic<T> fix(Dynamic<T> tag) {
		Optional<String> optional = tag.asString().result();
		if (optional.isEmpty()) {
			return tag;
		} else {
			String string = (String)optional.get();
			String[] strings = string.split(" ", 2);
			String string2 = NamespacedSchema.ensureNamespaced(strings[0]);
			Dynamic<T> dynamic = tag.createMap(Map.of(tag.createString("type"), tag.createString(string2)));

			return switch (string2) {
				case "minecraft:item" -> strings.length > 1 ? this.updateItem(dynamic, strings[1]) : dynamic;
				case "minecraft:block", "minecraft:block_marker", "minecraft:falling_dust", "minecraft:dust_pillar" -> strings.length > 1
					? this.updateBlock(dynamic, strings[1])
					: dynamic;
				case "minecraft:dust" -> strings.length > 1 ? this.updateDust(dynamic, strings[1]) : dynamic;
				case "minecraft:dust_color_transition" -> strings.length > 1 ? this.updateDustTransition(dynamic, strings[1]) : dynamic;
				case "minecraft:sculk_charge" -> strings.length > 1 ? this.updateSculkCharge(dynamic, strings[1]) : dynamic;
				case "minecraft:vibration" -> strings.length > 1 ? this.updateVibration(dynamic, strings[1]) : dynamic;
				case "minecraft:shriek" -> strings.length > 1 ? this.updateShriek(dynamic, strings[1]) : dynamic;
				default -> dynamic;
			};
		}
	}

	private <T> Dynamic<T> updateItem(Dynamic<T> tag, String item) {
		int i = item.indexOf("{");
		Dynamic<T> dynamic = tag.createMap(Map.of(tag.createString("Count"), tag.createInt(1)));
		if (i == -1) {
			dynamic = dynamic.set("id", tag.createString(item));
		} else {
			dynamic = dynamic.set("id", tag.createString(item.substring(0, i)));
			Dynamic<T> dynamic2 = parseTag(tag.getOps(), item.substring(i));
			if (dynamic2 != null) {
				dynamic = dynamic.set("tag", dynamic2);
			}
		}

		return tag.set("item", dynamic);
	}

	@Nullable
	private static <T> Dynamic<T> parseTag(DynamicOps<T> ops, String tag) {
		try {
			return new Dynamic<>(ops, TagParser.create(ops).parseFully(tag));
		} catch (Exception var3) {
			LOGGER.warn("Failed to parse tag: {}", tag, var3);
			return null;
		}
	}

	private <T> Dynamic<T> updateBlock(Dynamic<T> tag, String block) {
		int i = block.indexOf("[");
		Dynamic<T> dynamic = tag.emptyMap();
		if (i == -1) {
			dynamic = dynamic.set("Name", tag.createString(NamespacedSchema.ensureNamespaced(block)));
		} else {
			dynamic = dynamic.set("Name", tag.createString(NamespacedSchema.ensureNamespaced(block.substring(0, i))));
			Map<Dynamic<T>, Dynamic<T>> map = parseBlockProperties(tag, block.substring(i));
			if (!map.isEmpty()) {
				dynamic = dynamic.set("Properties", tag.createMap(map));
			}
		}

		return tag.set("block_state", dynamic);
	}

	private static <T> Map<Dynamic<T>, Dynamic<T>> parseBlockProperties(Dynamic<T> tag, String properties) {
		try {
			Map<Dynamic<T>, Dynamic<T>> map = new HashMap();
			StringReader stringReader = new StringReader(properties);
			stringReader.expect('[');
			stringReader.skipWhitespace();

			while (stringReader.canRead() && stringReader.peek() != ']') {
				stringReader.skipWhitespace();
				String string = stringReader.readString();
				stringReader.skipWhitespace();
				stringReader.expect('=');
				stringReader.skipWhitespace();
				String string2 = stringReader.readString();
				stringReader.skipWhitespace();
				map.put(tag.createString(string), tag.createString(string2));
				if (stringReader.canRead()) {
					if (stringReader.peek() != ',') {
						break;
					}

					stringReader.skip();
				}
			}

			stringReader.expect(']');
			return map;
		} catch (Exception var6) {
			LOGGER.warn("Failed to parse block properties: {}", properties, var6);
			return Map.of();
		}
	}

	private static <T> Dynamic<T> readVector(Dynamic<T> tag, StringReader reader) throws CommandSyntaxException {
		float f = reader.readFloat();
		reader.expect(' ');
		float g = reader.readFloat();
		reader.expect(' ');
		float h = reader.readFloat();
		return tag.createList(Stream.of(f, g, h).map(tag::createFloat));
	}

	private <T> Dynamic<T> updateDust(Dynamic<T> tag, String options) {
		try {
			StringReader stringReader = new StringReader(options);
			Dynamic<T> dynamic = readVector(tag, stringReader);
			stringReader.expect(' ');
			float f = stringReader.readFloat();
			return tag.set("color", dynamic).set("scale", tag.createFloat(f));
		} catch (Exception var6) {
			LOGGER.warn("Failed to parse particle options: {}", options, var6);
			return tag;
		}
	}

	private <T> Dynamic<T> updateDustTransition(Dynamic<T> tag, String options) {
		try {
			StringReader stringReader = new StringReader(options);
			Dynamic<T> dynamic = readVector(tag, stringReader);
			stringReader.expect(' ');
			float f = stringReader.readFloat();
			stringReader.expect(' ');
			Dynamic<T> dynamic2 = readVector(tag, stringReader);
			return tag.set("from_color", dynamic).set("to_color", dynamic2).set("scale", tag.createFloat(f));
		} catch (Exception var7) {
			LOGGER.warn("Failed to parse particle options: {}", options, var7);
			return tag;
		}
	}

	private <T> Dynamic<T> updateSculkCharge(Dynamic<T> tag, String options) {
		try {
			StringReader stringReader = new StringReader(options);
			float f = stringReader.readFloat();
			return tag.set("roll", tag.createFloat(f));
		} catch (Exception var5) {
			LOGGER.warn("Failed to parse particle options: {}", options, var5);
			return tag;
		}
	}

	private <T> Dynamic<T> updateVibration(Dynamic<T> tag, String options) {
		try {
			StringReader stringReader = new StringReader(options);
			float f = (float)stringReader.readDouble();
			stringReader.expect(' ');
			float g = (float)stringReader.readDouble();
			stringReader.expect(' ');
			float h = (float)stringReader.readDouble();
			stringReader.expect(' ');
			int i = stringReader.readInt();
			Dynamic<T> dynamic = (Dynamic<T>)tag.createIntList(IntStream.of(new int[]{Mth.floor(f), Mth.floor(g), Mth.floor(h)}));
			Dynamic<T> dynamic2 = tag.createMap(Map.of(tag.createString("type"), tag.createString("minecraft:block"), tag.createString("pos"), dynamic));
			return tag.set("destination", dynamic2).set("arrival_in_ticks", tag.createInt(i));
		} catch (Exception var10) {
			LOGGER.warn("Failed to parse particle options: {}", options, var10);
			return tag;
		}
	}

	private <T> Dynamic<T> updateShriek(Dynamic<T> tag, String options) {
		try {
			StringReader stringReader = new StringReader(options);
			int i = stringReader.readInt();
			return tag.set("delay", tag.createInt(i));
		} catch (Exception var5) {
			LOGGER.warn("Failed to parse particle options: {}", options, var5);
			return tag;
		}
	}
}