package net.minecraft.world.level.biome;

import com.mojang.serialization.Codec;
import com.mojang.serialization.codecs.RecordCodecBuilder;
import java.util.Optional;
import java.util.OptionalInt;
import net.minecraft.core.Holder;
import net.minecraft.sounds.Music;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.util.StringRepresentable;
import org.jetbrains.annotations.Nullable;

public class BiomeSpecialEffects {
	public static final Codec<BiomeSpecialEffects> CODEC = RecordCodecBuilder.create(
		instance -> instance.group(
				Codec.INT.fieldOf("fog_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.fogColor),
				Codec.INT.fieldOf("water_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.waterColor),
				Codec.INT.fieldOf("water_fog_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.waterFogColor),
				Codec.INT.fieldOf("sky_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.skyColor),
				Codec.INT.optionalFieldOf("foliage_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.foliageColorOverride),
				Codec.INT.optionalFieldOf("grass_color").forGetter(biomeSpecialEffects -> biomeSpecialEffects.grassColorOverride),
				BiomeSpecialEffects.GrassColorModifier.CODEC
					.optionalFieldOf("grass_color_modifier", BiomeSpecialEffects.GrassColorModifier.NONE)
					.forGetter(biomeSpecialEffects -> biomeSpecialEffects.grassColorModifier),
				AmbientParticleSettings.CODEC.optionalFieldOf("particle").forGetter(biomeSpecialEffects -> biomeSpecialEffects.ambientParticleSettings),
				SoundEvent.CODEC.optionalFieldOf("ambient_sound").forGetter(biomeSpecialEffects -> biomeSpecialEffects.ambientLoopSoundEvent),
				AmbientMoodSettings.CODEC.optionalFieldOf("mood_sound").forGetter(biomeSpecialEffects -> biomeSpecialEffects.ambientMoodSettings),
				AmbientAdditionsSettings.CODEC.optionalFieldOf("additions_sound").forGetter(biomeSpecialEffects -> biomeSpecialEffects.ambientAdditionsSettings),
				Music.CODEC.optionalFieldOf("music").forGetter(biomeSpecialEffects -> biomeSpecialEffects.backgroundMusic)
			)
			.apply(instance, BiomeSpecialEffects::new)
	);
	private final int fogColor;
	private final int waterColor;
	private final int waterFogColor;
	private final int skyColor;
	private final Optional<Integer> foliageColorOverride;
	private final Optional<Integer> grassColorOverride;
	private final BiomeSpecialEffects.GrassColorModifier grassColorModifier;
	private final Optional<AmbientParticleSettings> ambientParticleSettings;
	private final Optional<Holder<SoundEvent>> ambientLoopSoundEvent;
	private final Optional<AmbientMoodSettings> ambientMoodSettings;
	private final Optional<AmbientAdditionsSettings> ambientAdditionsSettings;
	private final Optional<Music> backgroundMusic;

	BiomeSpecialEffects(
		int fogColor,
		int waterColor,
		int waterFogColor,
		int skyColor,
		Optional<Integer> foliageColorOverride,
		Optional<Integer> grassColorOverride,
		BiomeSpecialEffects.GrassColorModifier grassColorModifier,
		Optional<AmbientParticleSettings> ambientParticleSettings,
		Optional<Holder<SoundEvent>> ambientLoopSoundEvent,
		Optional<AmbientMoodSettings> ambientMoodSettings,
		Optional<AmbientAdditionsSettings> ambientAdditionsSettings,
		Optional<Music> backgroundMusic
	) {
		this.fogColor = fogColor;
		this.waterColor = waterColor;
		this.waterFogColor = waterFogColor;
		this.skyColor = skyColor;
		this.foliageColorOverride = foliageColorOverride;
		this.grassColorOverride = grassColorOverride;
		this.grassColorModifier = grassColorModifier;
		this.ambientParticleSettings = ambientParticleSettings;
		this.ambientLoopSoundEvent = ambientLoopSoundEvent;
		this.ambientMoodSettings = ambientMoodSettings;
		this.ambientAdditionsSettings = ambientAdditionsSettings;
		this.backgroundMusic = backgroundMusic;
	}

	public int getFogColor() {
		return this.fogColor;
	}

	public int getWaterColor() {
		return this.waterColor;
	}

	public int getWaterFogColor() {
		return this.waterFogColor;
	}

	public int getSkyColor() {
		return this.skyColor;
	}

	public Optional<Integer> getFoliageColorOverride() {
		return this.foliageColorOverride;
	}

	public Optional<Integer> getGrassColorOverride() {
		return this.grassColorOverride;
	}

	public BiomeSpecialEffects.GrassColorModifier getGrassColorModifier() {
		return this.grassColorModifier;
	}

	public Optional<AmbientParticleSettings> getAmbientParticleSettings() {
		return this.ambientParticleSettings;
	}

	public Optional<Holder<SoundEvent>> getAmbientLoopSoundEvent() {
		return this.ambientLoopSoundEvent;
	}

	public Optional<AmbientMoodSettings> getAmbientMoodSettings() {
		return this.ambientMoodSettings;
	}

	public Optional<AmbientAdditionsSettings> getAmbientAdditionsSettings() {
		return this.ambientAdditionsSettings;
	}

	public Optional<Music> getBackgroundMusic() {
		return this.backgroundMusic;
	}

	public static class Builder {
		private OptionalInt fogColor = OptionalInt.empty();
		private OptionalInt waterColor = OptionalInt.empty();
		private OptionalInt waterFogColor = OptionalInt.empty();
		private OptionalInt skyColor = OptionalInt.empty();
		private Optional<Integer> foliageColorOverride = Optional.empty();
		private Optional<Integer> grassColorOverride = Optional.empty();
		private BiomeSpecialEffects.GrassColorModifier grassColorModifier = BiomeSpecialEffects.GrassColorModifier.NONE;
		private Optional<AmbientParticleSettings> ambientParticle = Optional.empty();
		private Optional<Holder<SoundEvent>> ambientLoopSoundEvent = Optional.empty();
		private Optional<AmbientMoodSettings> ambientMoodSettings = Optional.empty();
		private Optional<AmbientAdditionsSettings> ambientAdditionsSettings = Optional.empty();
		private Optional<Music> backgroundMusic = Optional.empty();

		public BiomeSpecialEffects.Builder fogColor(int fogColor) {
			this.fogColor = OptionalInt.of(fogColor);
			return this;
		}

		public BiomeSpecialEffects.Builder waterColor(int waterColor) {
			this.waterColor = OptionalInt.of(waterColor);
			return this;
		}

		public BiomeSpecialEffects.Builder waterFogColor(int waterFogColor) {
			this.waterFogColor = OptionalInt.of(waterFogColor);
			return this;
		}

		public BiomeSpecialEffects.Builder skyColor(int skyColor) {
			this.skyColor = OptionalInt.of(skyColor);
			return this;
		}

		public BiomeSpecialEffects.Builder foliageColorOverride(int foliageColorOverride) {
			this.foliageColorOverride = Optional.of(foliageColorOverride);
			return this;
		}

		public BiomeSpecialEffects.Builder grassColorOverride(int grassColorOverride) {
			this.grassColorOverride = Optional.of(grassColorOverride);
			return this;
		}

		public BiomeSpecialEffects.Builder grassColorModifier(BiomeSpecialEffects.GrassColorModifier grassColorModifier) {
			this.grassColorModifier = grassColorModifier;
			return this;
		}

		public BiomeSpecialEffects.Builder ambientParticle(AmbientParticleSettings ambientParticle) {
			this.ambientParticle = Optional.of(ambientParticle);
			return this;
		}

		public BiomeSpecialEffects.Builder ambientLoopSound(Holder<SoundEvent> ambientLoopSoundEvent) {
			this.ambientLoopSoundEvent = Optional.of(ambientLoopSoundEvent);
			return this;
		}

		public BiomeSpecialEffects.Builder ambientMoodSound(AmbientMoodSettings ambientMoodSettings) {
			this.ambientMoodSettings = Optional.of(ambientMoodSettings);
			return this;
		}

		public BiomeSpecialEffects.Builder ambientAdditionsSound(AmbientAdditionsSettings ambientAdditionsSettings) {
			this.ambientAdditionsSettings = Optional.of(ambientAdditionsSettings);
			return this;
		}

		public BiomeSpecialEffects.Builder backgroundMusic(@Nullable Music backgroundMusic) {
			this.backgroundMusic = Optional.ofNullable(backgroundMusic);
			return this;
		}

		public BiomeSpecialEffects build() {
			return new BiomeSpecialEffects(
				this.fogColor.orElseThrow(() -> new IllegalStateException("Missing 'fog' color.")),
				this.waterColor.orElseThrow(() -> new IllegalStateException("Missing 'water' color.")),
				this.waterFogColor.orElseThrow(() -> new IllegalStateException("Missing 'water fog' color.")),
				this.skyColor.orElseThrow(() -> new IllegalStateException("Missing 'sky' color.")),
				this.foliageColorOverride,
				this.grassColorOverride,
				this.grassColorModifier,
				this.ambientParticle,
				this.ambientLoopSoundEvent,
				this.ambientMoodSettings,
				this.ambientAdditionsSettings,
				this.backgroundMusic
			);
		}
	}

	public static enum GrassColorModifier implements StringRepresentable {
		NONE("NONE", 0, "none"),
		DARK_FOREST("DARK_FOREST", 1, "dark_forest"),
		SWAMP("SWAMP", 2, "swamp");

		private final String name;
		public static final Codec<BiomeSpecialEffects.GrassColorModifier> CODEC = StringRepresentable.fromEnum(BiomeSpecialEffects.GrassColorModifier::values);

		public abstract int modifyColor(double x, double z, int grassColor);

		GrassColorModifier(final String name) {
			this.name = name;
		}

		public String getName() {
			return this.name;
		}

		@Override
		public String getSerializedName() {
			return this.name;
		}
	}
}