ProtocolLib/ProtocolLib/src/main/java/com/comphenix/protocol/injector/player/PlayerInjectionHandler.java

package com.comphenix.protocol.injector.player;

import java.io.DataInputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.util.Set;
import org.bukkit.entity.Player;

import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketListener;
import com.comphenix.protocol.injector.GamePhase;
import com.comphenix.protocol.injector.PacketFilterManager.PlayerInjectHooks;

public interface PlayerInjectionHandler {
	/**
	 * How to handle a previously existing player injection.
	 * 
	 * @author Kristian
	 */
	public enum ConflictStrategy {
		/**
		 * Override it.
		 */
		OVERRIDE,
		
		/**
		 * Immediately exit.
		 */
		BAIL_OUT;
	}
	
	/**
	 * Retrieves how the server packets are read.
	 * @return Injection method for reading server packets.
	 */
	public abstract PlayerInjectHooks getPlayerHook();

	/**
	 * Retrieves how the server packets are read.
	 * @param phase - the current game phase.
	 * @return Injection method for reading server packets.
	 */
	public abstract PlayerInjectHooks getPlayerHook(GamePhase phase);

	/**
	 * Sets how the server packets are read.
	 * @param playerHook - the new injection method for reading server packets.
	 */
	public abstract void setPlayerHook(PlayerInjectHooks playerHook);

	/**
	 * Sets how the server packets are read.
	 * @param phase - the current game phase.
	 * @param playerHook - the new injection method for reading server packets.
	 */
	public abstract void setPlayerHook(GamePhase phase, PlayerInjectHooks playerHook);

	/**
	 * Add an underlying packet handler of the given ID.
	 * @param packetID - packet ID to register.
	 */
	public abstract void addPacketHandler(int packetID);

	/**
	 * Remove an underlying packet handler of ths ID.  
	 * @param packetID - packet ID to unregister.
	 */
	public abstract void removePacketHandler(int packetID);

	/**
	 * Retrieve a player by its DataInput connection.
	 * @param inputStream - the associated DataInput connection.
	 * @return The player.
	 * @throws InterruptedException If the thread was interrupted during the wait.
	 */
	public abstract Player getPlayerByConnection(DataInputStream inputStream)
			throws InterruptedException;

	/**
	 * Initialize a player hook, allowing us to read server packets.
	 * <p>
	 * This call will  be ignored if there's no listener that can receive the given events.
	 * @param player - player to hook.
	 * @param strategy - how to handle injection conflicts.
	 */
	public abstract void injectPlayer(Player player, ConflictStrategy strategy);

	/**
	 * Invoke special routines for handling disconnect before a player is uninjected.
	 * @param player - player to process.
	 */
	public abstract void handleDisconnect(Player player);

	/**
	 * Unregisters the given player.
	 * @param player - player to unregister.
	 * @return TRUE if a player has been uninjected, FALSE otherwise.
	 */
	public abstract boolean uninjectPlayer(Player player);

	/**
	 * Unregisters a player by the given address.
	 * <p>
	 * If the server handler has been created before we've gotten a chance to unject the player,
	 * the method will try a workaround to remove the injected hook in the NetServerHandler.
	 * 
	 * @param address - address of the player to unregister.
	 * @return TRUE if a player has been uninjected, FALSE otherwise.
	 */
	public abstract boolean uninjectPlayer(InetSocketAddress address);

	/**
	 * Send the given packet to the given reciever.
	 * @param reciever - the player receiver.
	 * @param packet - the packet to send.
	 * @param filters - whether or not to invoke the packet filters.
	 * @throws InvocationTargetException If an error occured during sending.
	 */
	public abstract void sendServerPacket(Player reciever, PacketContainer packet, boolean filters)
			throws InvocationTargetException;

	/**
	 * Process a packet as if it were sent by the given player.
	 * @param player - the sender.
	 * @param mcPacket - the packet to process.
	 * @throws IllegalAccessException If the reflection machinery failed.
	 * @throws InvocationTargetException If the underlying method caused an error.
	 */
	public abstract void recieveClientPacket(Player player, Object mcPacket)
			throws IllegalAccessException, InvocationTargetException;

	/**
	 * Determine if the given listeners are valid.
	 * @param version - the current Minecraft version, or NULL if unknown.
	 * @param listeners - listeners to check.
	 */
	public abstract void checkListener(Set<PacketListener> listeners);

	/**
	 * Determine if a listener is valid or not.
	 * <p>
	 * If not, a warning will be printed to the console. 
	 * @param version - the current Minecraft version, or NULL if unknown.
	 * @param listener - listener to check.
	 */
	public abstract void checkListener(PacketListener listener);

	/**
	 * Retrieve the current list of registered sending listeners.
	 * @return List of the sending listeners's packet IDs.
	 */
	public abstract Set<Integer> getSendingFilters();

	/**
	 * Close any lingering proxy injections.
	 */
	public abstract void close();

	/**
	 * Perform any action that must be delayed until the world(s) has loaded.
	 */
	public abstract void postWorldLoaded();
}