package me.dasneueupdate.nukkitnuller.utils;

import java.util.Random;
import java.util.zip.DataFormatException;

import com.nukkitx.network.VarInts;
import com.nukkitx.network.raknet.RakNetPriority;
import com.nukkitx.network.raknet.RakNetReliability;
import com.nukkitx.protocol.util.Zlib;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.util.AsciiString;
import io.netty.util.internal.ThreadLocalRandom;
import wode.ProfileHelper;

public class PacketGenerator {
	private static final Random RAND = new Random();
	private static final Zlib zlib = Zlib.DEFAULT;
	public static void encodeLoginPacket(ByteBuf buffer,int protocolversion,AsciiString chainData,AsciiString skinData) {
		buffer.writeByte(0x01);

		buffer.writeInt(protocolversion);

		VarInts.writeUnsignedInt(buffer, chainData.length() + skinData.length() + 8);

		writeLEAsciiString(buffer, chainData);
		writeLEAsciiString(buffer, skinData);
	}
	public static EncapsulatedPacket[] generateLoginPacket(String displayname,String ip,int port) {
		AsciiString[] auth = ProfileHelper.randomAuthData(displayname,ip, port);
		AsciiString chaindata = auth[0];
		AsciiString skindata = auth[1];
		ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer(1, 55900);
		encodeLoginPacket(buffer, 389, chaindata, skindata);
		ByteBuf source = PooledByteBufAllocator.DEFAULT.buffer(1, 55900);
		VarInts.writeUnsignedInt(source, buffer.readableBytes());
		source.writeBytes(buffer);
		buffer.release();
		try {
			source = zlib.deflate(source);
		} catch (DataFormatException e) {
			e.printStackTrace();
		}
		ByteBuf finalpayload = PooledByteBufAllocator.DEFAULT.directBuffer(source.readableBytes() + 9);
		finalpayload.writeByte(0xfe);
		finalpayload.writeBytes(source);
		source.release();
		EncapsulatedPacket[] packets = createEncapsulated(finalpayload);
		finalpayload.release();
		return packets;
	}
	public static byte[] BytebufferToArray(ByteBuf buf) {
		byte[] bytes = new byte[buf.readableBytes()];
		for (int i = 0;i < bytes.length;i++) {
			bytes[i] = buf.getByte(i);
		}
		return bytes;
	}
	private static EncapsulatedPacket[] createEncapsulated(ByteBuf buffer) {
		int maxLength = 1463;
		RakNetPriority priority = RakNetPriority.MEDIUM;
		RakNetReliability reliability = RakNetReliability.RELIABLE_ORDERED;
		int orderingChannel = 0;
		int splitIndexUpdater = 0;
		ByteBuf[] buffers;
		int splitId = 0;

		if (buffer.readableBytes() > maxLength) {
			// Packet requires splitting
			// Adjust reliability
			switch (reliability) {
			case UNRELIABLE:
				reliability = RakNetReliability.RELIABLE;
				break;
			case UNRELIABLE_SEQUENCED:
				reliability = RakNetReliability.RELIABLE_SEQUENCED;
				break;
			case UNRELIABLE_WITH_ACK_RECEIPT:
				reliability = RakNetReliability.RELIABLE_WITH_ACK_RECEIPT;
				break;
			}

			int split = ((buffer.readableBytes() - 1) / maxLength) + 1;
			buffer.retain(split);

			buffers = new ByteBuf[split];
			for (int i = 0; i < split; i++) {
				buffers[i] = buffer.readSlice(Math.min(maxLength, buffer.readableBytes()));
			}
			if (buffer.isReadable()) {
				throw new IllegalStateException("Buffer still has bytes to read!");
			}

			// Allocate split ID
			splitId = splitIndexUpdater;
			splitIndexUpdater++;
		} else {
			buffers = new ByteBuf[]{buffer.readRetainedSlice(buffer.readableBytes())};
		}

		// Set meta
		int orderingIndex = 2;
		// Now create the packets.
		int reliabilityIndex = 3;
		EncapsulatedPacket[] packets = new EncapsulatedPacket[buffers.length];
		for (int i = 0, parts = buffers.length; i < parts; i++) {
			EncapsulatedPacket packet = new EncapsulatedPacket();
			packet.buffer = buffers[i];
			packet.orderingChannel = (short) orderingChannel;
			packet.orderingIndex = orderingIndex;
			//packet.setSequenceIndex(sequencingIndex);
			packet.reliability = reliability;
			packet.priority = priority;
			packet.reliabilityIndex = reliabilityIndex;
			reliabilityIndex++;
			if (parts > 1) {
				packet.split = true;
				packet.partIndex = i;
				packet.partCount = parts;
				packet.partId = splitId;
			}
			packets[i] = packet;
		}
		return packets;
	}
	public static String getString(int l) {
		String allowed = "abcdefghijklmopqrstuvwxyz123456789";
		String out = "";
		for (int i = 0;i < l;i++) {
			out += String.valueOf(allowed.charAt(RAND.nextInt(allowed.length() - 1)));
		}
		return out;
	}
	public static void writeLEAsciiString(ByteBuf buffer, AsciiString string) {
		buffer.writeIntLE(string.length());
		buffer.writeBytes(string.toByteArray());
	}
}