/*
 * Copyright (C) 2019 BARBOTIN Nicolas
 */

package net.montoyo.wd.client;

import com.cinemamod.mcef.MCEF;
import com.cinemamod.mcef.MCEFBrowser;
import com.mojang.authlib.GameProfile;
import com.mojang.blaze3d.platform.GlStateManager;
import com.mojang.blaze3d.platform.InputConstants;
import com.mojang.blaze3d.systems.RenderSystem;
import net.minecraft.advancements.Advancement;
import net.minecraft.advancements.AdvancementProgress;
import net.minecraft.client.KeyMapping;
import net.minecraft.client.Minecraft;
import net.minecraft.client.Options;
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
import net.minecraft.client.multiplayer.ClientAdvancements;
import net.minecraft.client.renderer.ItemBlockRenderTypes;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
import net.minecraft.core.BlockPos;
import net.minecraft.core.NonNullList;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.resources.ResourceKey;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.packs.resources.ReloadableResourceManager;
import net.minecraft.server.packs.resources.ResourceManager;
import net.minecraft.server.packs.resources.ResourceManagerReloadListener;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.entity.HumanoidArm;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.Slot;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.ClipContext;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.client.event.*;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.TickEvent;
import net.minecraftforge.event.level.LevelEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.LogicalSide;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.network.NetworkEvent;
import net.montoyo.wd.SharedProxy;
import net.montoyo.wd.WebDisplays;
import net.montoyo.wd.block.ScreenBlock;
import net.montoyo.wd.client.gui.*;
import net.montoyo.wd.client.gui.loading.GuiLoader;
import net.montoyo.wd.client.renderers.*;
import net.montoyo.wd.core.HasAdvancement;
import net.montoyo.wd.data.GuiData;
import net.montoyo.wd.entity.ScreenBlockEntity;
import net.montoyo.wd.registry.BlockRegistry;
import net.montoyo.wd.registry.ItemRegistry;
import net.montoyo.wd.registry.TileRegistry;
import net.montoyo.wd.item.ItemLaserPointer;
import net.montoyo.wd.item.ItemMinePad2;
import net.montoyo.wd.item.WDItem;
import net.montoyo.wd.miniserv.client.Client;
import net.montoyo.wd.net.WDNetworkRegistry;
import net.montoyo.wd.net.server_bound.C2SMessageMinepadUrl;
import net.montoyo.wd.utilities.*;
import org.cef.CefSettings;
import org.cef.browser.CefBrowser;
import org.cef.browser.CefFrame;
import org.cef.handler.CefDisplayHandler;
import org.cef.misc.CefCursorType;
import org.joml.Vector3d;
import org.lwjgl.glfw.GLFW;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;

import javax.annotation.Nonnull;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.*;
import java.util.stream.Stream;

@Mod.EventBusSubscriber(modid = "webdisplays", value = Dist.CLIENT, bus = Mod.EventBusSubscriber.Bus.MOD)
public class ClientProxy extends SharedProxy implements CefDisplayHandler/*, IJSQueryHandler*/, ResourceManagerReloadListener {
	
	private static ClientProxy INSTANCE;
	
	public ClientProxy() {
		INSTANCE = this;
	}
	
	public static void renderCrosshair(Options options, int screenWidth, int screenHeight, int offset, GuiGraphics poseStack, CallbackInfo ci) {
		ItemStack stack = Minecraft.getInstance().player.getItemInHand(InteractionHand.MAIN_HAND);
		ItemStack stack1 = Minecraft.getInstance().player.getItemInHand(InteractionHand.OFF_HAND);
		
		if (stack.getItem() instanceof ItemMinePad2) {
			float sign = 1;
			if (Minecraft.getInstance().player.getMainArm() == HumanoidArm.LEFT) sign = -1;
			if (!MinePadRenderer.renderAtSide(sign)) {
				ci.cancel();
				return;
			}
		} else {
			if (stack1.getItem() instanceof ItemMinePad2) {
				float sign = -1;
				if (Minecraft.getInstance().player.getMainArm() == HumanoidArm.LEFT) sign = 1;
				if (!MinePadRenderer.renderAtSide(sign)) {
					ci.cancel();
					return;
				}
			}
		}
		
		if (!(stack.getItem() instanceof ItemLaserPointer ||
				stack1.getItem() instanceof ItemLaserPointer))
			return;
		
		if (!LaserPointerRenderer.isOn()) {
			RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.ONE_MINUS_DST_COLOR, GlStateManager.DestFactor.ONE_MINUS_SRC_COLOR, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);

			poseStack.blit(new ResourceLocation(
					"webdisplays:textures/gui/cursors.png"
			), (screenWidth - 15) / 2, (screenHeight - 15) / 2, offset, 240, 240, 15, 15, 256, 256);
			ci.cancel();
			return;
		}
		
		Minecraft mc = Minecraft.getInstance();
		
		BlockHitResult result = raycast(64.0); //TODO: Make that distance configurable
		
		BlockPos bpos = result.getBlockPos();
		
		if (result.getType() != HitResult.Type.BLOCK || mc.level.getBlockState(bpos).getBlock() != BlockRegistry.SCREEN_BLOCk.get()) {
			RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.ONE_MINUS_DST_COLOR, GlStateManager.DestFactor.ONE_MINUS_SRC_COLOR, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);

			poseStack.blit(new ResourceLocation(
					"webdisplays:textures/gui/cursors.png"
			), (screenWidth - 15) / 2, (screenHeight - 15) / 2, offset, 240, 240, 15, 15, 256, 256);
			ci.cancel();
			return;
		}

		Vector3i pos = new Vector3i(result.getBlockPos());
		BlockSide side = BlockSide.values()[result.getDirection().ordinal()];
		
		Multiblock.findOrigin(mc.level, pos, side, null);
		ScreenBlockEntity te = (ScreenBlockEntity) mc.level.getBlockEntity(pos.toBlock());
		
		ScreenBlockEntity.Screen sc = te.getScreen(side);
		
		if (sc == null) return;

		int coordX = sc.mouseType * 15;
		int coordY = coordX / 255;
		coordX -= coordY * 255;
		coordY *= 15;
		// for some reason, the cursor gets offset at this value
		if (sc.mouseType >= CefCursorType.NOT_ALLOWED.ordinal()) coordX -= 15;
		
		RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.ONE_MINUS_DST_COLOR, GlStateManager.DestFactor.ONE_MINUS_SRC_COLOR, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);

		poseStack.blit(new ResourceLocation(
				"webdisplays:textures/gui/cursors.png"
		), (screenWidth - 15) / 2, (screenHeight - 15) / 2, offset, coordX, coordY, 15, 15, 256, 256);

		ci.cancel();
	}
	
	public class PadData {
		
		public CefBrowser view;
		private boolean isInHotbar;
		private final UUID id;
		private long lastURLSent;
		
		public int activeCursor;
		
		private PadData(String url, UUID id) {
			String webUrl;
			try {
				webUrl = ScreenBlockEntity.url(url);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			view = MCEF.createBrowser(WebDisplays.applyBlacklist(webUrl), false);
			if (view instanceof MCEFBrowser browser) {
				browser.resize((int) WebDisplays.INSTANCE.padResX, (int) WebDisplays.INSTANCE.padResY);
				browser.setCursorChangeListener((cursor) -> {
					activeCursor = cursor;
				});
			}
			isInHotbar = true;
			this.id = id;
		}
	}
	
	private Minecraft mc;
	private MinePadRenderer minePadRenderer;
//	private JSQueryDispatcher jsDispatcher;
	private LaserPointerRenderer laserPointerRenderer;
	private Screen nextScreen;
	private boolean isF1Down;
	
	//Miniserv handling
	private int miniservPort;
	private boolean msClientStarted;
	
	//Client-side advancement hack
	private final Field advancementToProgressField = findAdvancementToProgressField();
	private ClientAdvancements lastAdvMgr;
	private Map advancementToProgress;
	
	//Tracking
	private final ArrayList<ScreenBlockEntity> screenTracking = new ArrayList<>();
	private int lastTracked = 0;
	
	//MinePads Management
	private final HashMap<UUID, PadData> padMap = new HashMap<>();
	private final ArrayList<PadData> padList = new ArrayList<>();
	private int minePadTickCounter = 0;
	
	/**************************************** INHERITED METHODS ****************************************/
	@SubscribeEvent
	public static void onClientSetup(FMLClientSetupEvent event) {
		BlockEntityRenderers.register(TileRegistry.SCREEN_BLOCK_ENTITY.get(), new ScreenRenderer.ScreenRendererProvider());
	}
	
	@SubscribeEvent
	public static void onModelRegistryEvent(ModelEvent.RegisterGeometryLoaders event) {
		event.register(ScreenModelLoader.SCREEN_LOADER.getPath(), new ScreenModelLoader());
	}
	
	private static void registerBlockRenderLayers(RenderType layer, Block... blocks) {
		Stream.of(blocks).forEach(block -> ItemBlockRenderTypes.setRenderLayer(block, layer));
	}
	
	@Override
	public void preInit() {
		super.preInit();
		mc = Minecraft.getInstance();
		MinecraftForge.EVENT_BUS.register(this);
	}
	
	@Override
	public void init() {
		super.init();
	}
	
	@Override
	public void onCefInit(/*CefInitEvent event*/) {
		minePadRenderer = new MinePadRenderer();
		laserPointerRenderer = new LaserPointerRenderer();

		if (!MCEF.isInitialized()) return;

		MCEF.getApp().getHandle().registerSchemeHandlerFactory(
				"webdisplays", "",
				(browser, frame, url, request) -> {
					// TODO: check if it's a webdisplays browser?
					return new WDScheme(request.getURL());
				}
		);

//		jsDispatcher = new JSQueryDispatcher(this);
		MCEF.getClient().addDisplayHandler(this);
//		mcef.registerJSQueryHandler(this);

		findAdvancementToProgressField();
	}
	
	@Override
	public void postInit() {
		((ReloadableResourceManager) mc.getResourceManager()).registerReloadListener(this);
	}
	
	@Override
	public Level getWorld(ResourceKey<Level> dim) {
		Level ret = mc.level;
//        if(dim == CURRENT_DIMENSION)
//            return ret;
		if (ret != null) {
			if (!ret.dimension().equals(dim))
				throw new RuntimeException("Can't get non-current dimension " + dim + " from client.");
			return ret;
		} else {
			throw new RuntimeException("Level on client is null");
		}
	}
	
	@Override
	public void enqueue(Runnable r) {
		mc.submit(r);
	}
	
	@Override
	public void displayGui(GuiData data) {
		Screen gui = data.createGui(mc.screen, mc.level);
		if (gui != null)
			mc.setScreen(gui);
	}
	
	@Override
	public void trackScreen(ScreenBlockEntity tes, boolean track) {
		int idx = -1;
		for (int i = 0; i < screenTracking.size(); i++) {
			if (screenTracking.get(i) == tes) {
				idx = i;
				break;
			}
		}
		
		if (track) {
			if (idx < 0)
				screenTracking.add(tes);
		} else if (idx >= 0)
			screenTracking.remove(idx);
	}
	
	@Override
	public void onAutocompleteResult(NameUUIDPair[] pairs) {
		if (mc.screen != null && mc.screen instanceof WDScreen screen) {
			if (pairs.length == 0)
				(screen).onAutocompleteFailure();
			else
				(screen).onAutocompleteResult(pairs);
		}
	}
	
	@Override
	public GameProfile[] getOnlineGameProfiles() {
		return new GameProfile[]{mc.player.getGameProfile()};
	}
	
	@Override
	public void screenUpdateResolutionInGui(Vector3i pos, BlockSide side, Vector2i res) {
		if (mc.screen != null && mc.screen instanceof GuiScreenConfig gsc) {
			if (gsc.isForBlock(pos.toBlock(), side))
				gsc.updateResolution(res);
		}
	}
	
	@Override
	public void screenUpdateRotationInGui(Vector3i pos, BlockSide side, Rotation rot) {
		if (mc.screen != null && mc.screen instanceof GuiScreenConfig gsc) {
			if (gsc.isForBlock(pos.toBlock(), side))
				gsc.updateRotation(rot);
		}
	}
	
	@Override
	public void screenUpdateAutoVolumeInGui(Vector3i pos, BlockSide side, boolean av) {
		if (mc.screen != null && mc.screen instanceof GuiScreenConfig gsc) {
			if (gsc.isForBlock(pos.toBlock(), side))
				gsc.updateAutoVolume(av);
		}
	}
	
	@Override
	public void displaySetPadURLGui(ItemStack is, String padURL) {
		mc.setScreen(new GuiSetURL2(is, padURL));
	}
	
	@Override
	public void openMinePadGui(UUID padId) {
		PadData pd = padMap.get(padId);
		
		if (pd != null && pd.view != null)
			mc.setScreen(new GuiMinePad(pd));
	}
	
	@Override
	@Nonnull
	public HasAdvancement hasClientPlayerAdvancement(@Nonnull ResourceLocation rl) {
		if (advancementToProgressField != null && mc.player != null && mc.player.connection != null) {
			ClientAdvancements cam = mc.player.connection.getAdvancements();
			Advancement adv = cam.getAdvancements().get(rl);
			
			if (adv == null)
				return HasAdvancement.DONT_KNOW;
			
			if (lastAdvMgr != cam) {
				lastAdvMgr = cam;
				
				try {
					advancementToProgress = (Map) advancementToProgressField.get(cam);
				} catch (Throwable t) {
					Log.warningEx("Could not get ClientAdvancementManager.advancementToProgress field", t);
					advancementToProgress = null;
					return HasAdvancement.DONT_KNOW;
				}
			}
			
			if (advancementToProgress == null)
				return HasAdvancement.DONT_KNOW;
			
			Object progress = advancementToProgress.get(adv);
			if (progress == null)
				return HasAdvancement.NO;
			
			if (!(progress instanceof AdvancementProgress)) {
				Log.warning("The ClientAdvancementManager.advancementToProgress map does not contain AdvancementProgress instances");
				advancementToProgress = null; //Invalidate this: it's wrong
				return HasAdvancement.DONT_KNOW;
			}
			
			return ((AdvancementProgress) progress).isDone() ? HasAdvancement.YES : HasAdvancement.NO;
		}
		
		return HasAdvancement.DONT_KNOW;
	}
	
	@Override
	public MinecraftServer getServer() {
		return mc.getSingleplayerServer();
	}
	
//	@Override
//	public void handleJSResponseSuccess(int reqId, JSServerRequest type, byte[] data) {
//		JSQueryDispatcher.ServerQuery q = jsDispatcher.fulfillQuery(reqId);
//
//		if (q == null)
//			Log.warning("Received success response for invalid query ID %d of type %s", reqId, type.toString());
//		else {
//			if (type == JSServerRequest.CLEAR_REDSTONE || type == JSServerRequest.SET_REDSTONE_AT)
//				q.success("{\"status\":\"success\"}");
//			else
//				Log.warning("Received success response for query ID %d, but type is invalid", reqId);
//		}
//	}
//
//	@Override
//	public void handleJSResponseError(int reqId, JSServerRequest type, int errCode, String err) {
//		JSQueryDispatcher.ServerQuery q = jsDispatcher.fulfillQuery(reqId);
//
//		if (q == null)
//			Log.warning("Received error response for invalid query ID %d of type %s", reqId, type.toString());
//		else
//			q.error(errCode, err);
//	}
	
	@Override
	public void setMiniservClientPort(int port) {
		miniservPort = port;
	}
	
	@Override
	public void startMiniservClient() {
		if (miniservPort <= 0) {
			Log.warning("Can't start miniserv client: miniserv is disabled");
			return;
		}
		
		if (mc.player == null) {
			Log.warning("Can't start miniserv client: player is null");
			return;
		}
		
		SocketAddress saddr = mc.player.connection.getConnection().channel().remoteAddress();
		if (saddr == null || !(saddr instanceof InetSocketAddress)) {
			Log.warning("Miniserv client: remote address is not inet, assuming local address");
			saddr = new InetSocketAddress("127.0.0.1", 1234);
		}
		
		InetSocketAddress msAddr = new InetSocketAddress(((InetSocketAddress) saddr).getAddress(), miniservPort);
		Client.getInstance().start(msAddr);
		msClientStarted = true;
	}
	
	@Override
	public boolean isMiniservDisabled() {
		return miniservPort <= 0;
	}
	
	@Override
	public void closeGui(BlockPos bp, BlockSide bs) {
		if (mc.screen instanceof WDScreen) {
			WDScreen scr = (WDScreen) mc.screen;
			
			if (scr.isForBlock(bp, bs))
				mc.setScreen(null);
		}
	}
	
	@Override
	public void renderRecipes() {
		nextScreen = new RenderRecipe();
	}
	
	@Override
	public boolean isShiftDown() {
		return Screen.hasShiftDown();
	}
	
	
	/**************************************** RESOURCE MANAGER METHODS ****************************************/
	
	@Override
	public void onResourceManagerReload(ResourceManager resourceManager) {
		Log.info("Resource manager reload: clearing GUI cache...");
		GuiLoader.clearCache();
	}
	
	/**************************************** DISPLAY HANDLER METHODS ****************************************/
	
	
	@Override
	public void onAddressChange(CefBrowser browser, CefFrame cefFrame, String url) {
		if (browser != null) {
			long t = System.currentTimeMillis();
			
			for (PadData pd : padList) {
				if (pd.view == browser && t - pd.lastURLSent >= 1000) {
					if (WebDisplays.isSiteBlacklisted(url))
						pd.view.loadURL(WebDisplays.BLACKLIST_URL);
					else {
						pd.lastURLSent = t; //Avoid spamming the server with porn URLs
						WDNetworkRegistry.INSTANCE.sendToServer(new C2SMessageMinepadUrl(pd.id, url));
					}
					
					break;
				}
			}
			
			for (ScreenBlockEntity tes : screenTracking)
				tes.updateClientSideURL(browser, url);
		}
	}
	
	@Override
	public void onTitleChange(CefBrowser cefBrowser, String s) {
	}
	
	@Override
	public boolean onTooltip(CefBrowser cefBrowser, String s) {
		return false;
	}
	
	@Override
	public void onStatusMessage(CefBrowser cefBrowser, String s) {
	}
	
	@Override
	public boolean onConsoleMessage(CefBrowser cefBrowser, CefSettings.LogSeverity logSeverity, String s, String s1, int i) {
		return false;
	}
	
	@Override
	public boolean onCursorChange(CefBrowser cefBrowser, int i) {
		return false;
	}
	
	/**************************************** JS HANDLER METHODS ****************************************/
	
//	@Override
//	public boolean handleQuery(IBrowser browser, long queryId, String query, boolean persistent, IJSQueryCallback cb) {
//		if (browser != null && persistent && query != null && cb != null) {
//			query = query.toLowerCase();
//
//			if (query.startsWith("webdisplays_")) {
//				query = query.substring(12);
//
//				String args;
//				int parenthesis = query.indexOf('(');
//				if (parenthesis < 0)
//					args = null;
//				else {
//					if (query.indexOf(')') != query.length() - 1) {
//						cb.failure(400, "Malformed request");
//						return true;
//					}
//
//					args = query.substring(parenthesis + 1, query.length() - 1);
//					query = query.substring(0, parenthesis);
//				}
//
//				if (jsDispatcher.canHandleQuery(query))
//					jsDispatcher.enqueueQuery(browser, query, args, cb);
//				else
//					cb.failure(404, "Unknown WebDisplays query");
//
//				return true;
//			}
//		}
//
//		return false;
//	}
//
//	@Override
//	public void cancelQuery(IBrowser browser, long queryId) {
//	}
	
	/**************************************** EVENT METHODS ****************************************/
	
//    @SubscribeEvent
//    public void onBakeModel(ModelBakeEvent ev) {
//        for(ResourceModelPair pair : modelBakers)
//            ev.getModelRegistry().put(pair.getResourceLocation(), pair.getModel());
//    }

 /*   @SubscribeEvent
    public void onRegisterModels(ModelRegistryEvent ev) {
        final WebDisplays wd = WebDisplays.INSTANCE;

        //I hope I'm doing this right because it doesn't seem like it...
       registerItemModel(wd.blockScreen.getItem(), 0, "inventory");
       ModelLoaderRegistry.setCustomModelResourceLocation(wd.blockPeripheral.getItem(), 0, new ModelResourceLocation("webdisplays:kb_inv", "normal"));
       registerItemModel(wd.blockPeripheral.getItem(), 1, "facing=2,type=ccinterface");
       registerItemModel(wd.blockPeripheral.getItem(), 2, "facing=2,type=cointerface");
       registerItemModel(wd.blockPeripheral.getItem(), 3, "facing=0,type=remotectrl");
       registerItemModel(wd.blockPeripheral.getItem(), 7, "facing=0,type=redstonectrl");
       registerItemModel(wd.blockPeripheral.getItem(), 11, "facing=0,type=server");
       registerItemModel(wd.itemScreenCfg, 0, "normal");
       registerItemModel(wd.itemOwnerThief, 0, "normal");
       registerItemModel(wd.itemLinker, 0, "normal");
       registerItemModel(wd.itemMinePad, 0, "normal");
       registerItemModel(wd.itemMinePad, 1, "normal");
       registerItemModel(wd.itemLaserPointer, 0, "normal");
       registerItemMultiModels(wd.itemUpgrade);
       registerItemMultiModels(wd.itemCraftComp);
       registerItemMultiModels(wd.itemAdvIcon);
    } */
	
	@SubscribeEvent
	public void onLevelTick(TickEvent.LevelTickEvent ev) {
		if (!ev.side.equals(LogicalSide.CLIENT)) return;
		if (ev.phase != TickEvent.Phase.END) return;
		
		//Unload/load screens depending on client player distance
		if (mc.player != null || !screenTracking.isEmpty())
			return;
		
		int id = lastTracked % screenTracking.size();
		
		ScreenBlockEntity tes = screenTracking.get(id);
		
		if (!tes.getLevel().equals(ev.level))
			return;
		
		lastTracked++;
		if (tes.getLevel() != mc.player.level()) {
			// TODO: properly handle this
			// probably gonna want a helper class for cross-dimensional distances
			if (!tes.isLoaded())
				tes.load();
		} else {
			double dist = Double.POSITIVE_INFINITY;
			for (int i = 0; i < tes.screenCount(); i++) {
				ScreenBlockEntity.Screen scrn = tes.getScreen(i);
				
				Vector3d pos = new Vector3d(
						scrn.side.right.x * scrn.size.x + scrn.size.y * scrn.side.up.x,
						scrn.side.right.y * scrn.size.x + scrn.size.y * scrn.side.up.y,
						scrn.side.right.z * scrn.size.x + scrn.size.y * scrn.side.up.z
				);
				
				double dist2 = mc.player.distanceToSqr(pos.x, pos.y, pos.z);
				dist = Math.min(dist, dist2);
			}
			
			if (tes.isLoaded()) {
				if (dist > WebDisplays.INSTANCE.unloadDistance2)
					tes.unload();
//				else if (ClientConfig.AutoVolumeControl.enableAutoVolume)
//					tes.updateTrackDistance(dist, 80); //ToDo find master volume
			} else if (dist <= WebDisplays.INSTANCE.loadDistance2)
				tes.load();
		}
	}
	
	@SubscribeEvent
	public void onTick(TickEvent.ClientTickEvent ev) {
		if (ev.phase != TickEvent.Phase.END) return;
		
		//Help
		if (InputConstants.isKeyDown(Minecraft.getInstance().getWindow().getWindow(), GLFW.GLFW_KEY_F1)) {
			if (!isF1Down) {
				isF1Down = true;
				
				String wikiName = null;
				if (mc.screen instanceof WDScreen)
					wikiName = ((WDScreen) mc.screen).getWikiPageName();
				else if (mc.screen instanceof AbstractContainerScreen) {
					Slot slot = ((AbstractContainerScreen) mc.screen).getSlotUnderMouse();
					
					if (slot != null && slot.hasItem() && slot.getItem().getItem() instanceof WDItem)
						wikiName = ((WDItem) slot.getItem().getItem()).getWikiName(slot.getItem());
				}
				
//				if (wikiName != null)
//					mcef.openExampleBrowser("https://montoyo.net/wdwiki/index.php/" + wikiName);
			}
		} else if (isF1Down)
			isF1Down = false;
		
		//Workaround cuz chat sux
		if (nextScreen != null && mc.screen == null) {
			mc.setScreen(nextScreen);
			nextScreen = null;
		}
		
		// handle r button
		if (KEY_MOUSE.isDown()) {
			if (!rDown) {
				rDown = true;
				mouseOn = !mouseOn;
			}
		} else rDown = false;
		if (
				Minecraft.getInstance().player == null ||
						!(Minecraft.getInstance().player.getItemInHand(InteractionHand.MAIN_HAND).getItem() instanceof ItemLaserPointer)
		) mouseOn = false;
		
		
		//Load/unload minePads depending on which item is in the player's hand
		if (++minePadTickCounter >= 10) {
			minePadTickCounter = 0;
			Player ep = mc.player;
			
			for (PadData pd : padList)
				pd.isInHotbar = false;
			
			if (ep != null) {
				updateInventory(ep.getInventory().items, ep.getItemInHand(InteractionHand.MAIN_HAND), 9);
				updateInventory(ep.getInventory().offhand, ep.getItemInHand(InteractionHand.OFF_HAND), 1); //Is this okay?
			}
			
			//TODO: Check for GuiContainer.draggedStack
			
			for (int i = padList.size() - 1; i >= 0; i--) {
				PadData pd = padList.get(i);
				
				if (!pd.isInHotbar) {
					pd.view.close(true);
					pd.view = null; //This is for GuiMinePad, in case the player dies with the GUI open
					padList.remove(i);
					padMap.remove(pd.id);
				}
			}
		}
		
		//Laser pointer raycast
		if (LaserPointerRenderer.isOn()) {
			ItemLaserPointer.tick(mc);
		} else {
			ItemLaserPointer.deselect(mc);
		}

//        //Handle JS queries
//        jsDispatcher.handleQueries();
		
		//Miniserv
		if (msClientStarted && mc.player == null) {
			msClientStarted = false;
			Client.getInstance().stop();
		}
	}
	
	@SubscribeEvent
	public void onRenderPlayerHand(RenderHandEvent ev) {
		Item item = ev.getItemStack().getItem();
		IItemRenderer renderer;
		
		if (ItemRegistry.MINEPAD.isPresent() && ItemRegistry.LASER_POINTER.isPresent()) {
			if (item == ItemRegistry.MINEPAD.get())
				renderer = minePadRenderer;
			else if (item == ItemRegistry.LASER_POINTER.get())
				renderer = laserPointerRenderer;
			else
				return;
			HumanoidArm handSide = mc.player.getMainArm();
			if (ev.getHand() == InteractionHand.OFF_HAND)
				handSide = handSide.getOpposite();
			
			if (renderer.render(ev.getPoseStack(), ev.getItemStack(), (handSide == HumanoidArm.RIGHT) ? 1.0f : -1.0f, ev.getSwingProgress(), ev.getEquipProgress(), ev.getMultiBufferSource(), ev.getPackedLight())) {
				ev.setCanceled(true);
			}
		}
	}
	
	@SubscribeEvent
	public void onWorldUnload(LevelEvent.Unload ev) {
		Log.info("World unloaded; killing screens...");
		if (ev.getLevel() instanceof Level level) {
			ResourceLocation dim = level.dimension().location();
			for (int i = screenTracking.size() - 1; i >= 0; i--) {
				if (screenTracking.get(i).getLevel().dimension().location().equals(dim)) //Could be world == ev.getWorld()
					screenTracking.remove(i).unload();
			}
		}
	}
	
	public static BlockHitResult raycast(double dist) {
		Minecraft mc = Minecraft.getInstance();
		
		Vec3 start = mc.player.getEyePosition(1.0f);
		Vec3 lookVec = mc.player.getLookAngle();
		Vec3 end = start.add(lookVec.x * dist, lookVec.y * dist, lookVec.z * dist);
		
		return mc.level.clip(new ClipContext(start, end, ClipContext.Block.COLLIDER, ClipContext.Fluid.ANY, null));
	}
	
	private void updateInventory(NonNullList<ItemStack> inv, ItemStack heldStack, int cnt) {
		for (int i = 0; i < cnt; i++) {
			ItemStack item = inv.get(i);
			
			if (ItemRegistry.MINEPAD.isPresent()) {
				if (item.getItem() == ItemRegistry.MINEPAD.get()) {
					CompoundTag tag = item.getTag();
					
					if (tag != null && tag.contains("PadID"))
						updatePad(tag.getUUID("PadID"), tag, item == heldStack);
				}
			}
		}
	}
	
	private void updatePad(UUID id, CompoundTag tag, boolean isSelected) {
		PadData pd = padMap.get(id);
		
		if (pd != null)
			pd.isInHotbar = true;
		else if (isSelected && tag.contains("PadURL")) {
			pd = new PadData(tag.getString("PadURL"), id);
			padMap.put(id, pd);
			padList.add(pd);
		}
	}
	
	public MinePadRenderer getMinePadRenderer() {
		return minePadRenderer;
	}
	
	public PadData getPadByID(UUID id) {
		return padMap.get(id);
	}
	
	public static final class ScreenSidePair {
		
		public ScreenBlockEntity tes;
		public BlockSide side;
		
	}
	
	public boolean findScreenFromBrowser(CefBrowser browser, ScreenSidePair pair) {
		for (ScreenBlockEntity tes : screenTracking) {
			for (int i = 0; i < tes.screenCount(); i++) {
				ScreenBlockEntity.Screen scr = tes.getScreen(i);
				
				if (scr.browser == browser) {
					pair.tes = tes;
					pair.side = scr.side;
					return true;
				}
			}
		}
		
		return false;
	}
	
	private static Field findAdvancementToProgressField() {
		Field[] fields = ClientAdvancements.class.getDeclaredFields();
		Optional<Field> result = Arrays.stream(fields).filter(f -> f.getType() == Map.class).findAny();
		
		if (result.isPresent()) {
			try {
				Field ret = result.get();
				ret.setAccessible(true);
				return ret;
			} catch (Throwable t) {
				t.printStackTrace();
			}
		}
		
		Log.warning("ClientAdvancementManager.advancementToProgress field could not be found");
		return null;
	}
	
	@Override
	public BlockGetter getWorld(NetworkEvent.Context context) {
		BlockGetter senderLevel = super.getWorld(context);
		if (senderLevel == null) return Minecraft.getInstance().level;
		return senderLevel;
	}
	
	public static void onDrawSelection(RenderHighlightEvent event) {
		if (event.getTarget() instanceof BlockHitResult bhr) {
			BlockState state = Minecraft.getInstance().level.getBlockState(bhr.getBlockPos());
			if (state.getBlock() instanceof ScreenBlock screen) {
				Vector3i vec = new Vector3i(bhr.getBlockPos().getX(), bhr.getBlockPos().getY(), bhr.getBlockPos().getZ());
				BlockSide side = BlockSide.fromInt(bhr.getDirection().ordinal());
				Multiblock.findOrigin(
						Minecraft.getInstance().level, vec,
						side, null
				);
				
				BlockPos pos = new BlockPos(vec.x, vec.y, vec.z);
				BlockEntity be = Minecraft.getInstance().level.getBlockEntity(
						pos
				);
				if (be instanceof ScreenBlockEntity tes) {
					if (tes.getScreen(side) != null) {
						event.setCanceled(true);
					}
				}
			}
		}
	}
	
	/**
	 * KEYBINDS
	 **/
	public static final KeyMapping KEY_MOUSE = new KeyMapping("webdisplays.key.toggle_mouse", GLFW.GLFW_KEY_R, "key.categories.misc");
	static boolean rDown = false;
	public static boolean mouseOn = false;
	
	public static void onKeybindRegistry(RegisterKeyMappingsEvent event) {
		event.register(KEY_MOUSE);
	}
}