/*
 * This file was automatically generated by sel-utils and
 * released under the MIT License.
 * 
 * License: https://github.com/sel-project/sel-utils/blob/master/LICENSE
 * Repository: https://github.com/sel-project/sel-utils
 * Generated from https://github.com/sel-project/sel-utils/blob/master/xml/protocol/externalconsole2.xml
 */
/**
 * Packets regarding the server's console and commands.
 */
module sul.protocol.externalconsole2.connected;

import std.bitmanip : write, peek;
static import std.conv;
import std.system : Endian;
import std.typetuple : TypeTuple;
import std.typecons : Tuple;
import std.uuid : UUID;

import sul.utils.buffer;
import sul.utils.var;

static import sul.protocol.externalconsole2.types;

static if(__traits(compiles, { import sul.metadata.externalconsole2; })) import sul.metadata.externalconsole2;

alias Packets = TypeTuple!(ConsoleMessage, Command, PermissionDenied);

/**
 * Logs a message from the server's console. It may be the output of a command, a debug
 * message or any other message that the server retains able to be seen by the External
 * Console.
 */
class ConsoleMessage : Buffer {

	public enum ubyte ID = 4;

	public enum bool CLIENTBOUND = true;
	public enum bool SERVERBOUND = false;

	public enum string[] FIELDS = ["node", "timestamp", "logger", "message", "commandId"];

	/**
	 * Name of the node that created the log or an empty string if the log was created
	 * by the hub or by a server that isn't based on the hub-node layout.
	 */
	public string node;

	/**
	 * Unix timestamp in milliseconds that indicates the exact time when the log was generated
	 * by the server.
	 * The logs may not arrive in order when the server uses the hub-node layout or some
	 * other kind of proxy because the logs created by the nodes have an additional latency
	 * (the one between the hub, or proxy, and the node).
	 */
	public ulong timestamp;

	/**
	 * Name of the logger. It may be the world name if the log was generated by a world's
	 * message (like a broadcast or a chat message), the name of plugin (for example `plugin\test`)
	 * or the name of the package/module/class that generated the log (like `math.vector`
	 * or `event.world.player`).
	 */
	public string logger;

	/**
	 * The logged message. It may contain Minecraft's formatting codes which should be
	 * translated into appropriate colours and formatting (bold, italic and strikethrough)
	 * by the client implementation of the external console.
	 */
	public string message;

	/**
	 * Identifier given in Command.commandId if the log was generated by a command sent
	 * by the external console or -1 if the log was not related to a command sent from
	 * the external console.
	 */
	public int commandId;

	public pure nothrow @safe @nogc this() {}

	public pure nothrow @safe @nogc this(string node, ulong timestamp=ulong.init, string logger=string.init, string message=string.init, int commandId=int.init) {
		this.node = node;
		this.timestamp = timestamp;
		this.logger = logger;
		this.message = message;
		this.commandId = commandId;
	}

	public pure nothrow @safe ubyte[] encode(bool writeId=true)() {
		_buffer.length = 0;
		static if(writeId){ writeBigEndianUbyte(ID); }
		writeBigEndianUshort(cast(ushort)node.length); writeString(node);
		writeBigEndianUlong(timestamp);
		writeBigEndianUshort(cast(ushort)logger.length); writeString(logger);
		writeBigEndianUshort(cast(ushort)message.length); writeString(message);
		writeBigEndianInt(commandId);
		return _buffer;
	}

	public pure nothrow @safe void decode(bool readId=true)() {
		static if(readId){ ubyte _id; _id=readBigEndianUbyte(); }
		ushort b9z=readBigEndianUshort(); node=readString(b9z);
		timestamp=readBigEndianUlong();
		ushort b9zv=readBigEndianUshort(); logger=readString(b9zv);
		ushort bvcfz=readBigEndianUshort(); message=readString(bvcfz);
		commandId=readBigEndianInt();
	}

	public static pure nothrow @safe ConsoleMessage fromBuffer(bool readId=true)(ubyte[] buffer) {
		ConsoleMessage ret = new ConsoleMessage();
		ret._buffer = buffer;
		ret.decode!readId();
		return ret;
	}

	public override string toString() {
		return "ConsoleMessage(node: " ~ std.conv.to!string(this.node) ~ ", timestamp: " ~ std.conv.to!string(this.timestamp) ~ ", logger: " ~ std.conv.to!string(this.logger) ~ ", message: " ~ std.conv.to!string(this.message) ~ ", commandId: " ~ std.conv.to!string(this.commandId) ~ ")";
	}

}

/**
 * Executes a command remotely if the server allows it. If not a Permission Denied
 * is sent back. A good implementation of the external console client should never
 * send this packet if remoteCommands field in Welcome.Accepted is not true.
 */
class Command : Buffer {

	public enum ubyte ID = 5;

	public enum bool CLIENTBOUND = false;
	public enum bool SERVERBOUND = true;

	public enum string[] FIELDS = ["command", "commandId"];

	/**
	 * Command to execute on the server.
	 */
	public string command;

	/**
	 * Identifier for the command that will be sent in ConsoleMessage.commandId if the
	 * command generates an output.
	 */
	public uint commandId;

	public pure nothrow @safe @nogc this() {}

	public pure nothrow @safe @nogc this(string command, uint commandId=uint.init) {
		this.command = command;
		this.commandId = commandId;
	}

	public pure nothrow @safe ubyte[] encode(bool writeId=true)() {
		_buffer.length = 0;
		static if(writeId){ writeBigEndianUbyte(ID); }
		writeBigEndianUshort(cast(ushort)command.length); writeString(command);
		writeBigEndianUint(commandId);
		return _buffer;
	}

	public pure nothrow @safe void decode(bool readId=true)() {
		static if(readId){ ubyte _id; _id=readBigEndianUbyte(); }
		ushort y9bfz=readBigEndianUshort(); command=readString(y9bfz);
		commandId=readBigEndianUint();
	}

	public static pure nothrow @safe Command fromBuffer(bool readId=true)(ubyte[] buffer) {
		Command ret = new Command();
		ret._buffer = buffer;
		ret.decode!readId();
		return ret;
	}

	public override string toString() {
		return "Command(command: " ~ std.conv.to!string(this.command) ~ ", commandId: " ~ std.conv.to!string(this.commandId) ~ ")";
	}

}

/**
 * Bodyless packet only sent in response to Command when the server doesn't allow the
 * execution of remote commands through the external console. A good implementation
 * of the external console client should never receive this packet avoiding the use
 * of the Command packet when the remoteCommands field is false.
 */
class PermissionDenied : Buffer {

	public enum ubyte ID = 6;

	public enum bool CLIENTBOUND = true;
	public enum bool SERVERBOUND = false;

	public enum string[] FIELDS = [];

	public pure nothrow @safe ubyte[] encode(bool writeId=true)() {
		_buffer.length = 0;
		static if(writeId){ writeBigEndianUbyte(ID); }
		return _buffer;
	}

	public pure nothrow @safe void decode(bool readId=true)() {
		static if(readId){ ubyte _id; _id=readBigEndianUbyte(); }
	}

	public static pure nothrow @safe PermissionDenied fromBuffer(bool readId=true)(ubyte[] buffer) {
		PermissionDenied ret = new PermissionDenied();
		ret._buffer = buffer;
		ret.decode!readId();
		return ret;
	}

	public override string toString() {
		return "PermissionDenied()";
	}

}