package com.mojang.realmsclient;

import com.google.common.collect.Lists;
import com.google.common.util.concurrent.RateLimiter;
import com.mojang.authlib.yggdrasil.ProfileResult;
import com.mojang.logging.LogUtils;
import com.mojang.math.Axis;
import com.mojang.realmsclient.client.Ping;
import com.mojang.realmsclient.client.RealmsClient;
import com.mojang.realmsclient.dto.PingResult;
import com.mojang.realmsclient.dto.RealmsNotification;
import com.mojang.realmsclient.dto.RealmsServer;
import com.mojang.realmsclient.dto.RealmsServerPlayerLists;
import com.mojang.realmsclient.dto.RegionPingResult;
import com.mojang.realmsclient.dto.RealmsNotification.InfoPopup;
import com.mojang.realmsclient.dto.RealmsNotification.VisitUrl;
import com.mojang.realmsclient.dto.RealmsServer.State;
import com.mojang.realmsclient.exception.RealmsServiceException;
import com.mojang.realmsclient.gui.RealmsDataFetcher;
import com.mojang.realmsclient.gui.RealmsServerList;
import com.mojang.realmsclient.gui.screens.AddRealmPopupScreen;
import com.mojang.realmsclient.gui.screens.RealmsConfigureWorldScreen;
import com.mojang.realmsclient.gui.screens.RealmsCreateRealmScreen;
import com.mojang.realmsclient.gui.screens.RealmsGenericErrorScreen;
import com.mojang.realmsclient.gui.screens.RealmsLongRunningMcoTaskScreen;
import com.mojang.realmsclient.gui.screens.RealmsPendingInvitesScreen;
import com.mojang.realmsclient.gui.screens.RealmsPopups;
import com.mojang.realmsclient.gui.task.DataFetcher.Subscription;
import com.mojang.realmsclient.gui.task.DataFetcher.Task;
import com.mojang.realmsclient.util.RealmsPersistence;
import com.mojang.realmsclient.util.RealmsUtil;
import com.mojang.realmsclient.util.RealmsPersistence.RealmsPersistenceData;
import com.mojang.realmsclient.util.task.GetServerDetailsTask;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Supplier;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.ChatFormatting;
import net.minecraft.SharedConstants;
import net.minecraft.Util;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.gui.components.AbstractWidget;
import net.minecraft.client.gui.components.Button;
import net.minecraft.client.gui.components.CycleButton;
import net.minecraft.client.gui.components.FocusableTextWidget;
import net.minecraft.client.gui.components.ImageButton;
import net.minecraft.client.gui.components.ImageWidget;
import net.minecraft.client.gui.components.LoadingDotsWidget;
import net.minecraft.client.gui.components.MultiLineTextWidget;
import net.minecraft.client.gui.components.ObjectSelectionList;
import net.minecraft.client.gui.components.PlayerFaceRenderer;
import net.minecraft.client.gui.components.PopupScreen;
import net.minecraft.client.gui.components.Tooltip;
import net.minecraft.client.gui.components.WidgetSprites;
import net.minecraft.client.gui.components.WidgetTooltipHolder;
import net.minecraft.client.gui.components.Button.OnPress;
import net.minecraft.client.gui.components.SpriteIconButton.CenteredIcon;
import net.minecraft.client.gui.layouts.FrameLayout;
import net.minecraft.client.gui.layouts.GridLayout;
import net.minecraft.client.gui.layouts.HeaderAndFooterLayout;
import net.minecraft.client.gui.layouts.Layout;
import net.minecraft.client.gui.layouts.LayoutSettings;
import net.minecraft.client.gui.layouts.LinearLayout;
import net.minecraft.client.gui.layouts.SpacerElement;
import net.minecraft.client.gui.layouts.GridLayout.RowHelper;
import net.minecraft.client.gui.navigation.CommonInputs;
import net.minecraft.client.gui.navigation.ScreenRectangle;
import net.minecraft.client.gui.screens.ConfirmLinkScreen;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.client.gui.screens.inventory.tooltip.ClientActivePlayersTooltip.ActivePlayersTooltip;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.resources.sounds.SimpleSoundInstance;
import net.minecraft.network.chat.CommonComponents;
import net.minecraft.network.chat.Component;
import net.minecraft.realms.RealmsScreen;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.sounds.SoundEvents;
import net.minecraft.util.CommonLinks;
import net.minecraft.util.Mth;
import net.minecraft.world.level.GameType;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;

@Environment(EnvType.CLIENT)
public class RealmsMainScreen extends RealmsScreen {
	static final ResourceLocation INFO_SPRITE = ResourceLocation.withDefaultNamespace("icon/info");
	static final ResourceLocation NEW_REALM_SPRITE = ResourceLocation.withDefaultNamespace("icon/new_realm");
	static final ResourceLocation EXPIRED_SPRITE = ResourceLocation.withDefaultNamespace("realm_status/expired");
	static final ResourceLocation EXPIRES_SOON_SPRITE = ResourceLocation.withDefaultNamespace("realm_status/expires_soon");
	static final ResourceLocation OPEN_SPRITE = ResourceLocation.withDefaultNamespace("realm_status/open");
	static final ResourceLocation CLOSED_SPRITE = ResourceLocation.withDefaultNamespace("realm_status/closed");
	private static final ResourceLocation INVITE_SPRITE = ResourceLocation.withDefaultNamespace("icon/invite");
	private static final ResourceLocation NEWS_SPRITE = ResourceLocation.withDefaultNamespace("icon/news");
	public static final ResourceLocation HARDCORE_MODE_SPRITE = ResourceLocation.withDefaultNamespace("hud/heart/hardcore_full");
	static final Logger LOGGER = LogUtils.getLogger();
	private static final ResourceLocation LOGO_LOCATION = ResourceLocation.withDefaultNamespace("textures/gui/title/realms.png");
	private static final ResourceLocation NO_REALMS_LOCATION = ResourceLocation.withDefaultNamespace("textures/gui/realms/no_realms.png");
	private static final Component TITLE = Component.translatable("menu.online");
	private static final Component LOADING_TEXT = Component.translatable("mco.selectServer.loading");
	static final Component SERVER_UNITIALIZED_TEXT = Component.translatable("mco.selectServer.uninitialized");
	static final Component SUBSCRIPTION_EXPIRED_TEXT = Component.translatable("mco.selectServer.expiredList");
	private static final Component SUBSCRIPTION_RENEW_TEXT = Component.translatable("mco.selectServer.expiredRenew");
	static final Component TRIAL_EXPIRED_TEXT = Component.translatable("mco.selectServer.expiredTrial");
	private static final Component PLAY_TEXT = Component.translatable("mco.selectServer.play");
	private static final Component LEAVE_SERVER_TEXT = Component.translatable("mco.selectServer.leave");
	private static final Component CONFIGURE_SERVER_TEXT = Component.translatable("mco.selectServer.configure");
	static final Component SERVER_EXPIRED_TOOLTIP = Component.translatable("mco.selectServer.expired");
	static final Component SERVER_EXPIRES_SOON_TOOLTIP = Component.translatable("mco.selectServer.expires.soon");
	static final Component SERVER_EXPIRES_IN_DAY_TOOLTIP = Component.translatable("mco.selectServer.expires.day");
	static final Component SERVER_OPEN_TOOLTIP = Component.translatable("mco.selectServer.open");
	static final Component SERVER_CLOSED_TOOLTIP = Component.translatable("mco.selectServer.closed");
	static final Component UNITIALIZED_WORLD_NARRATION = Component.translatable("gui.narrate.button", SERVER_UNITIALIZED_TEXT);
	private static final Component NO_REALMS_TEXT = Component.translatable("mco.selectServer.noRealms");
	private static final Component NO_PENDING_INVITES = Component.translatable("mco.invites.nopending");
	private static final Component PENDING_INVITES = Component.translatable("mco.invites.pending");
	private static final Component INCOMPATIBLE_POPUP_TITLE = Component.translatable("mco.compatibility.incompatible.popup.title");
	private static final Component INCOMPATIBLE_RELEASE_TYPE_POPUP_MESSAGE = Component.translatable("mco.compatibility.incompatible.releaseType.popup.message");
	private static final int BUTTON_WIDTH = 100;
	private static final int BUTTON_COLUMNS = 3;
	private static final int BUTTON_SPACING = 4;
	private static final int CONTENT_WIDTH = 308;
	private static final int LOGO_WIDTH = 128;
	private static final int LOGO_HEIGHT = 34;
	private static final int LOGO_TEXTURE_WIDTH = 128;
	private static final int LOGO_TEXTURE_HEIGHT = 64;
	private static final int LOGO_PADDING = 5;
	private static final int HEADER_HEIGHT = 44;
	private static final int FOOTER_PADDING = 11;
	private static final int NEW_REALM_SPRITE_WIDTH = 40;
	private static final int NEW_REALM_SPRITE_HEIGHT = 20;
	private static final int ENTRY_WIDTH = 216;
	private static final int ITEM_HEIGHT = 36;
	private static final boolean SNAPSHOT = !SharedConstants.getCurrentVersion().isStable();
	private static boolean snapshotToggle = SNAPSHOT;
	private final CompletableFuture<RealmsAvailability.Result> availability = RealmsAvailability.get();
	@Nullable
	private Subscription dataSubscription;
	private final Set<UUID> handledSeenNotifications = new HashSet();
	private static boolean regionsPinged;
	private final RateLimiter inviteNarrationLimiter;
	private final Screen lastScreen;
	private Button playButton;
	private Button backButton;
	private Button renewButton;
	private Button configureButton;
	private Button leaveButton;
	RealmsMainScreen.RealmSelectionList realmSelectionList;
	RealmsServerList serverList;
	List<RealmsServer> availableSnapshotServers = List.of();
	RealmsServerPlayerLists onlinePlayersPerRealm = new RealmsServerPlayerLists();
	private volatile boolean trialsAvailable;
	@Nullable
	private volatile String newsLink;
	long lastClickTime;
	final List<RealmsNotification> notifications = new ArrayList();
	private Button addRealmButton;
	private RealmsMainScreen.NotificationButton pendingInvitesButton;
	private RealmsMainScreen.NotificationButton newsButton;
	private RealmsMainScreen.LayoutState activeLayoutState;
	@Nullable
	private HeaderAndFooterLayout layout;

	public RealmsMainScreen(Screen lastScreen) {
		super(TITLE);
		this.lastScreen = lastScreen;
		this.inviteNarrationLimiter = RateLimiter.create(0.016666668F);
	}

	@Override
	public void init() {
		this.serverList = new RealmsServerList(this.minecraft);
		this.realmSelectionList = new RealmsMainScreen.RealmSelectionList();
		Component component = Component.translatable("mco.invites.title");
		this.pendingInvitesButton = new RealmsMainScreen.NotificationButton(
			component, INVITE_SPRITE, button -> this.minecraft.setScreen(new RealmsPendingInvitesScreen(this, component))
		);
		Component component2 = Component.translatable("mco.news");
		this.newsButton = new RealmsMainScreen.NotificationButton(component2, NEWS_SPRITE, button -> {
			String string = this.newsLink;
			if (string != null) {
				ConfirmLinkScreen.confirmLinkNow(this, string);
				if (this.newsButton.notificationCount() != 0) {
					RealmsPersistenceData realmsPersistenceData = RealmsPersistence.readFile();
					realmsPersistenceData.hasUnreadNews = false;
					RealmsPersistence.writeFile(realmsPersistenceData);
					this.newsButton.setNotificationCount(0);
				}
			}
		});
		this.newsButton.setTooltip(Tooltip.create(component2));
		this.playButton = Button.builder(PLAY_TEXT, button -> play(this.getSelectedServer(), this)).width(100).build();
		this.configureButton = Button.builder(CONFIGURE_SERVER_TEXT, button -> this.configureClicked(this.getSelectedServer())).width(100).build();
		this.renewButton = Button.builder(SUBSCRIPTION_RENEW_TEXT, button -> this.onRenew(this.getSelectedServer())).width(100).build();
		this.leaveButton = Button.builder(LEAVE_SERVER_TEXT, button -> this.leaveClicked(this.getSelectedServer())).width(100).build();
		this.addRealmButton = Button.builder(Component.translatable("mco.selectServer.purchase"), button -> this.openTrialAvailablePopup()).size(100, 20).build();
		this.backButton = Button.builder(CommonComponents.GUI_BACK, button -> this.onClose()).width(100).build();
		if (RealmsClient.ENVIRONMENT == RealmsClient.Environment.STAGE) {
			this.addRenderableWidget(
				CycleButton.booleanBuilder(Component.literal("Snapshot"), Component.literal("Release"))
					.create(5, 5, 100, 20, Component.literal("Realm"), (cycleButton, boolean_) -> {
						snapshotToggle = boolean_;
						this.availableSnapshotServers = List.of();
						this.debugRefreshDataFetchers();
					})
			);
		}

		this.updateLayout(RealmsMainScreen.LayoutState.LOADING);
		this.updateButtonStates();
		this.availability.thenAcceptAsync(result -> {
			Screen screen = result.createErrorScreen(this.lastScreen);
			if (screen == null) {
				this.dataSubscription = this.initDataFetcher(this.minecraft.realmsDataFetcher());
			} else {
				this.minecraft.setScreen(screen);
			}
		}, this.screenExecutor);
	}

	public static boolean isSnapshot() {
		return SNAPSHOT && snapshotToggle;
	}

	@Override
	protected void repositionElements() {
		if (this.layout != null) {
			this.realmSelectionList.updateSize(this.width, this.layout);
			this.layout.arrangeElements();
		}
	}

	@Override
	public void onClose() {
		this.minecraft.setScreen(this.lastScreen);
	}

	private void updateLayout() {
		if (this.serverList.isEmpty() && this.availableSnapshotServers.isEmpty() && this.notifications.isEmpty()) {
			this.updateLayout(RealmsMainScreen.LayoutState.NO_REALMS);
		} else {
			this.updateLayout(RealmsMainScreen.LayoutState.LIST);
		}
	}

	private void updateLayout(RealmsMainScreen.LayoutState layoutState) {
		if (this.activeLayoutState != layoutState) {
			if (this.layout != null) {
				this.layout.visitWidgets(guiEventListener -> this.removeWidget(guiEventListener));
			}

			this.layout = this.createLayout(layoutState);
			this.activeLayoutState = layoutState;
			this.layout.visitWidgets(guiEventListener -> {
				AbstractWidget var10000 = this.addRenderableWidget(guiEventListener);
			});
			this.repositionElements();
		}
	}

	private HeaderAndFooterLayout createLayout(RealmsMainScreen.LayoutState layoutState) {
		HeaderAndFooterLayout headerAndFooterLayout = new HeaderAndFooterLayout(this);
		headerAndFooterLayout.setHeaderHeight(44);
		headerAndFooterLayout.addToHeader(this.createHeader());
		Layout layout = this.createFooter(layoutState);
		layout.arrangeElements();
		headerAndFooterLayout.setFooterHeight(layout.getHeight() + 22);
		headerAndFooterLayout.addToFooter(layout);
		switch (layoutState) {
			case LOADING:
				headerAndFooterLayout.addToContents(new LoadingDotsWidget(this.font, LOADING_TEXT));
				break;
			case NO_REALMS:
				headerAndFooterLayout.addToContents(this.createNoRealmsContent());
				break;
			case LIST:
				headerAndFooterLayout.addToContents(this.realmSelectionList);
		}

		return headerAndFooterLayout;
	}

	private Layout createHeader() {
		int i = 90;
		LinearLayout linearLayout = LinearLayout.horizontal().spacing(4);
		linearLayout.defaultCellSetting().alignVerticallyMiddle();
		linearLayout.addChild(this.pendingInvitesButton);
		linearLayout.addChild(this.newsButton);
		LinearLayout linearLayout2 = LinearLayout.horizontal();
		linearLayout2.defaultCellSetting().alignVerticallyMiddle();
		linearLayout2.addChild(SpacerElement.width(90));
		linearLayout2.addChild(ImageWidget.texture(128, 34, LOGO_LOCATION, 128, 64), LayoutSettings::alignHorizontallyCenter);
		linearLayout2.addChild(new FrameLayout(90, 44)).addChild(linearLayout, LayoutSettings::alignHorizontallyRight);
		return linearLayout2;
	}

	private Layout createFooter(RealmsMainScreen.LayoutState layoutState) {
		GridLayout gridLayout = new GridLayout().spacing(4);
		RowHelper rowHelper = gridLayout.createRowHelper(3);
		if (layoutState == RealmsMainScreen.LayoutState.LIST) {
			rowHelper.addChild(this.playButton);
			rowHelper.addChild(this.configureButton);
			rowHelper.addChild(this.renewButton);
			rowHelper.addChild(this.leaveButton);
		}

		rowHelper.addChild(this.addRealmButton);
		rowHelper.addChild(this.backButton);
		return gridLayout;
	}

	private LinearLayout createNoRealmsContent() {
		LinearLayout linearLayout = LinearLayout.vertical().spacing(8);
		linearLayout.defaultCellSetting().alignHorizontallyCenter();
		linearLayout.addChild(ImageWidget.texture(130, 64, NO_REALMS_LOCATION, 130, 64));
		FocusableTextWidget focusableTextWidget = new FocusableTextWidget(308, NO_REALMS_TEXT, this.font, false, 4);
		linearLayout.addChild(focusableTextWidget);
		return linearLayout;
	}

	void updateButtonStates() {
		RealmsServer realmsServer = this.getSelectedServer();
		this.addRealmButton.active = this.activeLayoutState != RealmsMainScreen.LayoutState.LOADING;
		this.playButton.active = realmsServer != null && this.shouldPlayButtonBeActive(realmsServer);
		this.renewButton.active = realmsServer != null && this.shouldRenewButtonBeActive(realmsServer);
		this.leaveButton.active = realmsServer != null && this.shouldLeaveButtonBeActive(realmsServer);
		this.configureButton.active = realmsServer != null && this.shouldConfigureButtonBeActive(realmsServer);
	}

	boolean shouldPlayButtonBeActive(RealmsServer realmsServer) {
		boolean bl = !realmsServer.expired && realmsServer.state == State.OPEN;
		return bl && (realmsServer.isCompatible() || realmsServer.needsUpgrade() || isSelfOwnedServer(realmsServer));
	}

	private boolean shouldRenewButtonBeActive(RealmsServer realmsServer) {
		return realmsServer.expired && isSelfOwnedServer(realmsServer);
	}

	private boolean shouldConfigureButtonBeActive(RealmsServer realmsServer) {
		return isSelfOwnedServer(realmsServer) && realmsServer.state != State.UNINITIALIZED;
	}

	private boolean shouldLeaveButtonBeActive(RealmsServer realmsServer) {
		return !isSelfOwnedServer(realmsServer);
	}

	@Override
	public void tick() {
		super.tick();
		if (this.dataSubscription != null) {
			this.dataSubscription.tick();
		}
	}

	public static void refreshPendingInvites() {
		Minecraft.getInstance().realmsDataFetcher().pendingInvitesTask.reset();
	}

	public static void refreshServerList() {
		Minecraft.getInstance().realmsDataFetcher().serverListUpdateTask.reset();
	}

	private void debugRefreshDataFetchers() {
		for (Task<?> task : this.minecraft.realmsDataFetcher().getTasks()) {
			task.reset();
		}
	}

	private Subscription initDataFetcher(RealmsDataFetcher dataFetcher) {
		Subscription subscription = dataFetcher.dataFetcher.createSubscription();
		subscription.subscribe(dataFetcher.serverListUpdateTask, serverListData -> {
			this.serverList.updateServersList(serverListData.serverList());
			this.availableSnapshotServers = serverListData.availableSnapshotServers();
			this.refreshListAndLayout();
			boolean bl = false;

			for (RealmsServer realmsServer : this.serverList) {
				if (this.isSelfOwnedNonExpiredServer(realmsServer)) {
					bl = true;
				}
			}

			if (!regionsPinged && bl) {
				regionsPinged = true;
				this.pingRegions();
			}
		});
		callRealmsClient(RealmsClient::getNotifications, list -> {
			this.notifications.clear();
			this.notifications.addAll(list);

			for (RealmsNotification realmsNotification : list) {
				if (realmsNotification instanceof InfoPopup infoPopup) {
					PopupScreen popupScreen = infoPopup.buildScreen(this, this::dismissNotification);
					if (popupScreen != null) {
						this.minecraft.setScreen(popupScreen);
						this.markNotificationsAsSeen(List.of(realmsNotification));
						break;
					}
				}
			}

			if (!this.notifications.isEmpty() && this.activeLayoutState != RealmsMainScreen.LayoutState.LOADING) {
				this.refreshListAndLayout();
			}
		});
		subscription.subscribe(dataFetcher.pendingInvitesTask, integer -> {
			this.pendingInvitesButton.setNotificationCount(integer);
			this.pendingInvitesButton.setTooltip(integer == 0 ? Tooltip.create(NO_PENDING_INVITES) : Tooltip.create(PENDING_INVITES));
			if (integer > 0 && this.inviteNarrationLimiter.tryAcquire(1)) {
				this.minecraft.getNarrator().sayNow(Component.translatable("mco.configure.world.invite.narration", integer));
			}
		});
		subscription.subscribe(dataFetcher.trialAvailabilityTask, boolean_ -> this.trialsAvailable = boolean_);
		subscription.subscribe(dataFetcher.onlinePlayersTask, realmsServerPlayerLists -> this.onlinePlayersPerRealm = realmsServerPlayerLists);
		subscription.subscribe(dataFetcher.newsTask, realmsNews -> {
			dataFetcher.newsManager.updateUnreadNews(realmsNews);
			this.newsLink = dataFetcher.newsManager.newsLink();
			this.newsButton.setNotificationCount(dataFetcher.newsManager.hasUnreadNews() ? Integer.MAX_VALUE : 0);
		});
		return subscription;
	}

	void markNotificationsAsSeen(Collection<RealmsNotification> notifications) {
		List<UUID> list = new ArrayList(notifications.size());

		for (RealmsNotification realmsNotification : notifications) {
			if (!realmsNotification.seen() && !this.handledSeenNotifications.contains(realmsNotification.uuid())) {
				list.add(realmsNotification.uuid());
			}
		}

		if (!list.isEmpty()) {
			callRealmsClient(realmsClient -> {
				realmsClient.notificationsSeen(list);
				return null;
			}, object -> this.handledSeenNotifications.addAll(list));
		}
	}

	private static <T> void callRealmsClient(RealmsMainScreen.RealmsCall<T> call, Consumer<T> onFinish) {
		Minecraft minecraft = Minecraft.getInstance();
		CompletableFuture.supplyAsync(() -> {
			try {
				return call.request(RealmsClient.getOrCreate(minecraft));
			} catch (RealmsServiceException var3) {
				throw new RuntimeException(var3);
			}
		}).thenAcceptAsync(onFinish, minecraft).exceptionally(throwable -> {
			LOGGER.error("Failed to execute call to Realms Service", throwable);
			return null;
		});
	}

	private void refreshListAndLayout() {
		this.realmSelectionList.refreshEntries(this, this.getSelectedServer());
		this.updateLayout();
		this.updateButtonStates();
	}

	private void pingRegions() {
		new Thread(() -> {
			List<RegionPingResult> list = Ping.pingAllRegions();
			RealmsClient realmsClient = RealmsClient.getOrCreate();
			PingResult pingResult = new PingResult();
			pingResult.pingResults = list;
			pingResult.realmIds = this.getOwnedNonExpiredRealmIds();

			try {
				realmsClient.sendPingResults(pingResult);
			} catch (Throwable var5) {
				LOGGER.warn("Could not send ping result to Realms: ", var5);
			}
		}).start();
	}

	private List<Long> getOwnedNonExpiredRealmIds() {
		List<Long> list = Lists.<Long>newArrayList();

		for (RealmsServer realmsServer : this.serverList) {
			if (this.isSelfOwnedNonExpiredServer(realmsServer)) {
				list.add(realmsServer.id);
			}
		}

		return list;
	}

	private void onRenew(@Nullable RealmsServer realmsServer) {
		if (realmsServer != null) {
			String string = CommonLinks.extendRealms(realmsServer.remoteSubscriptionId, this.minecraft.getUser().getProfileId(), realmsServer.expiredTrial);
			this.minecraft.keyboardHandler.setClipboard(string);
			Util.getPlatform().openUri(string);
		}
	}

	private void configureClicked(@Nullable RealmsServer realmsServer) {
		if (realmsServer != null && this.minecraft.isLocalPlayer(realmsServer.ownerUUID)) {
			this.minecraft.setScreen(new RealmsConfigureWorldScreen(this, realmsServer.id));
		}
	}

	private void leaveClicked(@Nullable RealmsServer realmsServer) {
		if (realmsServer != null && !this.minecraft.isLocalPlayer(realmsServer.ownerUUID)) {
			Component component = Component.translatable("mco.configure.world.leave.question.line1");
			this.minecraft.setScreen(RealmsPopups.infoPopupScreen(this, component, popupScreen -> this.leaveServer(realmsServer)));
		}
	}

	@Nullable
	private RealmsServer getSelectedServer() {
		return this.realmSelectionList.getSelected() instanceof RealmsMainScreen.ServerEntry serverEntry ? serverEntry.getServer() : null;
	}

	private void leaveServer(RealmsServer server) {
		(new Thread("Realms-leave-server") {
			public void run() {
				try {
					RealmsClient realmsClient = RealmsClient.getOrCreate();
					realmsClient.uninviteMyselfFrom(server.id);
					RealmsMainScreen.this.minecraft.execute(RealmsMainScreen::refreshServerList);
				} catch (RealmsServiceException var2) {
					RealmsMainScreen.LOGGER.error("Couldn't configure world", (Throwable)var2);
					RealmsMainScreen.this.minecraft.execute(() -> RealmsMainScreen.this.minecraft.setScreen(new RealmsGenericErrorScreen(var2, RealmsMainScreen.this)));
				}
			}
		}).start();
		this.minecraft.setScreen(this);
	}

	void dismissNotification(UUID uuid) {
		callRealmsClient(realmsClient -> {
			realmsClient.notificationsDismiss(List.of(uuid));
			return null;
		}, object -> {
			this.notifications.removeIf(realmsNotification -> realmsNotification.dismissable() && uuid.equals(realmsNotification.uuid()));
			this.refreshListAndLayout();
		});
	}

	public void resetScreen() {
		this.realmSelectionList.setSelected(null);
		refreshServerList();
	}

	@Override
	public Component getNarrationMessage() {
		return (Component)(switch (this.activeLayoutState) {
			case LOADING -> CommonComponents.joinForNarration(super.getNarrationMessage(), LOADING_TEXT);
			case NO_REALMS -> CommonComponents.joinForNarration(super.getNarrationMessage(), NO_REALMS_TEXT);
			case LIST -> super.getNarrationMessage();
		});
	}

	@Override
	public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
		super.render(guiGraphics, mouseX, mouseY, partialTick);
		if (isSnapshot()) {
			guiGraphics.drawString(this.font, "Minecraft " + SharedConstants.getCurrentVersion().getName(), 2, this.height - 10, -1);
		}

		if (this.trialsAvailable && this.addRealmButton.active) {
			AddRealmPopupScreen.renderDiamond(guiGraphics, this.addRealmButton);
		}

		switch (RealmsClient.ENVIRONMENT) {
			case STAGE:
				this.renderEnvironment(guiGraphics, "STAGE!", -256);
				break;
			case LOCAL:
				this.renderEnvironment(guiGraphics, "LOCAL!", 8388479);
		}
	}

	private void openTrialAvailablePopup() {
		this.minecraft.setScreen(new AddRealmPopupScreen(this, this.trialsAvailable));
	}

	public static void play(@Nullable RealmsServer realmsServer, Screen lastScreen) {
		play(realmsServer, lastScreen, false);
	}

	public static void play(@Nullable RealmsServer realmsServer, Screen lastScreen, boolean allowSnapshots) {
		if (realmsServer != null) {
			if (!isSnapshot() || allowSnapshots || realmsServer.isMinigameActive()) {
				Minecraft.getInstance().setScreen(new RealmsLongRunningMcoTaskScreen(lastScreen, new GetServerDetailsTask(lastScreen, realmsServer)));
				return;
			}

			switch (realmsServer.compatibility) {
				case COMPATIBLE:
					Minecraft.getInstance().setScreen(new RealmsLongRunningMcoTaskScreen(lastScreen, new GetServerDetailsTask(lastScreen, realmsServer)));
					break;
				case UNVERIFIABLE:
					confirmToPlay(
						realmsServer,
						lastScreen,
						Component.translatable("mco.compatibility.unverifiable.title").withColor(-171),
						Component.translatable("mco.compatibility.unverifiable.message"),
						CommonComponents.GUI_CONTINUE
					);
					break;
				case NEEDS_DOWNGRADE:
					confirmToPlay(
						realmsServer,
						lastScreen,
						Component.translatable("selectWorld.backupQuestion.downgrade").withColor(-2142128),
						Component.translatable(
							"mco.compatibility.downgrade.description",
							Component.literal(realmsServer.activeVersion).withColor(-171),
							Component.literal(SharedConstants.getCurrentVersion().getName()).withColor(-171)
						),
						Component.translatable("mco.compatibility.downgrade")
					);
					break;
				case NEEDS_UPGRADE:
					upgradeRealmAndPlay(realmsServer, lastScreen);
					break;
				case INCOMPATIBLE:
					Minecraft.getInstance()
						.setScreen(
							new PopupScreen.Builder(lastScreen, INCOMPATIBLE_POPUP_TITLE)
								.setMessage(
									Component.translatable(
										"mco.compatibility.incompatible.series.popup.message",
										Component.literal(realmsServer.activeVersion).withColor(-171),
										Component.literal(SharedConstants.getCurrentVersion().getName()).withColor(-171)
									)
								)
								.addButton(CommonComponents.GUI_BACK, PopupScreen::onClose)
								.build()
						);
					break;
				case RELEASE_TYPE_INCOMPATIBLE:
					Minecraft.getInstance()
						.setScreen(
							new PopupScreen.Builder(lastScreen, INCOMPATIBLE_POPUP_TITLE)
								.setMessage(INCOMPATIBLE_RELEASE_TYPE_POPUP_MESSAGE)
								.addButton(CommonComponents.GUI_BACK, PopupScreen::onClose)
								.build()
						);
			}
		}
	}

	private static void confirmToPlay(RealmsServer realmsServer, Screen lastScreen, Component title, Component message, Component confirmButton) {
		Minecraft.getInstance().setScreen(new PopupScreen.Builder(lastScreen, title).setMessage(message).addButton(confirmButton, popupScreen -> {
			Minecraft.getInstance().setScreen(new RealmsLongRunningMcoTaskScreen(lastScreen, new GetServerDetailsTask(lastScreen, realmsServer)));
			refreshServerList();
		}).addButton(CommonComponents.GUI_CANCEL, PopupScreen::onClose).build());
	}

	private static void upgradeRealmAndPlay(RealmsServer server, Screen lastScreen) {
		Component component = Component.translatable("mco.compatibility.upgrade.title").withColor(-171);
		Component component2 = Component.translatable("mco.compatibility.upgrade");
		Component component3 = Component.literal(server.activeVersion).withColor(-171);
		Component component4 = Component.literal(SharedConstants.getCurrentVersion().getName()).withColor(-171);
		Component component5 = isSelfOwnedServer(server)
			? Component.translatable("mco.compatibility.upgrade.description", component3, component4)
			: Component.translatable("mco.compatibility.upgrade.friend.description", component3, component4);
		confirmToPlay(server, lastScreen, component, component5, component2);
	}

	public static Component getVersionComponent(String version, boolean compatible) {
		return getVersionComponent(version, compatible ? -8355712 : -2142128);
	}

	public static Component getVersionComponent(String version, int color) {
		return (Component)(StringUtils.isBlank(version) ? CommonComponents.EMPTY : Component.literal(version).withColor(color));
	}

	public static Component getGameModeComponent(int gamemode, boolean hardcore) {
		return (Component)(hardcore ? Component.translatable("gameMode.hardcore").withColor(-65536) : GameType.byId(gamemode).getLongDisplayName());
	}

	static boolean isSelfOwnedServer(RealmsServer server) {
		return Minecraft.getInstance().isLocalPlayer(server.ownerUUID);
	}

	private boolean isSelfOwnedNonExpiredServer(RealmsServer server) {
		return isSelfOwnedServer(server) && !server.expired;
	}

	private void renderEnvironment(GuiGraphics guiGraphics, String text, int color) {
		guiGraphics.pose().pushPose();
		guiGraphics.pose().translate((float)(this.width / 2 - 25), 20.0F, 0.0F);
		guiGraphics.pose().mulPose(Axis.ZP.rotationDegrees(-20.0F));
		guiGraphics.pose().scale(1.5F, 1.5F, 1.5F);
		guiGraphics.drawString(this.font, text, 0, 0, color);
		guiGraphics.pose().popPose();
	}

	@Environment(EnvType.CLIENT)
	class AvailableSnapshotEntry extends RealmsMainScreen.Entry {
		private static final Component START_SNAPSHOT_REALM = Component.translatable("mco.snapshot.start");
		private static final int TEXT_PADDING = 5;
		private final WidgetTooltipHolder tooltip = new WidgetTooltipHolder();
		private final RealmsServer parent;

		public AvailableSnapshotEntry(final RealmsServer parent) {
			this.parent = parent;
			this.tooltip.set(Tooltip.create(Component.translatable("mco.snapshot.tooltip")));
		}

		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
			guiGraphics.blitSprite(RenderType::guiTextured, RealmsMainScreen.NEW_REALM_SPRITE, left - 5, top + height / 2 - 10, 40, 20);
			int i = top + height / 2 - 9 / 2;
			guiGraphics.drawString(RealmsMainScreen.this.font, START_SNAPSHOT_REALM, left + 40 - 2, i - 5, 8388479);
			guiGraphics.drawString(
				RealmsMainScreen.this.font,
				Component.translatable("mco.snapshot.description", Objects.requireNonNullElse(this.parent.name, "unknown server")),
				left + 40 - 2,
				i + 5,
				-8355712
			);
			this.tooltip.refreshTooltipForNextRenderPass(hovering, this.isFocused(), new ScreenRectangle(left, top, width, height));
		}

		@Override
		public boolean mouseClicked(double mouseX, double mouseY, int button) {
			this.addSnapshotRealm();
			return true;
		}

		@Override
		public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
			if (CommonInputs.selected(keyCode)) {
				this.addSnapshotRealm();
				return false;
			} else {
				return super.keyPressed(keyCode, scanCode, modifiers);
			}
		}

		private void addSnapshotRealm() {
			RealmsMainScreen.this.minecraft.getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
			RealmsMainScreen.this.minecraft
				.setScreen(
					new PopupScreen.Builder(RealmsMainScreen.this, Component.translatable("mco.snapshot.createSnapshotPopup.title"))
						.setMessage(Component.translatable("mco.snapshot.createSnapshotPopup.text"))
						.addButton(
							Component.translatable("mco.selectServer.create"),
							popupScreen -> RealmsMainScreen.this.minecraft.setScreen(new RealmsCreateRealmScreen(RealmsMainScreen.this, this.parent, true))
						)
						.addButton(CommonComponents.GUI_CANCEL, PopupScreen::onClose)
						.build()
				);
		}

		@Override
		public Component getNarration() {
			return Component.translatable(
				"gui.narrate.button",
				CommonComponents.joinForNarration(
					START_SNAPSHOT_REALM, Component.translatable("mco.snapshot.description", Objects.requireNonNullElse(this.parent.name, "unknown server"))
				)
			);
		}
	}

	@Environment(EnvType.CLIENT)
	class ButtonEntry extends RealmsMainScreen.Entry {
		private final Button button;

		public ButtonEntry(final Button button) {
			this.button = button;
		}

		@Override
		public boolean mouseClicked(double mouseX, double mouseY, int button) {
			this.button.mouseClicked(mouseX, mouseY, button);
			return super.mouseClicked(mouseX, mouseY, button);
		}

		@Override
		public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
			return this.button.keyPressed(keyCode, scanCode, modifiers) ? true : super.keyPressed(keyCode, scanCode, modifiers);
		}

		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
			this.button.setPosition(RealmsMainScreen.this.width / 2 - 75, top + 4);
			this.button.render(guiGraphics, mouseX, mouseY, partialTick);
		}

		@Override
		public void setFocused(boolean focused) {
			super.setFocused(focused);
			this.button.setFocused(focused);
		}

		@Override
		public Component getNarration() {
			return this.button.getMessage();
		}
	}

	@Environment(EnvType.CLIENT)
	static class CrossButton extends ImageButton {
		private static final WidgetSprites SPRITES = new WidgetSprites(
			ResourceLocation.withDefaultNamespace("widget/cross_button"), ResourceLocation.withDefaultNamespace("widget/cross_button_highlighted")
		);

		protected CrossButton(OnPress onPress, Component message) {
			super(0, 0, 14, 14, SPRITES, onPress);
			this.setTooltip(Tooltip.create(message));
		}
	}

	@Environment(EnvType.CLIENT)
	class EmptyEntry extends RealmsMainScreen.Entry {
		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
		}

		@Override
		public Component getNarration() {
			return Component.empty();
		}
	}

	@Environment(EnvType.CLIENT)
	abstract class Entry extends ObjectSelectionList.Entry<RealmsMainScreen.Entry> {
		protected static final int STATUS_LIGHT_WIDTH = 10;
		private static final int STATUS_LIGHT_HEIGHT = 28;
		protected static final int PADDING_X = 7;
		protected static final int PADDING_Y = 2;

		protected void renderStatusLights(RealmsServer realmsServer, GuiGraphics guiGraphics, int x, int y, int mouseX, int mouseY) {
			int i = x - 10 - 7;
			int j = y + 2;
			if (realmsServer.expired) {
				this.drawRealmStatus(guiGraphics, i, j, mouseX, mouseY, RealmsMainScreen.EXPIRED_SPRITE, () -> RealmsMainScreen.SERVER_EXPIRED_TOOLTIP);
			} else if (realmsServer.state == State.CLOSED) {
				this.drawRealmStatus(guiGraphics, i, j, mouseX, mouseY, RealmsMainScreen.CLOSED_SPRITE, () -> RealmsMainScreen.SERVER_CLOSED_TOOLTIP);
			} else if (RealmsMainScreen.isSelfOwnedServer(realmsServer) && realmsServer.daysLeft < 7) {
				this.drawRealmStatus(
					guiGraphics,
					i,
					j,
					mouseX,
					mouseY,
					RealmsMainScreen.EXPIRES_SOON_SPRITE,
					() -> {
						if (realmsServer.daysLeft <= 0) {
							return RealmsMainScreen.SERVER_EXPIRES_SOON_TOOLTIP;
						} else {
							return (Component)(realmsServer.daysLeft == 1
								? RealmsMainScreen.SERVER_EXPIRES_IN_DAY_TOOLTIP
								: Component.translatable("mco.selectServer.expires.days", realmsServer.daysLeft));
						}
					}
				);
			} else if (realmsServer.state == State.OPEN) {
				this.drawRealmStatus(guiGraphics, i, j, mouseX, mouseY, RealmsMainScreen.OPEN_SPRITE, () -> RealmsMainScreen.SERVER_OPEN_TOOLTIP);
			}
		}

		private void drawRealmStatus(
			GuiGraphics guiGraphics, int x, int y, int mouseX, int mouseY, ResourceLocation spriteLocation, Supplier<Component> tooltipSupplier
		) {
			guiGraphics.blitSprite(RenderType::guiTextured, spriteLocation, x, y, 10, 28);
			if (RealmsMainScreen.this.realmSelectionList.isMouseOver(mouseX, mouseY) && mouseX >= x && mouseX <= x + 10 && mouseY >= y && mouseY <= y + 28) {
				RealmsMainScreen.this.setTooltipForNextRenderPass((Component)tooltipSupplier.get());
			}
		}

		protected void renderThirdLine(GuiGraphics guiGraphics, int top, int left, RealmsServer server) {
			int i = this.textX(left);
			int j = this.firstLineY(top);
			int k = this.thirdLineY(j);
			if (!RealmsMainScreen.isSelfOwnedServer(server)) {
				guiGraphics.drawString(RealmsMainScreen.this.font, server.owner, i, this.thirdLineY(j), -8355712);
			} else if (server.expired) {
				Component component = server.expiredTrial ? RealmsMainScreen.TRIAL_EXPIRED_TEXT : RealmsMainScreen.SUBSCRIPTION_EXPIRED_TEXT;
				guiGraphics.drawString(RealmsMainScreen.this.font, component, i, k, -2142128);
			}
		}

		protected void renderClampedString(GuiGraphics guiGraphics, @Nullable String text, int minX, int y, int maxX, int color) {
			if (text != null) {
				int i = maxX - minX;
				if (RealmsMainScreen.this.font.width(text) > i) {
					String string = RealmsMainScreen.this.font.plainSubstrByWidth(text, i - RealmsMainScreen.this.font.width("... "));
					guiGraphics.drawString(RealmsMainScreen.this.font, string + "...", minX, y, color);
				} else {
					guiGraphics.drawString(RealmsMainScreen.this.font, text, minX, y, color);
				}
			}
		}

		protected int versionTextX(int left, int width, Component versionComponent) {
			return left + width - RealmsMainScreen.this.font.width(versionComponent) - 20;
		}

		protected int gameModeTextX(int left, int width, Component component) {
			return left + width - RealmsMainScreen.this.font.width(component) - 20;
		}

		protected int renderGameMode(RealmsServer server, GuiGraphics guiGraphics, int left, int width, int firstLineY) {
			boolean bl = server.isHardcore;
			int i = server.gameMode;
			int j = left;
			if (GameType.isValidId(i)) {
				Component component = RealmsMainScreen.getGameModeComponent(i, bl);
				j = this.gameModeTextX(left, width, component);
				guiGraphics.drawString(RealmsMainScreen.this.font, component, j, this.secondLineY(firstLineY), -8355712);
			}

			if (bl) {
				j -= 10;
				guiGraphics.blitSprite(RenderType::guiTextured, RealmsMainScreen.HARDCORE_MODE_SPRITE, j, this.secondLineY(firstLineY), 8, 8);
			}

			return j;
		}

		protected int firstLineY(int top) {
			return top + 1;
		}

		protected int lineHeight() {
			return 2 + 9;
		}

		protected int textX(int left) {
			return left + 36 + 2;
		}

		protected int secondLineY(int firstLineY) {
			return firstLineY + this.lineHeight();
		}

		protected int thirdLineY(int firstLineY) {
			return firstLineY + this.lineHeight() * 2;
		}
	}

	@Environment(EnvType.CLIENT)
	static enum LayoutState {
		LOADING,
		NO_REALMS,
		LIST;
	}

	@Environment(EnvType.CLIENT)
	static class NotificationButton extends CenteredIcon {
		private static final ResourceLocation[] NOTIFICATION_ICONS = new ResourceLocation[]{
			ResourceLocation.withDefaultNamespace("notification/1"),
			ResourceLocation.withDefaultNamespace("notification/2"),
			ResourceLocation.withDefaultNamespace("notification/3"),
			ResourceLocation.withDefaultNamespace("notification/4"),
			ResourceLocation.withDefaultNamespace("notification/5"),
			ResourceLocation.withDefaultNamespace("notification/more")
		};
		private static final int UNKNOWN_COUNT = Integer.MAX_VALUE;
		private static final int SIZE = 20;
		private static final int SPRITE_SIZE = 14;
		private int notificationCount;

		public NotificationButton(Component message, ResourceLocation sprite, OnPress onPress) {
			super(20, 20, message, 14, 14, sprite, onPress, null);
		}

		int notificationCount() {
			return this.notificationCount;
		}

		public void setNotificationCount(int notificationCount) {
			this.notificationCount = notificationCount;
		}

		@Override
		public void renderWidget(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
			super.renderWidget(guiGraphics, mouseX, mouseY, partialTick);
			if (this.active && this.notificationCount != 0) {
				this.drawNotificationCounter(guiGraphics);
			}
		}

		private void drawNotificationCounter(GuiGraphics guiGraphics) {
			guiGraphics.blitSprite(
				RenderType::guiTextured, NOTIFICATION_ICONS[Math.min(this.notificationCount, 6) - 1], this.getX() + this.getWidth() - 5, this.getY() - 3, 8, 8
			);
		}
	}

	@Environment(EnvType.CLIENT)
	class NotificationMessageEntry extends RealmsMainScreen.Entry {
		private static final int SIDE_MARGINS = 40;
		private static final int OUTLINE_COLOR = -12303292;
		private final Component text;
		private final int frameItemHeight;
		private final List<AbstractWidget> children = new ArrayList();
		@Nullable
		private final RealmsMainScreen.CrossButton dismissButton;
		private final MultiLineTextWidget textWidget;
		private final GridLayout gridLayout;
		private final FrameLayout textFrame;
		private int lastEntryWidth = -1;

		public NotificationMessageEntry(final Component text, final int frameItemHeight, final RealmsNotification notification) {
			this.text = text;
			this.frameItemHeight = frameItemHeight;
			this.gridLayout = new GridLayout();
			int i = 7;
			this.gridLayout.addChild(ImageWidget.sprite(20, 20, RealmsMainScreen.INFO_SPRITE), 0, 0, this.gridLayout.newCellSettings().padding(7, 7, 0, 0));
			this.gridLayout.addChild(SpacerElement.width(40), 0, 0);
			this.textFrame = this.gridLayout.addChild(new FrameLayout(0, 9 * 3 * (frameItemHeight - 1)), 0, 1, this.gridLayout.newCellSettings().paddingTop(7));
			this.textWidget = this.textFrame
				.addChild(
					new MultiLineTextWidget(text, RealmsMainScreen.this.font).setCentered(true),
					this.textFrame.newChildLayoutSettings().alignHorizontallyCenter().alignVerticallyTop()
				);
			this.gridLayout.addChild(SpacerElement.width(40), 0, 2);
			if (notification.dismissable()) {
				this.dismissButton = this.gridLayout
					.addChild(
						new RealmsMainScreen.CrossButton(
							button -> RealmsMainScreen.this.dismissNotification(notification.uuid()), Component.translatable("mco.notification.dismiss")
						),
						0,
						2,
						this.gridLayout.newCellSettings().alignHorizontallyRight().padding(0, 7, 7, 0)
					);
			} else {
				this.dismissButton = null;
			}

			this.gridLayout.visitWidgets(this.children::add);
		}

		@Override
		public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
			return this.dismissButton != null && this.dismissButton.keyPressed(keyCode, scanCode, modifiers) ? true : super.keyPressed(keyCode, scanCode, modifiers);
		}

		private void updateEntryWidth(int entryWidth) {
			if (this.lastEntryWidth != entryWidth) {
				this.refreshLayout(entryWidth);
				this.lastEntryWidth = entryWidth;
			}
		}

		private void refreshLayout(int width) {
			int i = width - 80;
			this.textFrame.setMinWidth(i);
			this.textWidget.setMaxWidth(i);
			this.gridLayout.arrangeElements();
		}

		@Override
		public void renderBack(
			GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean isMouseOver, float partialTick
		) {
			super.renderBack(guiGraphics, index, top, left, width, height, mouseX, mouseY, isMouseOver, partialTick);
			guiGraphics.renderOutline(left - 2, top - 2, width, 36 * this.frameItemHeight - 2, -12303292);
		}

		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
			this.gridLayout.setPosition(left, top);
			this.updateEntryWidth(width - 4);
			this.children.forEach(abstractWidget -> abstractWidget.render(guiGraphics, mouseX, mouseY, partialTick));
		}

		@Override
		public boolean mouseClicked(double mouseX, double mouseY, int button) {
			if (this.dismissButton != null) {
				this.dismissButton.mouseClicked(mouseX, mouseY, button);
			}

			return super.mouseClicked(mouseX, mouseY, button);
		}

		@Override
		public Component getNarration() {
			return this.text;
		}
	}

	@Environment(EnvType.CLIENT)
	class ParentEntry extends RealmsMainScreen.Entry {
		private final RealmsServer server;
		private final WidgetTooltipHolder tooltip = new WidgetTooltipHolder();

		public ParentEntry(final RealmsServer server) {
			this.server = server;
			if (!server.expired) {
				this.tooltip.set(Tooltip.create(Component.translatable("mco.snapshot.parent.tooltip")));
			}
		}

		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
			int i = this.textX(left);
			int j = this.firstLineY(top);
			RealmsUtil.renderPlayerFace(guiGraphics, left, top, 32, this.server.ownerUUID);
			Component component = RealmsMainScreen.getVersionComponent(this.server.activeVersion, -8355712);
			int k = this.versionTextX(left, width, component);
			this.renderClampedString(guiGraphics, this.server.getName(), i, j, k, -8355712);
			if (component != CommonComponents.EMPTY) {
				guiGraphics.drawString(RealmsMainScreen.this.font, component, k, j, -8355712);
			}

			int l = left;
			if (!this.server.isMinigameActive()) {
				l = this.renderGameMode(this.server, guiGraphics, left, width, j);
			}

			this.renderClampedString(guiGraphics, this.server.getDescription(), i, this.secondLineY(j), l, -8355712);
			this.renderThirdLine(guiGraphics, top, left, this.server);
			this.renderStatusLights(this.server, guiGraphics, left + width, top, mouseX, mouseY);
			this.tooltip.refreshTooltipForNextRenderPass(hovering, this.isFocused(), new ScreenRectangle(left, top, width, height));
		}

		@Override
		public Component getNarration() {
			return Component.literal((String)Objects.requireNonNullElse(this.server.name, "unknown server"));
		}
	}

	@Environment(EnvType.CLIENT)
	class RealmSelectionList extends ObjectSelectionList<RealmsMainScreen.Entry> {
		public RealmSelectionList() {
			super(Minecraft.getInstance(), RealmsMainScreen.this.width, RealmsMainScreen.this.height, 0, 36);
		}

		public void setSelected(@Nullable RealmsMainScreen.Entry entry) {
			super.setSelected(entry);
			RealmsMainScreen.this.updateButtonStates();
		}

		@Override
		public int getRowWidth() {
			return 300;
		}

		void refreshEntries(RealmsMainScreen screen, @Nullable RealmsServer server) {
			this.clearEntries();

			for (RealmsNotification realmsNotification : RealmsMainScreen.this.notifications) {
				if (realmsNotification instanceof VisitUrl visitUrl) {
					this.addEntriesForNotification(visitUrl, screen);
					RealmsMainScreen.this.markNotificationsAsSeen(List.of(realmsNotification));
					break;
				}
			}

			this.refreshServerEntries(server);
		}

		private void refreshServerEntries(@Nullable RealmsServer server) {
			for (RealmsServer realmsServer : RealmsMainScreen.this.availableSnapshotServers) {
				this.addEntry(RealmsMainScreen.this.new AvailableSnapshotEntry(realmsServer));
			}

			for (RealmsServer realmsServer : RealmsMainScreen.this.serverList) {
				RealmsMainScreen.Entry entry;
				if (RealmsMainScreen.isSnapshot() && !realmsServer.isSnapshotRealm()) {
					if (realmsServer.state == State.UNINITIALIZED) {
						continue;
					}

					entry = RealmsMainScreen.this.new ParentEntry(realmsServer);
				} else {
					entry = RealmsMainScreen.this.new ServerEntry(realmsServer);
				}

				this.addEntry(entry);
				if (server != null && server.id == realmsServer.id) {
					this.setSelected(entry);
				}
			}
		}

		private void addEntriesForNotification(VisitUrl url, RealmsMainScreen mainScreen) {
			Component component = url.getMessage();
			int i = RealmsMainScreen.this.font.wordWrapHeight(component, 216);
			int j = Mth.positiveCeilDiv(i + 7, 36) - 1;
			this.addEntry(RealmsMainScreen.this.new NotificationMessageEntry(component, j + 2, url));

			for (int k = 0; k < j; k++) {
				this.addEntry(RealmsMainScreen.this.new EmptyEntry());
			}

			this.addEntry(RealmsMainScreen.this.new ButtonEntry(url.buildOpenLinkButton(mainScreen)));
		}
	}

	@Environment(EnvType.CLIENT)
	interface RealmsCall<T> {
		T request(RealmsClient realmsClient) throws RealmsServiceException;
	}

	@Environment(EnvType.CLIENT)
	class ServerEntry extends RealmsMainScreen.Entry {
		private static final Component ONLINE_PLAYERS_TOOLTIP_HEADER = Component.translatable("mco.onlinePlayers");
		private static final int PLAYERS_ONLINE_SPRITE_SIZE = 9;
		private static final int SKIN_HEAD_LARGE_WIDTH = 36;
		private final RealmsServer serverData;
		private final WidgetTooltipHolder tooltip = new WidgetTooltipHolder();

		public ServerEntry(final RealmsServer serverData) {
			this.serverData = serverData;
			boolean bl = RealmsMainScreen.isSelfOwnedServer(serverData);
			if (RealmsMainScreen.isSnapshot() && bl && serverData.isSnapshotRealm()) {
				this.tooltip.set(Tooltip.create(Component.translatable("mco.snapshot.paired", serverData.parentWorldName)));
			} else if (!bl && serverData.needsDowngrade()) {
				this.tooltip.set(Tooltip.create(Component.translatable("mco.snapshot.friendsRealm.downgrade", serverData.activeVersion)));
			}
		}

		@Override
		public void render(GuiGraphics guiGraphics, int index, int top, int left, int width, int height, int mouseX, int mouseY, boolean hovering, float partialTick) {
			if (this.serverData.state == State.UNINITIALIZED) {
				guiGraphics.blitSprite(RenderType::guiTextured, RealmsMainScreen.NEW_REALM_SPRITE, left - 5, top + height / 2 - 10, 40, 20);
				int i = top + height / 2 - 9 / 2;
				guiGraphics.drawString(RealmsMainScreen.this.font, RealmsMainScreen.SERVER_UNITIALIZED_TEXT, left + 40 - 2, i, 8388479);
			} else {
				this.renderStatusLights(this.serverData, guiGraphics, left + 36, top, mouseX, mouseY);
				RealmsUtil.renderPlayerFace(guiGraphics, left, top, 32, this.serverData.ownerUUID);
				this.renderFirstLine(guiGraphics, top, left, width);
				this.renderSecondLine(guiGraphics, top, left, width);
				this.renderThirdLine(guiGraphics, top, left, this.serverData);
				boolean bl = this.renderOnlinePlayers(guiGraphics, top, left, width, height, mouseX, mouseY);
				this.renderStatusLights(this.serverData, guiGraphics, left + width, top, mouseX, mouseY);
				if (!bl) {
					this.tooltip.refreshTooltipForNextRenderPass(hovering, this.isFocused(), new ScreenRectangle(left, top, width, height));
				}
			}
		}

		private void renderFirstLine(GuiGraphics guiGraphics, int top, int left, int width) {
			int i = this.textX(left);
			int j = this.firstLineY(top);
			Component component = RealmsMainScreen.getVersionComponent(this.serverData.activeVersion, this.serverData.isCompatible());
			int k = this.versionTextX(left, width, component);
			this.renderClampedString(guiGraphics, this.serverData.getName(), i, j, k, -1);
			if (component != CommonComponents.EMPTY && !this.serverData.isMinigameActive()) {
				guiGraphics.drawString(RealmsMainScreen.this.font, component, k, j, -8355712);
			}
		}

		private void renderSecondLine(GuiGraphics guiGraphics, int top, int left, int width) {
			int i = this.textX(left);
			int j = this.firstLineY(top);
			int k = this.secondLineY(j);
			String string = this.serverData.getMinigameName();
			boolean bl = this.serverData.isMinigameActive();
			if (bl && string != null) {
				Component component = Component.literal(string).withStyle(ChatFormatting.GRAY);
				guiGraphics.drawString(RealmsMainScreen.this.font, Component.translatable("mco.selectServer.minigameName", component).withColor(-171), i, k, -1);
			} else {
				int l = this.renderGameMode(this.serverData, guiGraphics, left, width, j);
				this.renderClampedString(guiGraphics, this.serverData.getDescription(), i, this.secondLineY(j), l, -8355712);
			}
		}

		private boolean renderOnlinePlayers(GuiGraphics guiGraphics, int top, int left, int width, int height, int mouseX, int mouseY) {
			List<ProfileResult> list = RealmsMainScreen.this.onlinePlayersPerRealm.getProfileResultsFor(this.serverData.id);
			if (!list.isEmpty()) {
				int i = left + width - 21;
				int j = top + height - 9 - 2;
				int k = i;

				for (int l = 0; l < list.size(); l++) {
					k -= 9 + (l == 0 ? 0 : 3);
					PlayerFaceRenderer.draw(guiGraphics, Minecraft.getInstance().getSkinManager().getInsecureSkin(((ProfileResult)list.get(l)).profile()), k, j, 9);
				}

				if (mouseX >= k && mouseX <= i && mouseY >= j && mouseY <= j + 9) {
					guiGraphics.renderTooltip(RealmsMainScreen.this.font, List.of(ONLINE_PLAYERS_TOOLTIP_HEADER), Optional.of(new ActivePlayersTooltip(list)), mouseX, mouseY);
					return true;
				}
			}

			return false;
		}

		private void playRealm() {
			RealmsMainScreen.this.minecraft.getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
			RealmsMainScreen.play(this.serverData, RealmsMainScreen.this);
		}

		private void createUnitializedRealm() {
			RealmsMainScreen.this.minecraft.getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
			RealmsCreateRealmScreen realmsCreateRealmScreen = new RealmsCreateRealmScreen(RealmsMainScreen.this, this.serverData, this.serverData.isSnapshotRealm());
			RealmsMainScreen.this.minecraft.setScreen(realmsCreateRealmScreen);
		}

		@Override
		public boolean mouseClicked(double mouseX, double mouseY, int button) {
			if (this.serverData.state == State.UNINITIALIZED) {
				this.createUnitializedRealm();
			} else if (RealmsMainScreen.this.shouldPlayButtonBeActive(this.serverData)) {
				if (Util.getMillis() - RealmsMainScreen.this.lastClickTime < 250L && this.isFocused()) {
					this.playRealm();
				}

				RealmsMainScreen.this.lastClickTime = Util.getMillis();
			}

			return true;
		}

		@Override
		public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
			if (CommonInputs.selected(keyCode)) {
				if (this.serverData.state == State.UNINITIALIZED) {
					this.createUnitializedRealm();
					return true;
				}

				if (RealmsMainScreen.this.shouldPlayButtonBeActive(this.serverData)) {
					this.playRealm();
					return true;
				}
			}

			return super.keyPressed(keyCode, scanCode, modifiers);
		}

		@Override
		public Component getNarration() {
			return (Component)(this.serverData.state == State.UNINITIALIZED
				? RealmsMainScreen.UNITIALIZED_WORLD_NARRATION
				: Component.translatable("narrator.select", Objects.requireNonNullElse(this.serverData.name, "unknown server")));
		}

		public RealmsServer getServer() {
			return this.serverData;
		}
	}
}