/**
 * Both requests and responses are sent as TCP packets. Their payload follows the following basic structure: 
 * 
 * |     Field    |                 Type                |        Value        |
 * |:------------:|:-----------------------------------:|:-------------------:|
 * | Size         | 32-bit little-endian Signed Integer | Varies, see below.  |
 * | ID           | 32-bit little-endian Signed Integer | Varies, see below.  |
 * | Type         | 32-bit little-endian Signed Integer | Varies, see below.  |
 * | Body         | Null-terminated ASCII String        | Varies, see below.  |
 * | Empty String | Null-terminated ASCII String        | 0x00                |
 * 
 * The packet size field is a 32-bit little endian integer, representing the length of the request in bytes. Note that the packet size field itself is not included when determining the size of the packet, so the value of this field is always 4 less than the packet's actual length. The minimum possible value for packet size is 10: 
 * |       Size      |            Containing            |
 * |:---------------:|:--------------------------------:|
 * | 4 Bytes         | ID Field                         |
 * | 4 Bytes         | Type Field                       |
 * | At least 1 Byte | Packet body (potentially empty)  |
 * | 1 Bytes         | Empty string terminator          |
 * 
 * The packet id field is a 32-bit little endian integer chosen by the client for each request. It may be set to any positive integer. When the server responds to the request, the response packet will have the same packet id as the original request (unless it is a failed SERVERDATA_AUTH_RESPONSE packet - see below.) It need not be unique, but if a unique packet id is assigned, it can be used to match incoming responses to their corresponding requests. 
 */
export interface Packet {
    packetName: string;
    id: number;
    type: 3 | 2 | 0;
    body: string;
}
/**
 * Typically, the first packet sent by the client will be a SERVERDATA_AUTH packet, which is used to authenticate the connection with the server. 
 * 
 * | Field |                                                 Contains                                                  |
 * |:-----:|:---------------------------------------------------------------------------------------------------------:|
 * | ID    | any positive integer, chosen by the client (will be mirrored back in the server's response)               |
 * | Type  | 3                                                                                                         |
 * | Body  | the RCON password of the server (if this matches the server's rcon_password cvar, the auth will succeed)  |
 * 
 */
export interface SERVERDATA_AUTH extends Packet {
    packetName: "SERVERDATA_AUTH";
    type: 3;
}

/**
 * This packet type represents a command issued to the server by a client. The response will vary depending on the command issued. 
 * 
 * | Field |                                           Contains                                           |
 * |:-----:|:--------------------------------------------------------------------------------------------:|
 * | ID    | any positive integer, chosen by the client (will be mirrored back in the server's response)  |
 * | Type  | 2                                                                                            |
 * | Body  | the command to be executed on the server             
 * 
*/
export interface SERVERDATA_EXECCOMMAND extends Packet {
    packetName: "SERVERDATA_EXECCOMMAND";
    type: 2;
}
/**
 * This packet is a notification of the connection's current auth status. When the server receives an auth request, it will respond with an empty SERVERDATA_RESPONSE_VALUE, followed immediately by a SERVERDATA_AUTH_RESPONSE indicating whether authentication succeeded or failed. Note that the status code is returned in the packet id field, so when pairing the response with the original auth request, you may need to look at the packet id of the preceeding SERVERDATA_RESPONSE_VALUE. 
 * 
 * | Field |                                               Contains                                                |
 * |:-----:|:-----------------------------------------------------------------------------------------------------:|
 * | ID    | If authentication was successful, the ID assigned by the request. If auth failed, -1 (0xFF FF FF FF)  |
 * | Type  | 2                                                                                                     |
 * | Body  | Empty string (0x00)                    
 * 
*/
export interface SERVERDATA_AUTH_RESPONSE extends Packet {
    packetName: "SERVERDATA_AUTH_RESPONSE",
    type: 2;
}
/**
 * A SERVERDATA_RESPONSE_VALUE packet is the response to a SERVERDATA_EXECCOMMAND request. 
 * Also note that requests executed asynchronously can possibly send their responses out of order[1] - using a unique ID to identify and associate the responses with their requests can circumvent this issue. 
 * 
 * | Field |                                         Contains                                          |
 * |:-----:|:-----------------------------------------------------------------------------------------:|
 * | ID    | The ID assigned by the original request                                                   |
 * | Type  | 0                                                                                         |
 * | Body  | The server's response to the original command. May be empty string (0x00) in some cases.  |
 * 
*/

export interface SERVERDATA_RESPONSE_VALUE extends Packet {
    packetName: "SERVERDATA_RESPONSE_VALUE";
    type: 0;
}

export type Packets = SERVERDATA_RESPONSE_VALUE | SERVERDATA_AUTH | SERVERDATA_EXECCOMMAND | SERVERDATA_AUTH_RESPONSE;

export class PacketWriter {
    private buffer!: Uint8Array;
    private dv: DataView;
    private packet!: Packets;
    private body: Uint8Array;
    constructor(packet: Packets) {
        this.packet = packet;
        this.body = new TextEncoder().encode(packet.body)
        this.buffer = new Uint8Array(this.body.byteLength + 14);
        this.dv = new DataView(this.buffer.buffer);
    }
    build() {
        this.dv.setInt32(0, this.body.byteLength + 10, true);
        this.dv.setInt32(4, this.packet.id, true);
        this.dv.setInt32(8, this.packet.type, true);
        this.buffer.set(this.body, 12);
        this.dv.setInt16(12 + this.body.byteLength, 0x00, true);

        return this.buffer;
    }
}

export class PacketReader {
    private buffer: Uint8Array;
    private dv: DataView;
    constructor(buffer: Uint8Array) {
        this.buffer = buffer;
        this.dv = new DataView(this.buffer.buffer);
    }

    read(fromServer = true): Packets {
        const size = this.dv.getInt32(0, true);
        const id = this.dv.getInt32(4, true);
        const type = this.dv.getInt32(8, true);

        const body = this.buffer.subarray(12, this.buffer.byteLength - 2);
        const text = new TextDecoder().decode(body);

        let packet = {
            packetName: "",
            id,
            type: 0,
            body: text
        }
        if (type == 3) {
            packet.type = 3;
            packet.packetName = "SERVERDATA_AUTH";
        } else if (type == 2) {
            packet.type = 2;
            if (fromServer) {
                packet.packetName = "SERVERDATA_AUTH_RESPONSE"
            } else {
                packet.packetName = "SERVERDATA_EXECCOMMAND"
            }
        } else if (type == 0) {
            packet.type = 0;
            packet.packetName = "SERVERDATA_RESPONSE_VALUE"
        }

        return packet as Packets;
    }
}